static dbref
make_player(const char *name, const char *password, const char *host,
const char *ip)
{
dbref player;
char temp[SBUF_LEN];
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
player = new_object();
/* initialize everything */
set_name(player, name);
Location(player) = PLAYER_START;
Home(player) = PLAYER_START;
Owner(player) = player;
Parent(player) = NOTHING;
Type(player) = TYPE_PLAYER;
Flags(player) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.player_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", player, flagname, 0);
}
}
if (Suspect_Site(host, player) || Suspect_Site(ip, player))
set_flag_internal(player, "SUSPECT");
set_initial_warnings(player);
/* Modtime tracks login failures */
ModTime(player) = (time_t) 0;
(void) atr_add(player, pword_attr, password_hash(password, NULL), GOD, 0);
giveto(player, START_BONUS); /* starting bonus */
(void) atr_add(player, "LAST", show_time(mudtime, 0), GOD, 0);
(void) atr_add(player, "LASTSITE", host, GOD, 0);
(void) atr_add(player, "LASTIP", ip, GOD, 0);
(void) atr_add(player, "LASTFAILED", " ", GOD, 0);
snprintf(temp, sizeof temp, "%d", START_QUOTA);
(void) atr_add(player, "RQUOTA", temp, GOD, 0);
(void) atr_add(player, "MAILCURF", "0", GOD,
AF_LOCKED | AF_NOPROG | AF_WIZARD);
add_folder_name(player, 0, "inbox");
/* link him to PLAYER_START */
PUSH(player, Contents(PLAYER_START));
add_player(player);
add_lock(GOD, player, Basic_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
add_lock(GOD, player, Enter_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
add_lock(GOD, player, Use_Lock, parse_boolexp(player, "=me", Basic_Lock),
LF_DEFAULT);
current_state.players++;
local_data_create(player);
return player;
}
/** Check to see if an object has a good zone lock set.
* If it doesn't have a lock at all, set one of '=Zone'.
* \param player The object responsible for having the lock checked.
* \param zone the object whose lock needs to be checked.
* \param noisy if 1, notify player of automatic locking
*/
void
check_zone_lock(dbref player, dbref zone, int noisy)
{
boolexp key = getlock(zone, Zone_Lock);
if (key == TRUE_BOOLEXP) {
add_lock(GOD, zone, Zone_Lock, parse_boolexp(zone, "=me", Zone_Lock), -1);
if (noisy)
notify_format(player,
T
("Unlocked zone %s - automatically zone-locking to itself"),
unparse_object(player, zone));
} else if (eval_lock(Location(player), zone, Zone_Lock)) {
/* Does #0 and #2 pass it? If so, probably trivial elock */
if (eval_lock(PLAYER_START, zone, Zone_Lock) &&
eval_lock(MASTER_ROOM, zone, Zone_Lock)) {
if (noisy)
notify_format(player,
T("Zone %s really should have a more secure zone-lock."),
unparse_object(player, zone));
} else /* Probably inexact zone lock */
notify_format(player,
T
("Warning: Zone %s may have loose zone lock. Lock zones to =player, not player"),
unparse_object(player, zone));
}
}
/** Set/lock a lock (user interface).
* \verbatim
* This implements @lock.
* \endverbatim
* \param player the enactor.
* \param name name of object to lock.
* \param keyname key to lock the lock to, as a string.
* \param type type of lock to lock.
*/
void
do_lock(dbref player, const char *name, const char *keyname, lock_type type)
{
lock_type real_type;
dbref thing;
boolexp key;
/* check for '@lock <object>/<atr>' */
if (strchr(name, '/')) {
do_atrlock(player, name, "on");
return;
}
if (!keyname || !*keyname) {
do_unlock(player, name, type);
return;
}
switch (thing = match_result(player, name, NOTYPE, MAT_EVERYTHING)) {
case NOTHING:
notify(player, T("I don't see what you want to lock!"));
return;
case AMBIGUOUS:
notify(player, T("I don't know which one you want to lock!"));
return;
default:
if (!controls(player, thing)) {
notify(player, T("You can't lock that!"));
return;
}
if (IsGarbage(thing)) {
notify(player, T("Why would you want to lock garbage?"));
return;
}
break;
}
key = parse_boolexp(player, keyname, type);
/* do the lock */
if (key == TRUE_BOOLEXP) {
notify(player, T("I don't understand that key."));
} else {
if ((real_type = check_lock_type(player, thing, type)) != NULL) {
/* everything ok, do it */
if (add_lock(player, thing, real_type, key, LF_DEFAULT)) {
if (!AreQuiet(player, thing))
notify_format(player, T("%s(%s) - %s locked."),
AName(thing, AN_SYS, NULL), unparse_dbref(thing),
real_type);
if (!IsPlayer(thing))
ModTime(thing) = mudtime;
} else {
notify(player, T("Permission denied."));
/* Done by a failed add_lock() // free_boolexp(key); */
}
} else
free_boolexp(key);
}
}
// Can be used to set a type of lock on an object
void CHSInterface::SetLock(int objnum, int lockto, HS_LOCKTYPE lock)
{
#ifdef PENNMUSH // No change in code between versions
char tmp[32];
sprintf_s(tmp, "#%d", lockto);
switch (lock)
{
case LOCK_USE:
add_lock(GOD, objnum, Use_Lock, parse_boolexp(lockto, tmp, Use_Lock),
-1);
break;
case LOCK_ZONE:
add_lock(GOD, objnum, Zone_Lock,
parse_boolexp(lockto, tmp, Zone_Lock), -1);
break;
case LOCK_NORMAL:
default:
break;
}
#endif
#if defined(TM3) || defined(MUX)
char tmp[SBUF_SIZE];
BOOLEXP *key;
snprintf(tmp, SBUF_SIZE - 1, "#%d", lockto);
key = parse_boolexp(objnum, tmp, 1);
switch (lock)
{
case LOCK_USE:
atr_add_raw(objnum, A_LUSE, unparse_boolexp_quiet(objnum, key));
break;
case LOCK_ZONE:
atr_add_raw(objnum, A_LCONTROL, unparse_boolexp_quiet(objnum, key));
case LOCK_NORMAL:
break;
}
free_boolexp(key);
#endif
}
void
set_lock_property(dbref player, const char *type, char *lok)
{
struct boolexp *p;
if (!lok || !*lok) {
p = TRUE_BOOLEXP;
} else {
p = parse_boolexp(-1, (dbref) 1, lok, 1);
}
set_property(player, type, PROP_LOKTYP, (PTYPE) p);
}
void
prim_parselock(PRIM_PROTOTYPE)
{
struct boolexp *lok;
CHECKOP(1);
oper1 = POP(); /* string: lock string */
CHECKOFLOW(1);
if (oper1->type != PROG_STRING)
abort_interp("Invalid argument");
if (oper1->data.string != (struct shared_string *) NULL) {
lok = parse_boolexp(fr->descr, ProgUID, oper1->data.string->data, 0);
} else {
lok = TRUE_BOOLEXP;
}
CLEAR(oper1);
PushLock(lok);
}
HS_DBREF CHSInterface::GetLock(int objnum, HS_LOCKTYPE lock)
{
#ifdef PENNMUSH // No change in code between versions
boolexp boolExp = getlock(objnum, Use_Lock);
if (boolExp == TRUE_BOOLEXP)
{
return NOTHING;
}
else
{
return strtodbref(unparse_boolexp(objnum, boolExp, UB_DBREF));
}
#endif
#if defined(TM3) || defined(MUX)
char *value;
BOOLEXP *key;
int aowner, aflags;
dbref lockobj;
#ifdef TM3
int alen;
value = atr_get((dbref) objnum, A_LUSE, &aowner, &aflags, &alen);
#else
value = atr_get((dbref) objnum, A_LUSE, &aowner, &aflags);
#endif
key = parse_boolexp((dbref) objnum, value, 1);
free_lbuf(value);
if (key == TRUE_BOOLEXP)
{
free_boolexp(key);
return NOTHING;
}
else
{
lockobj = key->thing;
free_boolexp(key);
return lockobj;
}
#endif
}
static int db_write_object(FILE * f, dbref i, int db_format, int flags)
{
ATTR *a;
char *got, *as;
dbref aowner;
int ca, aflags, save, j;
BOOLEXP *tempbool;
if(!(flags & V_ATRNAME))
putstring(f, Name(i));
putref(f, Location(i));
if(flags & V_ZONE)
putref(f, Zone(i));
putref(f, Contents(i));
putref(f, Exits(i));
if(flags & V_LINK)
putref(f, Link(i));
putref(f, Next(i));
if(!(flags & V_ATRKEY)) {
got = atr_get(i, A_LOCK, &aowner, &aflags);
tempbool = parse_boolexp(GOD, got, 1);
free_lbuf(got);
putboolexp(f, tempbool);
if(tempbool)
free_bool(tempbool);
}
putref(f, Owner(i));
if(flags & V_PARENT)
putref(f, Parent(i));
if(!(flags & V_ATRMONEY))
putref(f, Pennies(i));
putref(f, Flags(i));
if(flags & V_XFLAGS)
putref(f, Flags2(i));
if(flags & V_3FLAGS)
putref(f, Flags3(i));
if(flags & V_POWERS) {
putref(f, Powers(i));
putref(f, Powers2(i));
}
/*
* write the attribute list
*/
if((!(flags & V_GDBM)) || (mudstate.panicking == 1)) {
for(ca = atr_head(i, &as); ca; ca = atr_next(&as)) {
save = 0;
a = atr_num(ca);
if(a)
j = a->number;
else
j = -1;
if(j > 0) {
switch (j) {
case A_NAME:
if(flags & V_ATRNAME)
save = 1;
break;
case A_LOCK:
if(flags & V_ATRKEY)
save = 1;
break;
case A_LIST:
case A_MONEY:
break;
default:
save = 1;
}
}
if(save) {
got = atr_get_raw(i, j);
fprintf(f, ">%d\n", j);
putstring(f, got);
}
}
fprintf(f, "<\n");
}
return 0;
}
int
db_get_single_prop(FILE * f, dbref obj, int pos)
{
char getprop_buf[BUFFER_LEN * 3];
char *name, *flags, *value, *p;
int tpos = 0;
bool do_diskbase_propvals;
PData pdat;
#ifdef DISKBASE
do_diskbase_propvals = tp_diskbase_propvals;
#else
do_diskbase_propvals = 0;
#endif
if (pos) {
fseek(f, pos, 0);
} else if (do_diskbase_propvals) {
tpos = ftell(f);
}
name = fgets(getprop_buf, sizeof(getprop_buf), f);
if (!name) {
fprintf(stderr, "PANIC: Error reading property in from db file.\n");
abort();
}
if (*name == '*') {
if (!strcmp(name, "*End*\n")) {
return 0;
}
}
flags = index(name, PROP_DELIMITER);
if (!flags) { /* this usually means the db file has new lines in the
* middle of properties. Something like this can be
* salvaged by editing the props in question.
*/
fprintf(stderr,
"PANIC: Unable to find prop flags while loading props.\n");
abort();
}
*flags++ = '\0';
value = index(flags, PROP_DELIMITER);
if (!value) {
fprintf(stderr,
"PANIC: Unable to find prop value while loading props.\n");
abort();
}
*value++ = '\0';
p = index(value, '\n');
if (p)
*p = '\0';
if (!number(flags)) {
fprintf(stderr, "PANIC: Prop flag was not a number. DB error.\n");
abort();
}
pdat.flags = atoi(flags);
switch (pdat.flags & PROP_TYPMASK) {
case PROP_STRTYP:
if (!do_diskbase_propvals || pos) {
pdat.flags &= ~PROP_ISUNLOADED;
#if defined(COMPRESS) && defined(ARCHAIC_DATABASES)
if (!(pdat.flags & PROP_COMPRESSED))
value = (char *) old_uncompress(value);
#endif
pdat.data.str = value;
} else {
pdat.flags |= PROP_ISUNLOADED;
pdat.data.pos = tpos;
}
break;
case PROP_LOKTYP:
if (!do_diskbase_propvals || pos) {
pdat.flags &= ~PROP_ISUNLOADED;
pdat.data.lok = parse_boolexp(-1, (dbref) 1, value, 32767);
} else {
pdat.flags |= PROP_ISUNLOADED;
pdat.data.pos = tpos;
}
break;
case PROP_INTTYP:
if (!number(value)) {
fprintf(stderr, "PANIC: INT prop had non-int value in db.\n");
abort();
}
pdat.data.val = atoi(value);
break;
case PROP_FLTTYP:
if (!number(value) && !ifloat(value)) {
char *tpnt = value;
int dtemp = 0;
if ((*tpnt == '+') || (*tpnt == '-')) {
if (*tpnt == '+') {
dtemp = 0;
} else {
dtemp = 1;
}
tpnt++;
}
tpnt[0] = toupper(tpnt[0]);
tpnt[1] = toupper(tpnt[1]);
tpnt[2] = toupper(tpnt[2]);
if (!strncmp(tpnt, "INF", 3)) {
if (!dtemp)
pdat.data.fval = INF;
else
pdat.data.fval = NINF;
} else {
if (!strncmp(tpnt, "NAN", 3)) {
pdat.data.fval = NAN;
} else {
fprintf(stderr,
"PANIC:Float prop contained invalid value.\n");
abort();
}
}
} else {
sscanf(value, "%lg", (double *) &pdat.data.fval);
}
break;
case PROP_REFTYP:
if (!number(value)) {
fprintf(stderr,
"PANIC:Ref prop contained non-numeric value.\n");
abort();
}
pdat.data.ref = atoi(value);
break;
case PROP_DIRTYP:
break;
}
set_property_nofetch(obj, name, &pdat, 1);
return 1;
}
/** Set/lock a lock (user interface).
* \verbatim
* This implements @lock.
* \endverbatim
* \param player the enactor.
* \param name name of object to lock.
* \param keyname key to lock the lock to, as a string.
* \param type type of lock to lock.
*/
void
do_lock(dbref player, const char *name, const char *keyname, lock_type type)
{
lock_type real_type;
dbref thing;
boolexp key;
char *sp;
/* check for '@lock <object>/<atr>' */
sp = strchr(name, '/');
if (sp) {
do_atrlock(player, name, keyname, 0);
return;
}
if (!keyname || !*keyname) {
do_unlock(player, name, type);
return;
}
switch (thing = match_result(player, name, NOTYPE, MAT_EVERYTHING)) {
case NOTHING:
notify(player, T("I don't see what you want to lock!"));
return;
case AMBIGUOUS:
notify(player, T("I don't know which one you want to lock!"));
return;
default:
if (!controls(player, thing)) {
notify(player, T("You can't lock that!"));
return;
}
if (IsGarbage(thing)) {
notify(player, T("Why would you want to lock garbage?"));
return;
}
break;
}
key = parse_boolexp(player, keyname, type);
/* do the lock */
if (key == TRUE_BOOLEXP) {
notify(player, T("I don't understand that key."));
} else {
if ((real_type = check_lock_type(player, thing, type)) != NULL) {
/* everything ok, do it */
if (add_lock(player, thing, real_type, key, -1)) {
if (!AreQuiet(player, thing))
notify_format(player, T("%s(%s) - %s locked."), Name(thing),
unparse_dbref(thing), real_type);
if (!IsPlayer(thing)) {
char lmbuf[1024];
ModTime(thing) = mudtime;
snprintf(lmbuf, 1023, "%s lock[#%d]", real_type, player);
lmbuf[strlen(lmbuf)+1] = '\0';
set_lmod(thing, lmbuf);
}
} else {
notify(player, T("Permission denied."));
free_boolexp(key);
}
} else
free_boolexp(key);
}
}
