/** 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;
}
/** Set flags on a lock (user interface).
* \verbatim
* This implements @lset.
* \endverbatim
* \param player the enactor.
* \param what string in the form obj/lock.
* \param flags list of flags to set.
*/
void
do_lset(dbref player, char *what, char *flags)
{
dbref thing;
lock_list *l;
char *lname;
int flag;
int unset = 0;
if ((lname = strchr(what, '/')) == NULL) {
notify(player, T("No lock name given."));
return;
}
*lname++ = '\0';
if ((thing = match_controlled(player, what)) == NOTHING)
return;
if (*flags == '!') {
unset = 1;
flags++;
}
if ((flag = string_to_lockflag(flags)) < 0) {
notify(player, T("Unrecognized lock flag."));
return;
}
l = getlockstruct_noparent(thing, lname);
if (!l || !Can_Read_Lock(player, thing, L_TYPE(l))) {
notify(player, T("No such lock."));
return;
}
if (!can_write_lock(player, thing, l)) {
notify(player, T("Permission denied."));
return;
}
if (unset)
L_FLAGS(l) &= ~flag;
else
L_FLAGS(l) |= flag;
if (!Quiet(player) && !(Quiet(thing) && (Owner(thing) == player)))
notify_format(player, "%s/%s - %s.", Name(thing), L_TYPE(l),
unset ? T("lock flags unset") : T("lock flags set"));
if (!IsPlayer(thing)) {
char lmbuf[1024];
ModTime(thing) = mudtime;
snprintf(lmbuf, 1023, "lflags - %s[#%d]", flags, player);
lmbuf[strlen(lmbuf)+1] = '\0';
set_lmod(thing, lmbuf);
}
}
/** Set flags on a lock (user interface).
* \verbatim
* This implements @lset.
* \endverbatim
* \param player the enactor.
* \param what string in the form obj/lock.
* \param flags list of flags to set.
*/
void
do_lset(dbref player, char *what, char *flags)
{
dbref thing;
lock_list *l;
char *lname;
privbits flag;
bool unset = 0;
if ((lname = strchr(what, '/')) == NULL) {
notify(player, T("No lock name given."));
return;
}
*lname++ = '\0';
if ((thing = match_controlled(player, what)) == NOTHING)
return;
if (*flags == '!') {
unset = 1;
flags++;
}
if (string_to_lockflag(player, flags, &flag) < 0) {
notify(player, T("Unrecognized lock flag."));
return;
}
l = getlockstruct_noparent(thing, lname);
if (!l || !Can_Read_Lock(player, thing, L_TYPE(l))) {
notify(player, T("No such lock."));
return;
}
if (!can_write_lock(player, thing, l)) {
notify(player, T("Permission denied."));
return;
}
if (unset)
L_FLAGS(l) &= ~flag;
else
L_FLAGS(l) |= flag;
if (!Quiet(player) && !(Quiet(thing) && (Owner(thing) == player)))
notify_format(player, "%s/%s - %s.", AName(thing, AN_SYS, NULL), L_TYPE(l),
unset ? T("lock flags unset") : T("lock flags set"));
if (!IsPlayer(thing))
ModTime(thing) = mudtime;
}
/** Delete a lock from an object (primitive).
* Another primitive routine.
* \param player the enactor, for permission checking.
* \param thing object on which to remove the lock.
* \param type type of lock to remove.
*/
int
delete_lock(dbref player, dbref thing, lock_type type)
{
lock_list *ll, **llp;
if (!GoodObject(thing)) {
return 0;
}
llp = &(Locks(thing));
while (*llp && strcasecmp((*llp)->type, type) != 0) {
llp = &((*llp)->next);
}
if (*llp != NULL) {
if (can_write_lock(player, thing, *llp)) {
ll = *llp;
*llp = ll->next;
free_one_lock_list(ll);
return 1;
} else
return 0;
} else
return 1;
}
