/** Add a player's alias list to the player list htab.
* \param player dbref of player to add.
* \param alias list of names ot use as hash table keys for player,
* semicolon-separated.
*/
void
add_player_alias(dbref player, const char *alias)
{
char tbuf1[BUFFER_LEN], *s, *sp;
if (!hft_initialized)
init_hft();
if (!alias) {
add_player(player);
return;
}
mush_strncpy(tbuf1, alias, BUFFER_LEN);
s = trim_space_sep(tbuf1, ALIAS_DELIMITER);
while (s) {
sp = split_token(&s, ALIAS_DELIMITER);
while (sp && *sp && *sp == ' ')
sp++;
if (sp && *sp) {
dbref *p;
p = slab_malloc(player_dbref_slab, NULL);
if (!p)
mush_panic("Unable to allocate memory in plyrlist!");
*p = player;
hashadd(strupper(sp), p, &htab_player_list);
}
}
}
/** Is a alias a valid player alias-list for thing?
* It must be a semicolon-separated list of valid player names
* with no more than than MAX_ALIASES names, if the player isn't
* a wizard.
* \param alias list to check.
* \param player player for permission checks.
* \param thing player who is being aliased.
* \return One of the OPAE_* constants defined in hdrs/attrib.h
*/
enum opa_error
ok_player_alias(const char *alias, dbref player, dbref thing)
{
char tbuf1[BUFFER_LEN], *s, *sp;
int cnt = 0;
if (!alias || !*alias)
return OPAE_NULL;
strncpy(tbuf1, alias, BUFFER_LEN - 1);
tbuf1[BUFFER_LEN - 1] = '\0';
s = trim_space_sep(tbuf1, ALIAS_DELIMITER);
while (s) {
sp = split_token(&s, ALIAS_DELIMITER);
while (sp && *sp && *sp == ' ')
sp++;
if (!sp || !*sp)
return OPAE_NULL; /* No null aliases */
if (!ok_player_name(sp, player, thing))
return OPAE_INVALID;
cnt++;
}
if (Wizard(player))
return OPAE_SUCCESS;
if (cnt > MAX_ALIASES)
return OPAE_TOOMANY;
return OPAE_SUCCESS;
}
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;
}
/** Given a list of warnings, return the bitmask that represents it.
* \param player dbref to report errors to, or NOTHING.
* \param warnings the string of warning names
* \return a warning bitmask
*/
warn_type
parse_warnings(dbref player, const char *warnings)
{
int found = 0;
warn_type flags, negate_flags;
char tbuf1[BUFFER_LEN];
char *w, *s;
tcheck *c;
flags = W_NONE;
negate_flags = W_NONE;
if (warnings && *warnings) {
strcpy(tbuf1, warnings);
/* Loop through whatever's listed and add on those warnings */
s = trim_space_sep(tbuf1, ' ');
w = split_token(&s, ' ');
while (w && *w) {
found = 0;
if (*w == '!') {
/* Found a negated warning */
w++;
for (c = checklist; c->name; c++) {
if (!strcasecmp(w, c->name)) {
negate_flags |= c->flag;
found++;
}
}
} else {
for (c = checklist; c->name; c++) {
if (!strcasecmp(w, c->name)) {
flags |= c->flag;
found++;
}
}
}
/* At this point, we haven't matched any warnings. */
if (!found && player != NOTHING) {
notify_format(player, T("Unknown warning: %s"), w);
}
w = split_token(&s, ' ');
}
/* If we haven't matched anything, don't change the player's stuff */
if (!found)
return -1;
return flags & ~negate_flags;
} else
return 0;
}
/** Remove a player from the player list htab.
* \param player dbref of player to remove.
* \param alias key to remove if given.
*/
void
delete_player(dbref player, const char *alias)
{
if (!hft_initialized) {
init_hft();
return;
}
if (alias) {
/* This could be a compound alias, in which case we need to delete
* them all, but we shouldn't delete the player's own name!
*/
char tbuf1[BUFFER_LEN], *s, *sp;
mush_strncpy(tbuf1, alias, BUFFER_LEN);
s = trim_space_sep(tbuf1, ALIAS_DELIMITER);
while (s) {
sp = split_token(&s, ALIAS_DELIMITER);
while (sp && *sp && *sp == ' ')
sp++;
if (sp && *sp && strcasecmp(sp, Name(player)))
hashdelete(strupper(sp), &htab_player_list);
}
} else
hashdelete(strupper(Name(player)), &htab_player_list);
}
/** Create an exit.
* This function opens an exit and optionally links it.
* \param player the enactor.
* \param direction the name of the exit.
* \param linkto the room to link to, as a string.
* \param pseudo a phony location for player if a back exit is needed. This is bpass by do_open() as the source room of the back exit.
* \return dbref of the new exit, or NOTHING.
*/
dbref
do_real_open(dbref player, const char *direction, const char *linkto,
dbref pseudo)
{
dbref loc =
(pseudo !=
NOTHING) ? pseudo : (IsExit(player) ? Source(player) : (IsRoom(player) ?
player :
Location(player)));
dbref new_exit;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
char *name = NULL;
char *alias = NULL;
if (!command_check_byname(player, "@dig")) {
notify(player, T("Permission denied."));
return NOTHING;
}
if ((loc == NOTHING) || (!IsRoom(loc))) {
notify(player, T("Sorry, you can only make exits out of rooms."));
return NOTHING;
}
if (Going(loc)) {
notify(player, T("You can't make an exit in a place that's crumbling."));
return NOTHING;
}
if (!*direction) {
notify(player, T("Open where?"));
return NOTHING;
} else
if (ok_object_name
((char *) direction, player, NOTHING, TYPE_EXIT, &name, &alias) < 1) {
notify(player, T("That's a strange name for an exit!"));
if (name)
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return NOTHING;
}
if (!Open_Anywhere(player) && !controls(player, loc)) {
notify(player, T("Permission denied."));
} else if (can_pay_fees(player, EXIT_COST)) {
/* create the exit */
new_exit = new_object();
/* initialize everything */
set_name(new_exit, name);
if (alias && *alias != ALIAS_DELIMITER)
atr_add(new_exit, "ALIAS", alias, player, 0);
Owner(new_exit) = Owner(player);
Zone(new_exit) = Zone(player);
Source(new_exit) = loc;
Type(new_exit) = TYPE_EXIT;
Flags(new_exit) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.exit_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", new_exit, flagname, 0);
}
}
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
/* link it in */
PUSH(new_exit, Exits(loc));
/* and we're done */
notify_format(player, T("Opened exit %s"), unparse_dbref(new_exit));
/* check second arg to see if we should do a link */
if (linkto && *linkto != '\0') {
notify(player, T("Trying to link..."));
if ((loc = check_var_link(linkto)) == NOTHING)
loc = parse_linkable_room(player, linkto);
if (loc != NOTHING) {
if (!payfor(player, LINK_COST)) {
notify_format(player, T("You don't have enough %s to link."), MONIES);
} else {
/* it's ok, link it */
Location(new_exit) = loc;
notify_format(player, T("Linked exit #%d to #%d"), new_exit, loc);
}
}
}
current_state.exits++;
local_data_create(new_exit);
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(new_exit));
return new_exit;
}
if (name)
mush_free(name, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return NOTHING;
}
/** Create a thing.
* \verbatim
* This is the top-level function for @create.
* \endverbatim
* \param player the enactor.
* \param name name of thing to create.
* \param cost pennies spent in creation.
* \paran newdbref the (unparsed) dbref to give the object, or NULL to use the next free
* \return dbref of new thing, or NOTHING.
*/
dbref
do_create(dbref player, char *name, int cost, char *newdbref)
{
dbref loc;
dbref thing;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
if (*name == '\0') {
notify(player, T("Create what?"));
return NOTHING;
} else if (!ok_name(name, 0)) {
notify(player, T("That's a silly name for a thing!"));
return NOTHING;
} else if (cost < OBJECT_COST) {
cost = OBJECT_COST;
}
if (!make_first_free_wrapper(player, newdbref)) {
return NOTHING;
}
if (can_pay_fees(player, cost)) {
/* create the object */
thing = new_object();
/* initialize everything */
set_name(thing, name);
if (!IsExit(player)) /* Exits shouldn't have contents! */
Location(thing) = player;
else
Location(thing) = Source(player);
Owner(thing) = Owner(player);
Zone(thing) = Zone(player);
s_Pennies(thing, cost);
Type(thing) = TYPE_THING;
Flags(thing) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.thing_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", thing, flagname, 0);
}
}
/* home is here (if we can link to it) or player's home */
if ((loc = Location(player)) != NOTHING &&
(controls(player, loc) || Abode(loc))) {
Home(thing) = loc; /* home */
} else {
Home(thing) = Home(player); /* home */
}
/* link it in */
if (!IsExit(player))
PUSH(thing, Contents(player));
else
PUSH(thing, Contents(Source(player)));
/* and we're done */
notify_format(player, T("Created: Object %s."), unparse_dbref(thing));
current_state.things++;
local_data_create(thing);
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(thing));
return thing;
}
return NOTHING;
}
/** Create a room.
* \verbatim
* This is the top-level interface for @dig.
* \endverbatim
* \param player the enactor.
* \param name the name of the room to create.
* \param argv array of additional arguments to command
* (exit forward,exit back,newdbref)
* \param tport if 1, teleport the player to the new room.
* \return dbref of new room, or NOTHING.
*/
dbref
do_dig(dbref player, const char *name, char **argv, int tport)
{
dbref room;
char *flaglist, *flagname;
char flagbuff[BUFFER_LEN];
char *newdbref = NULL;
if (argv[3] && *argv[3]) {
newdbref = argv[3];
}
/* we don't need to know player's location! hooray! */
if (*name == '\0') {
notify(player, T("Dig what?"));
} else if (!ok_name(name, 0)) {
notify(player, T("That's a silly name for a room!"));
} else if (can_pay_fees(player, ROOM_COST)) {
if (!make_first_free_wrapper(player, newdbref)) {
return NOTHING;
}
room = new_object();
/* Initialize everything */
set_name(room, name);
Owner(room) = Owner(player);
Zone(room) = Zone(player);
Type(room) = TYPE_ROOM;
Flags(room) = new_flag_bitmask("FLAG");
strcpy(flagbuff, options.room_flags);
flaglist = trim_space_sep(flagbuff, ' ');
if (*flaglist != '\0') {
while (flaglist) {
flagname = split_token(&flaglist, ' ');
twiddle_flag_internal("FLAG", room, flagname, 0);
}
}
notify_format(player, T("%s created with room number %d."), name, room);
if (argv[1] && *argv[1]) {
char nbuff[MAX_COMMAND_LEN];
sprintf(nbuff, "#%d", room);
do_real_open(player, argv[1], nbuff, NOTHING);
}
if (argv[2] && *argv[2]) {
do_real_open(player, argv[2], "here", room);
}
current_state.rooms++;
local_data_create(room);
if (tport) {
/* We need to use the full command, because we need NO_TEL
* and Z_TEL checking */
char roomstr[MAX_COMMAND_LEN];
sprintf(roomstr, "#%d", room);
do_teleport(player, "me", roomstr, 0, 0); /* if flag, move the player */
}
queue_event(player, "OBJECT`CREATE", "%s", unparse_objid(room));
return room;
}
return NOTHING;
}
/** Parse access options into fields.
* \param opts access options to read from.
* \param who pointer to player to whom rule applies, or AMBIGUOUS.
* \param can pointer to flags of allowed actions.
* \param cant pointer to flags of disallowed actions.
* \param player enactor.
* \return number of options successfully parsed.
* Parse options and return the appropriate can and cant bits.
* Return the number of options successfully parsed.
* This makes a copy of the options string, so it's not modified.
*/
int
parse_access_options(const char *opts, dbref *who, uint32_t *can,
uint32_t *cant, dbref player)
{
char myopts[BUFFER_LEN];
char *p;
char *w;
acsflag *c;
int found, totalfound, first;
if (!opts || !*opts)
return 0;
strcpy(myopts, opts);
totalfound = 0;
first = 1;
if (who)
*who = AMBIGUOUS;
p = trim_space_sep(myopts, ' ');
while ((w = split_token(&p, ' '))) {
found = 0;
if (first && who) { /* Check for a character */
first = 0;
if (is_strict_integer(w)) { /* We have a dbref */
*who = parse_integer(w);
if (*who != AMBIGUOUS && !GoodObject(*who))
*who = AMBIGUOUS;
continue;
}
}
if (*w == '!') {
/* Found a negated warning */
w++;
for (c = acslist; c->name; c++) {
if (c->toggle && !strncasecmp(w, c->name, strlen(c->name))) {
*cant |= c->flag;
found++;
}
}
} else {
/* None is special */
if (!strncasecmp(w, "NONE", 4)) {
*cant = ACS_DEFAULT;
found++;
} else {
for (c = acslist; c->name; c++) {
if (!strncasecmp(w, c->name, strlen(c->name))) {
*can |= c->flag;
found++;
}
}
}
}
/* At this point, we haven't matched any warnings. */
if (!found) {
if (GoodObject(player))
notify_format(player, T("Unknown access option: %s"), w);
else
do_log(LT_ERR, GOD, GOD, "Unknown access flag: %s", w);
} else {
totalfound += found;
}
}
return totalfound;
}
/** Rename something.
* \verbatim
* This implements @name.
* \endverbatim
* \param player the enactor.
* \param name current name of object to rename.
* \param newname_ new name for object.
*/
void
do_name(dbref player, const char *name, char *newname_)
{
dbref thing;
char oldname[BUFFER_LEN];
char *newname = NULL;
char *alias = NULL;
PE_REGS *pe_regs;
if ((thing = match_controlled(player, name)) == NOTHING)
return;
/* check for bad name */
if ((*newname_ == '\0') || strchr(newname_, '[')) {
notify(player, T("Give it what new name?"));
return;
}
switch (Typeof(thing)) {
case TYPE_PLAYER:
switch (ok_object_name
(newname_, player, thing, TYPE_PLAYER, &newname, &alias)) {
case OPAE_INVALID:
case OPAE_NULL:
notify(player, T("You can't give a player that name or alias."));
if (newname)
mush_free(newname, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return;
case OPAE_TOOMANY:
notify(player, T("Too many aliases."));
mush_free(newname, "name.newname");
return;
case OPAE_SUCCESS:
break;
}
break;
case TYPE_EXIT:
if (ok_object_name(newname_, player, thing, TYPE_EXIT, &newname, &alias) !=
OPAE_SUCCESS) {
notify(player, T("That is not a reasonable name."));
if (newname)
mush_free(newname, "name.newname");
if (alias)
mush_free(alias, "name.newname");
return;
}
break;
case TYPE_THING:
case TYPE_ROOM:
if (!ok_name(newname_, 0)) {
notify(player, T("That is not a reasonable name."));
return;
}
newname = mush_strdup(trim_space_sep(newname_, ' '), "name.newname");
break;
default:
/* Should never occur */
notify(player, T("I don't see that here."));
return;
}
/* Actually change it */
mush_strncpy(oldname, Name(thing), BUFFER_LEN);
if (IsPlayer(thing)) {
do_log(LT_CONN, 0, 0, "Name change by %s(#%d) to %s",
Name(thing), thing, newname);
if (Suspect(thing) && strcmp(Name(thing), newname) != 0)
flag_broadcast("WIZARD", 0,
T("Broadcast: Suspect %s changed name to %s."),
Name(thing), newname);
reset_player_list(thing, Name(thing), NULL, newname, NULL);
}
set_name(thing, newname);
if (alias) {
if (*alias == ALIAS_DELIMITER) {
do_set_atr(thing, "ALIAS", NULL, player, 0);
} else {
/* New alias to set */
do_set_atr(thing, "ALIAS", alias, player, 0);
}
mush_free(alias, "name.newname");
}
queue_event(player, "OBJECT`RENAME", "%s,%s,%s",
unparse_objid(thing), newname, oldname);
if (!AreQuiet(player, thing))
notify(player, T("Name set."));
pe_regs = pe_regs_create(PE_REGS_ARG, "do_name");
pe_regs_setenv_nocopy(pe_regs, 0, oldname);
pe_regs_setenv_nocopy(pe_regs, 1, newname);
real_did_it(player, thing, NULL, NULL, "ONAME", NULL, "ANAME", NOTHING,
pe_regs, NA_INTER_PRESENCE, AN_SYS);
pe_regs_free(pe_regs);
mush_free(newname, "name.newname");
}
