/** Add a lock to an object (primitive).
* Set the lock type on thing to boolexp.
* This is a primitive routine, to be called by other routines.
* It will go somewhat wonky if given a NULL boolexp.
* It will allocate memory if called with a string that is not already
* in the lock table.
* \param player the enactor, for permission checking.
* \param thing object on which to set the lock.
* \param type type of lock to set.
* \param key lock boolexp pointer (should not be NULL!).
* \param flags lock flags.
* \retval 0 failure.
* \retval 1 success.
*/
int
add_lock(dbref player, dbref thing, lock_type type, boolexp key, int flags)
{
lock_list *ll, **t;
lock_type real_type = type;
if (!GoodObject(thing)) {
return 0;
}
ll = getlockstruct_noparent(thing, type);
if (ll) {
if (!can_write_lock(player, thing, ll)) {
free_boolexp(key);
return 0;
}
/* We're replacing an existing lock. */
free_boolexp(ll->key);
ll->key = key;
ll->creator = player;
if (flags != -1)
ll->flags = flags;
} else {
ll = next_free_lock();
if (!ll) {
/* Oh, this sucks */
do_log(LT_ERR, 0, 0, "Unable to malloc memory for lock_list!");
} else {
real_type = st_insert(type, &lock_names);
ll->type = real_type;
ll->key = key;
ll->creator = player;
if (flags == -1) {
const lock_list *l2 = get_lockproto(real_type);
if (l2)
ll->flags = l2->flags;
else
ll->flags = 0;
} else {
ll->flags = flags;
}
if (!can_write_lock(player, thing, ll)) {
st_delete(real_type, &lock_names);
free_boolexp(key);
return 0;
}
t = &Locks(thing);
while (*t && strcasecmp(L_TYPE(*t), L_TYPE(ll)) < 0)
t = &L_NEXT(*t);
L_NEXT(ll) = *t;
*t = ll;
}
}
return 1;
}
/** Add a lock to an object on db load.
* Set the lock type on thing to boolexp.
* Used only on db load, when we can't safely test the player's
* permissions because they're not loaded yet.
* This is a primitive routine, to be called by other routines.
* It will go somewhat wonky if given a NULL boolexp.
* It will allocate memory if called with a string that is not already
* in the lock table.
* \param player lock creator.
* \param thing object on which to set the lock.
* \param type type of lock to set.
* \param key lock boolexp pointer (should not be NULL!).
* \param flags lock flags.
* \retval 0 failure.
*/
int
add_lock_raw(dbref player, dbref thing, lock_type type, boolexp key,
privbits flags)
{
lock_list *ll, **t;
lock_type real_type = type;
if (!GoodObject(thing)) {
return 0;
}
ll = next_free_lock(Locks(thing));
if (!ll) {
/* Oh, this sucks */
do_log(LT_ERR, 0, 0, "Unable to malloc memory for lock_list!");
} else {
real_type = st_insert(type, &lock_names);
ll->type = real_type;
ll->key = key;
ll->creator = player;
if (flags == LF_DEFAULT) {
const lock_list *l2 = get_lockproto(real_type);
if (l2)
ll->flags = l2->flags;
else
ll->flags = 0;
} else {
ll->flags = flags;
}
t = &Locks(thing);
while (*t && strcasecmp(L_TYPE(*t), L_TYPE(ll)) < 0)
t = &L_NEXT(*t);
L_NEXT(ll) = *t;
*t = ll;
}
return 1;
}
