/* utility for open and link */
static dbref
parse_linkable_room(dbref player, const char *room_name)
{
dbref room;
/* parse room */
if (!strcasecmp(room_name, "here")) {
room = IsExit(player) ? Source(player) : Location(player);
} else if (!strcasecmp(room_name, "home")) {
return HOME; /* HOME is always linkable */
} else {
room = parse_objid(room_name);
}
/* check room */
if (!GoodObject(room)) {
notify(player, T("That is not a valid object."));
return NOTHING;
} else if (Going(room)) {
notify(player, T("That room is being destroyed. Sorry."));
return NOTHING;
} else if (!can_link_to(player, room)) {
notify(player, T("You can't link to that."));
return NOTHING;
} else {
return room;
}
}
static bool fh_going_bit(dbref target, dbref player, FLAG flag, int fflags, bool reset)
{
if ( Going(target)
&& reset
&& (Typeof(target) != TYPE_GARBAGE))
{
notify(player, T("Your object has been spared from destruction."));
return (fh_any(target, player, flag, fflags, reset));
}
if (!God(player))
{
return false;
}
// Even God should not be allowed set protected dbrefs GOING.
//
if ( !reset
&& ( target == 0
|| God(target)
|| target == mudconf.start_home
|| target == mudconf.start_room
|| target == mudconf.default_home
|| target == mudconf.master_room))
{
return false;
}
return (fh_any(target, player, flag, fflags, reset));
}
int fh_going_bit( dbref target, dbref player, FLAG flag, int fflags, int reset ) {
if( Going( target ) && reset && ( Typeof( target ) != TYPE_GARBAGE ) ) {
notify( player,
"Your object has been spared from destruction." );
return ( fh_any( target, player, flag, fflags, reset ) );
}
if( !God( player ) || !destroyable( target ) ) {
return 0;
}
return ( fh_any( target, player, flag, fflags, reset ) );
}
// ---------------------------------------------------------------------------
// count_quota, mung_quota, show_quota, do_quota: Manage quotas.
//
static int count_quota(dbref player)
{
if (Owner(player) != player)
{
return 0;
}
int q = 0 - mudconf.player_quota;
dbref i;
DO_WHOLE_DB(i)
{
if (Owner(i) != player)
{
continue;
}
if (Going(i) && (!isRoom(i)))
{
continue;
}
switch (Typeof(i))
{
case TYPE_EXIT:
q += mudconf.exit_quota;
break;
case TYPE_ROOM:
q += mudconf.room_quota;
break;
case TYPE_THING:
q += mudconf.thing_quota;
break;
case TYPE_PLAYER:
q += mudconf.player_quota;
break;
}
}
return q;
}
void LoadSpecialObjects(void)
{
dbref i;
int id, brand;
int type;
void *tmpdat;
init_btdb_state(get_specialobjectsize);
init_xcode_tree();
muxevent_initialize();
muxevent_count_initialize();
init_stat();
initialize_partname_tables();
for(i = 0; MissileHitTable[i].key != -1; i++) {
if(find_matching_vlong_part(MissileHitTable[i].name, NULL, &id,
&brand))
MissileHitTable[i].key = Weapon2I(id);
else
MissileHitTable[i].key = -2;
}
/* Loop through the entire database, and if it has the special */
/* object flag, add it to our linked list. */
DO_WHOLE_DB(i)
if(Hardcode(i) && !Going(i) && !Halted(i)) {
type = WhichSpecialS(i);
if(type >= 0) {
if(SpecialObjects[type].datasize > 0)
tmpdat = NewSpecialObject(i, type);
else
tmpdat = NULL;
} else
c_Hardcode(i); /* Reset the flag */
}
for(i = 0; i < NUM_SPECIAL_OBJECTS; i++) {
InitSpecialHash(i);
if(!SpecialObjects[i].updatefunc)
SpecialObjects[i].updateTime = 0;
}
init_btechstats();
load_xcode();
zap_unneccessary_hcode();
}
dbref db_write(FILE * f, int format, int version)
{
dbref i;
int flags;
VATTR *vp;
switch (format) {
case F_MUX:
flags = version;
break;
default:
fprintf(stderr, "Can only write MUX format.\n");
return -1;
}
i = mudstate.attr_next;
fprintf(f, "+X%d\n+S%d\n+N%d\n", flags, mudstate.db_top, i);
fprintf(f, "-R%d\n", mudstate.record_players);
/*
* Dump user-named attribute info
*/
vp = vattr_first();
while (vp != NULL) {
if(!(vp->flags & AF_DELETED))
fprintf(f, "+A%d\n\"%d:%s\"\n", vp->number, vp->flags, vp->name);
vp = vattr_next(vp);
}
DO_WHOLE_DB(i) {
if(!(Going(i))) {
fprintf(f, "!%d\n", i);
db_write_object(f, i, format, flags);
}
}
fputs("***END OF DUMP***\n", f);
fflush(f);
return (mudstate.db_top);
}
static void
check_topology_on(dbref player, dbref i)
{
warn_type flags;
/* Skip it if it's NOWARN or the player checking is the owner and
* is NOWARN. Also skip GOING objects.
*/
if (Going(i) || NoWarn(i))
return;
/* If the owner is checking, use the flags on the object, and fall back
* on the owner's flags as default. If it's not the owner checking
* (therefore, an admin), ignore the object flags, use the admin's flags
*/
if (Owner(player) == Owner(i)) {
if (!(flags = Warnings(i)))
flags = Warnings(player);
} else
flags = Warnings(player);
ct_generic(player, i, flags);
switch (Typeof(i)) {
case TYPE_ROOM:
ct_room(player, i, flags);
break;
case TYPE_THING:
ct_thing(player, i, flags);
break;
case TYPE_EXIT:
ct_exit(player, i, flags);
break;
case TYPE_PLAYER:
ct_player(player, i, flags);
break;
}
return;
}
/** 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;
}
static void give_thing (dbref giver, dbref recipient, int key, char *what)
{
dbref thing, loc;
char *str, *sp;
init_match(giver, what, TYPE_THING);
match_possession();
match_me();
thing = match_result();
switch (thing) {
case NOTHING:
notify(giver, "You don't have that!");
return;
case AMBIGUOUS:
notify(giver, "I don't know which you mean!");
return;
}
if (thing == giver) {
notify(giver, "You can't give yourself away!");
return;
}
if (((Typeof(thing) != TYPE_THING) &&
(Typeof(thing) != TYPE_PLAYER)) ||
!(Enter_ok(recipient) || controls(giver, recipient))) {
notify(giver, "Permission denied.");
return;
}
if ((Flags3(thing) & NOMOVE) && !Wizard(giver)) {
notify(giver, "Permission denied.");
return;
}
if (!could_doit(giver, thing, A_LGIVE,1)) {
sp = str = alloc_lbuf("do_give.gfail");
safe_str((char *)"You can't give ", str, &sp);
safe_str(Name(thing), str, &sp);
safe_str((char *)" away.", str, &sp);
*sp = '\0';
did_it(giver, thing, A_GFAIL, str, A_OGFAIL, NULL,
A_AGFAIL, (char **)NULL, 0);
free_lbuf(str);
return;
}
if (!could_doit(thing, recipient, A_LRECEIVE,1)) {
sp = str = alloc_lbuf("do_give.rfail");
safe_str(Name(recipient), str, &sp);
safe_str((char *)" doesn't want ", str, &sp);
safe_str(Name(thing), str, &sp);
safe_chr('.', str, &sp);
*sp = '\0';
did_it(giver, recipient, A_RFAIL, str, A_ORFAIL, NULL,
A_ARFAIL, (char **)NULL, 0);
free_lbuf(str);
return;
}
loc = Location(giver);
if ( !Good_obj(loc) || loc == NOTHING || loc == AMBIGUOUS || Recover(loc) || Going(loc) )
loc = giver;
if (!could_doit(giver, loc, A_LGIVETO, 1)) {
sp = str = alloc_lbuf("do_giveto.rfail");
safe_str((char *)"You can not give ", str, &sp);
safe_str(Name(thing), str, &sp);
safe_str((char *)" away at this location.", str, &sp);
*sp = '\0';
notify(giver, str);
free_lbuf(str);
return;
}
move_via_generic(thing, recipient, giver, 0);
divest_object(thing);
if (!(key & GIVE_QUIET)) {
str = alloc_lbuf("do_give.thing.ok");
strcpy(str, Name(giver));
notify_with_cause(recipient, giver,
unsafe_tprintf("%s gave you %s.", str, Name(thing)));
notify(giver, "Given.");
notify_with_cause(thing, giver,
unsafe_tprintf("%s gave you to %s.", str, Name(recipient)));
free_lbuf(str);
}
else {
notify(giver, "Given. (quiet)");
}
did_it(giver, thing, A_DROP, NULL, A_ODROP, NULL, A_ADROP,
(char **)NULL, 0);
did_it(recipient, thing, A_SUCC, NULL, A_OSUCC, NULL, A_ASUCC,
(char **)NULL, 0);
}
// This Task assumes that pEntry is already unlinked from any lists it may
// have been related to.
//
static void Task_RunQueueEntry(void *pEntry, int iUnused)
{
UNUSED_PARAMETER(iUnused);
BQUE *point = (BQUE *)pEntry;
dbref executor = point->executor;
if ( Good_obj(executor)
&& !Going(executor))
{
giveto(executor, mudconf.waitcost);
mudstate.curr_enactor = point->enactor;
mudstate.curr_executor = executor;
a_Queue(Owner(executor), -1);
point->executor = NOTHING;
if (!Halted(executor))
{
// Load scratch args.
//
for (int i = 0; i < MAX_GLOBAL_REGS; i++)
{
if (mudstate.global_regs[i])
{
RegRelease(mudstate.global_regs[i]);
mudstate.global_regs[i] = NULL;
}
mudstate.global_regs[i] = point->scr[i];
point->scr[i] = NULL;
}
char *command = point->comm;
mux_assert(!mudstate.inpipe);
mux_assert(mudstate.pipe_nest_lev == 0);
mux_assert(mudstate.poutobj == NOTHING);
mux_assert(!mudstate.pout);
break_called = false;
while ( command
&& !break_called)
{
mux_assert(!mudstate.poutnew);
mux_assert(!mudstate.poutbufc);
char *cp = parse_to(&command, ';', 0);
if ( cp
&& *cp)
{
// Will command be piped?
//
if ( command
&& *command == '|'
&& mudstate.pipe_nest_lev < mudconf.ntfy_nest_lim)
{
command++;
mudstate.pipe_nest_lev++;
mudstate.inpipe = true;
mudstate.poutnew = alloc_lbuf("process_command.pipe");
mudstate.poutbufc = mudstate.poutnew;
mudstate.poutobj = executor;
}
else
{
mudstate.inpipe = false;
mudstate.poutobj = NOTHING;
}
CLinearTimeAbsolute ltaBegin;
ltaBegin.GetUTC();
MuxAlarm.Set(mudconf.max_cmdsecs);
CLinearTimeDelta ltdUsageBegin = GetProcessorUsage();
char *log_cmdbuf = process_command(executor, point->caller,
point->enactor, point->eval, false, cp, point->env,
point->nargs);
CLinearTimeAbsolute ltaEnd;
ltaEnd.GetUTC();
if (MuxAlarm.bAlarmed)
{
notify(executor, "GAME: Expensive activity abbreviated.");
s_Flags(point->enactor, FLAG_WORD1, Flags(point->enactor) | HALT);
s_Flags(point->executor, FLAG_WORD1, Flags(point->executor) | HALT);
halt_que(point->enactor, NOTHING);
halt_que(executor, NOTHING);
}
MuxAlarm.Clear();
CLinearTimeDelta ltdUsageEnd = GetProcessorUsage();
CLinearTimeDelta ltd = ltdUsageEnd - ltdUsageBegin;
db[executor].cpu_time_used += ltd;
ltd = ltaEnd - ltaBegin;
if (ltd > mudconf.rpt_cmdsecs)
{
STARTLOG(LOG_PROBLEMS, "CMD", "CPU");
log_name_and_loc(executor);
char *logbuf = alloc_lbuf("do_top.LOG.cpu");
mux_sprintf(logbuf, LBUF_SIZE, " queued command taking %s secs (enactor #%d): ",
ltd.ReturnSecondsString(4), point->enactor);
log_text(logbuf);
free_lbuf(logbuf);
log_text(log_cmdbuf);
ENDLOG;
}
}
// Transition %| value.
//
if (mudstate.pout)
{
free_lbuf(mudstate.pout);
mudstate.pout = NULL;
}
if (mudstate.poutnew)
{
*mudstate.poutbufc = '\0';
mudstate.pout = mudstate.poutnew;
mudstate.poutnew = NULL;
mudstate.poutbufc = NULL;
}
}
// Clean up %| value.
//
if (mudstate.pout)
{
free_lbuf(mudstate.pout);
mudstate.pout = NULL;
}
mudstate.pipe_nest_lev = 0;
mudstate.inpipe = false;
mudstate.poutobj = NOTHING;
}
}
for (int i = 0; i < MAX_GLOBAL_REGS; i++)
{
if (point->scr[i])
{
RegRelease(point->scr[i]);
point->scr[i] = NULL;
}
if (mudstate.global_regs[i])
{
RegRelease(mudstate.global_regs[i]);
mudstate.global_regs[i] = NULL;
}
}
MEMFREE(point->text);
point->text = NULL;
free_qentry(point);
}
/** Check to see if someone can connect to a player.
* \param d DESC the connect attempt is being made for
* \param name name of player to connect to.
* \param password password of player to connect to.
* \param host host from which connection is being attempted.
* \param ip ip address from which connection is being attempted.
* \param errbuf buffer to return connection errors.
* \return dbref of connected player object or NOTHING for failure
* (with reason for failure returned in errbuf).
*/
dbref
connect_player(DESC *d, const char *name, const char *password,
const char *host, const char *ip, char *errbuf)
{
dbref player;
int count;
/* Default error */
strcpy(errbuf,
T("Either that player does not exist, or has a different password."));
if (!name || !*name)
return NOTHING;
/* validate name */
if ((player = lookup_player(name)) == NOTHING) {
/* Invalid player names are failures, too. */
count = mark_failed(ip);
strcpy(errbuf, T("There is no player with that name."));
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d,%s",
d->descriptor, ip, count, "invalid player", -1, name);
return NOTHING;
}
/* See if player is allowed to connect like this */
if (Going(player) || Going_Twice(player)) {
do_log(LT_CONN, 0, 0,
"Connection to GOING player %s not allowed from %s (%s)",
Name(player), host, ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d", d->descriptor,
ip, count_failed(ip), "player is going", player);
strcpy(errbuf, T("You cannot connect to that player at this time."));
return NOTHING;
}
/* Check sitelock patterns */
if (Guest(player) &&
(!Site_Can_Guest(host, player) || !Site_Can_Guest(ip, player))) {
if (!Deny_Silent_Site(host, AMBIGUOUS) &&
!Deny_Silent_Site(ip, AMBIGUOUS)) {
do_log(LT_CONN, 0, 0, "Connection to %s (GUEST) not allowed from %s (%s)",
name, host, ip);
strcpy(errbuf, T("Guest connections not allowed."));
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "failed sitelock", player);
}
return NOTHING;
} else if (!Guest(player) && (!Site_Can_Connect(host, player) ||
!Site_Can_Connect(ip, player))) {
if (!Deny_Silent_Site(host, player) && !Deny_Silent_Site(ip, player)) {
do_log(LT_CONN, 0, 0,
"Connection to %s (Non-GUEST) not allowed from %s (%s)", name,
host, ip);
strcpy(errbuf, T("Player connections not allowed."));
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "failed sitelock", player);
}
return NOTHING;
}
/* validate password */
if (!Guest(player))
if (!password_check(player, password)) {
/* Increment count of login failures */
ModTime(player)++;
check_lastfailed(player, host);
count = mark_failed(ip);
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count, "invalid password", player);
strcpy(errbuf, T("That is not the correct password."));
return NOTHING;
}
/* If it's a Guest player, and already connected, search the
* db for another Guest player to connect them to. */
if (Guest(player)) {
/* Enforce guest limit */
player = guest_to_connect(player);
if (!GoodObject(player)) {
do_log(LT_CONN, 0, 0, "Can't connect to a guest (too many connected)");
strcpy(errbuf, T("Too many guests are connected now."));
queue_event(SYSEVENT, "SOCKET`LOGINFAIL", "%d,%s,%d,%s,#%d",
d->descriptor, ip, count_failed(ip), "too many guests",
player);
return NOTHING;
}
}
if (Suspect_Site(host, player) || Suspect_Site(ip, player)) {
do_log(LT_CONN, 0, 0,
"Connection from Suspect site. Setting %s(#%d) suspect.",
Name(player), player);
set_flag_internal(player, "SUSPECT");
}
return player;
}
