src/game.c

Go to the documentation of this file.

/*
 * game.c 
 */

#include "copyright.h"
#include "config.h"

#include <sys/stat.h>
#include <signal.h>
#include <event.h>
#include <regex.h>

#include "mudconf.h"
#include "config.h"
#include "file_c.h"
#include "db.h"
#include "interface.h"
#include "match.h"
#include "externs.h"
#include "flags.h"
#include "powers.h"
#include "attrs.h"
#include "alloc.h"
#include "vattr.h"
#include "commac.h"
#ifdef SQL_SUPPORT
#include "sqlchild.h"
#endif

#ifndef NEXT
#endif

#ifdef HAVE_IEEEFP_H
#include <ieeefp.h>
#endif
#ifdef HAVE_SYS_UCONTEXT_H
#include <sys/ucontext.h>
#endif

#define NSUBEXP 10

extern void init_attrtab(void);
extern void init_cmdtab(void);
extern void init_mactab(void);
extern void init_chantab(void);
extern void cf_init(void);
extern void pcache_init(void);
extern int cf_read(char *fn);
extern void init_functab(void);
extern void close_sockets(int emergency, char *message);
extern void init_version(void);
extern void init_logout_cmdtab(void);
extern void init_timer(void);
extern void raw_notify(dbref, const char *);
extern void do_second(void);
extern void do_dbck(dbref, dbref, int);

#ifdef ARBITRARY_LOGFILES
void logcache_init();
void logcache_destruct();
#endif

#ifdef HUDINFO_SUPPORT
extern void init_hudinfo(void);
#endif

void fork_and_dump(int);
void dump_database(void);
void do_dump_optimize(dbref, dbref, int);
void pcache_sync(void);
void dump_database_internal(int);
static void init_rlimit(void);

int reserved;

extern int corrupt;

/*
 * used to allocate storage for temporary stuff, cleared before command
 * execution
 */

void do_dump(dbref player, dbref cause, int key)
{
        notify(player, "Dumping...");

        /*
         * DUMP_OPTIMIZE takes advantage of a feature of GDBM to compress  
         * unused space in the database, and will not be very useful
         * except sparingly, perhaps done every month or so. 
         */

        if(key & DUMP_OPTIMIZE)
                do_dump_optimize(player, cause, key);
        else
                fork_and_dump(key);
}

void do_dump_optimize(dbref player, dbref cause, int key)
{
        raw_notify(player, "Database is memory based.");
}

void report(void)
{
        STARTLOG(LOG_BUGS, "BUG", "INFO") {
                log_text((char *) "Command: '");
                log_text(mudstate.debug_cmd);
                log_text((char *) "'");
                ENDLOG;
        } if(Good_obj(mudstate.curr_player)) {
                STARTLOG(LOG_BUGS, "BUG", "INFO") {
                        log_text((char *) "Player: ");
                        log_name_and_loc(mudstate.curr_player);
                        if((mudstate.curr_enactor != mudstate.curr_player) &&
                           Good_obj(mudstate.curr_enactor)) {
                                log_text((char *) " Enactor: ");
                                log_name_and_loc(mudstate.curr_enactor);
                        }
                        ENDLOG;
        }}
}

/*
 * Load a regular expression match and insert it into
 * registers.
 */
int regexp_match(char *pattern, char *str, char *args[], int nargs)
{
        regex_t re;
        int got_match;
        regmatch_t pmatch[NSUBEXP];
        int i, len;

        /*
         * Load the regexp pattern. This allocates memory which must be
         * later freed. A free() of the regexp does free all structures
         * under it.
         */

        if(regcomp(&re, pattern, REG_EXTENDED) != 0) {
                /*
                 * This is a matching error. We have an error message in
                 * regexp_errbuf that we can ignore, since we're doing
                 * command-matching.
                 */
                return 0;
        }

        /* 
         * Now we try to match the pattern. The relevant fields will
         * automatically be filled in by this.
         */
        got_match = (regexec(&re, str, NSUBEXP, pmatch, 0) == 0);
        if(!got_match) {
                regfree(&re);
                return 0;
        }

        /*
         * Now we fill in our args vector. Note that in regexp matching,
         * 0 is the entire string matched, and the parenthesized strings
         * go from 1 to 9. We DO PRESERVE THIS PARADIGM, for consistency
         * with other languages.
         */

        for(i = 0; i < nargs; i++) {
                args[i] = NULL;
        }

        /* Convenient: nargs and NSUBEXP are the same.
         * We are also guaranteed that our buffer is going to be LBUF_SIZE
         * so we can copy without fear.
         */

        for(i = 0; (i < NSUBEXP) && (pmatch[i].rm_so != -1) && (pmatch[i].rm_eo != -1); i++) {
                len = pmatch[i].rm_eo - pmatch[i].rm_so;
                args[i] = alloc_lbuf("regexp_match");
        memset(args[i], 0, LBUF_SIZE);
                strncpy(args[i], str + pmatch[i].rm_so, len);
                args[i][len] = '\0';    /* strncpy() does not null-terminate */
        }

        regfree(&re);
        return 1;
}

static int atr_match1(dbref thing, dbref parent, dbref player, char type,
                                          char *str, int check_exclude, int hash_insert)
{
        dbref aowner;
        int match, attr, aflags, i;
        char buff[LBUF_SIZE], *s, *as;
        char *args[10];
        ATTR *ap;

    memset(args, 0, sizeof(args));
    
        /*
         * See if we can do it.  Silently fail if we can't. 
         */

        if(!could_doit(player, parent, A_LUSE))
                return -1;

        match = 0;
        for(attr = atr_head(parent, &as); attr; attr = atr_next(&as)) {
                ap = atr_num(attr);

                /*
                 * Never check NOPROG attributes. 
                 */

                if(!ap || (ap->flags & AF_NOPROG))
                        continue;

                /*
                 * If we aren't the bottom level check if we saw this attr *
                 * * * * before.  Also exclude it if the attribute type is *
                 * * PRIVATE. 
                 */

                if(check_exclude && ((ap->flags & AF_PRIVATE) ||
                                                         nhashfind(ap->number, &mudstate.parent_htab))) {
                        continue;
                }
                atr_get_str(buff, parent, attr, &aowner, &aflags);

                /*
                 * Skip if private and on a parent 
                 */

                if(check_exclude && (aflags & AF_PRIVATE)) {
                        continue;
                }
                /*
                 * If we aren't the top level remember this attr so we * * *
                 * exclude * it from now on. 
                 */

                if(hash_insert)
                        nhashadd(ap->number, (int *) &attr, &mudstate.parent_htab);

                /*
                 * Check for the leadin character after excluding the attrib
                 * * * * * This lets non-command attribs on the child block * 
                 * *  * commands * on the parent. 
                 */

                if((buff[0] != type) || (aflags & AF_NOPROG))
                        continue;

                /*
                 * decode it: search for first un escaped : 
                 */

                for(s = buff + 1; *s && (*s != ':'); s++);
                if(!*s)
                        continue;
                *s++ = 0;
                if(((aflags & AF_REGEXP) && regexp_match(buff + 1, str, args, 10))
                   || wild(buff + 1, str, args, 10)) {
                        match = 1;
                        wait_que(thing, player, 0, NOTHING, 0, s, args, 10,
                                         mudstate.global_regs);
                        for(i = 0; i < 10; i++) {
                                if(args[i])
                                        free_lbuf(args[i]);
                        }
                }
        }
        return (match);
}

int atr_match(dbref thing, dbref player, char type, char *str,
                          int check_parents)
{
        int match, lev, result, exclude, insert;
        dbref parent;

        /*
         * If thing is halted, don't check anything 
         */

        if(Halted(thing))
                return 0;

        /*
         * If not checking parents, just check the thing 
         */

        match = 0;
        if(!check_parents)
                return atr_match1(thing, thing, player, type, str, 0, 0);

        /*
         * Check parents, ignoring halted objects 
         */

        exclude = 0;
        insert = 1;
        nhashflush(&mudstate.parent_htab, 0);
        ITER_PARENTS(thing, parent, lev) {
                if(!Good_obj(Parent(parent)))
                        insert = 0;
                result =
                        atr_match1(thing, parent, player, type, str, exclude, insert);
                if(result > 0) {
                        match = 1;
                } else if(result < 0) {
                        return match;
                }
                exclude = 1;
        }

        return match;
}

int check_filter(dbref object, dbref player, int filter, const char *msg)
{
        int aflags;
        dbref aowner;
        char *buf, *nbuf, *cp, *dp, *str;

        buf = atr_pget(object, filter, &aowner, &aflags);
        if(!*buf) {
                free_lbuf(buf);
                return (1);
        }
        nbuf = dp = alloc_lbuf("check_filter");
        str = buf;
        exec(nbuf, &dp, 0, object, player, EV_FIGNORE | EV_EVAL | EV_TOP, &str,
                 (char **) NULL, 0);
        *dp = '\0';
        dp = nbuf;
        free_lbuf(buf);
        do {
                cp = parse_to(&dp, ',', EV_STRIP);
                if(quick_wild(cp, (char *) msg)) {
                        free_lbuf(nbuf);
                        return (0);
                }
        } while (dp != NULL);
        free_lbuf(nbuf);
        return (1);
}

static char *add_prefix(dbref object, dbref player, int prefix,
                                                const char *msg, const char *dflt)
{
        int aflags;
        dbref aowner;
        char *buf, *nbuf, *cp, *bp, *str;

        buf = atr_pget(object, prefix, &aowner, &aflags);
        if(!*buf) {
                cp = buf;
                safe_str((char *) dflt, buf, &cp);
        } else {
                nbuf = bp = alloc_lbuf("add_prefix");
                str = buf;
                exec(nbuf, &bp, 0, object, player, EV_FIGNORE | EV_EVAL | EV_TOP,
                         &str, (char **) NULL, 0);
                *bp = '\0';
                free_lbuf(buf);
                buf = nbuf;
                cp = &buf[strlen(buf)];
        }
        if(cp != buf)
                safe_str((char *) " ", buf, &cp);
        safe_str((char *) msg, buf, &cp);
        *cp = '\0';
        return (buf);
}

static char *dflt_from_msg(dbref sender, dbref sendloc)
{
        char *tp, *tbuff;

        tp = tbuff = alloc_lbuf("notify_checked.fwdlist");
        safe_str((char *) "From ", tbuff, &tp);
        if(Good_obj(sendloc))
                safe_str(Name(sendloc), tbuff, &tp);
        else
                safe_str(Name(sender), tbuff, &tp);
        safe_chr(',', tbuff, &tp);
        *tp = '\0';
        return tbuff;
}

char *colorize(dbref player, char *from);

void notify_checked(dbref target, dbref sender, const char *msg, int key)
{
        char *msg_ns, *mp, *tbuff, *tp, *buff, *colbuf = NULL;
        char *args[10];
        dbref aowner, targetloc, recip, obj;
        int i, nargs, aflags, has_neighbors, pass_listen;
        int check_listens, pass_uselock, is_audible;
        FWDLIST *fp;

        /*
         * If speaker is invalid or message is empty, just exit 
         */

        if(!Good_obj(target) || !msg || !*msg)
                return;

        /*
         * Enforce a recursion limit 
         */

        mudstate.ntfy_nest_lev++;
        if(mudstate.ntfy_nest_lev >= mudconf.ntfy_nest_lim) {
                mudstate.ntfy_nest_lev--;
                return;
        }
        /*
         * If we want NOSPOOF output, generate it.  It is only needed if 
         * we are sending the message to the target object 
         */

        if(key & MSG_ME) {
                mp = msg_ns = alloc_lbuf("notify_checked");
                if(Nospoof(target) && (target != sender) &&
                   (target != mudstate.curr_enactor) &&
                   (target != mudstate.curr_player && Good_obj(sender))) {

                        /*
                         * I'd really like to use tprintf here but I can't 
                         * because the caller may have.
                         * notify(target, tprintf(...)) is quite common 
                         * in the code. 
                         */

                        tbuff = alloc_sbuf("notify_checked.nospoof");
                        safe_chr('[', msg_ns, &mp);
                        safe_str(Name(sender), msg_ns, &mp);
                        sprintf(tbuff, "(#%d)", sender);
                        safe_str(tbuff, msg_ns, &mp);

                        if(sender != Owner(sender)) {
                                safe_chr('{', msg_ns, &mp);
                                safe_str(Name(Owner(sender)), msg_ns, &mp);
                                safe_chr('}', msg_ns, &mp);
                        }
                        if(sender != mudstate.curr_enactor) {
                                sprintf(tbuff, "<-(#%d)", mudstate.curr_enactor);
                                safe_str(tbuff, msg_ns, &mp);
                        }
                        safe_str((char *) "] ", msg_ns, &mp);
                        free_sbuf(tbuff);
                }
                safe_str((char *) msg, msg_ns, &mp);
                *mp = '\0';
        } else {
                msg_ns = NULL;
        }

        /*
         * msg contains the raw message, msg_ns contains the NOSPOOFed msg 
         */

        check_listens = Halted(target) ? 0 : 1;
        switch (Typeof(target)) {
        case TYPE_PLAYER:
                if(key & MSG_ME) {
                        if(key & MSG_COLORIZE)
                                colbuf = colorize(target, msg_ns);
                        raw_notify(target, colbuf ? colbuf : msg_ns);


                }

                if(colbuf)
                        free_lbuf(colbuf);
                if(!mudconf.player_listen)
                        check_listens = 0;
        case TYPE_THING:
        case TYPE_ROOM:

                /* If we're in a pipe, objects can receive raw_notify
                 * if they're not a player and connected (if we didn't
                 * do this, they'd be notified twice! */

                if(mudstate.inpipe && (!isPlayer(target) || (isPlayer(target) &&
                                                                                                         !Connected(target)))) {
                        raw_notify(target, msg_ns);
                }

                /*
                 * Forward puppet message if it is for me 
                 */

                has_neighbors = Has_location(target);
                targetloc = where_is(target);
                is_audible = Audible(target);

                if((key & MSG_ME) && Puppet(target) && (target != Owner(target))
                   && ((key & MSG_PUP_ALWAYS) ||
                           ((targetloc != Location(Owner(target))) &&
                                (targetloc != Owner(target))))) {
                        tp = tbuff = alloc_lbuf("notify_checked.puppet");
                        safe_str(Name(target), tbuff, &tp);
                        safe_str((char *) "> ", tbuff, &tp);
                        if(key & MSG_COLORIZE)
                                colbuf = colorize(Owner(target), msg_ns);
                        safe_str(colbuf ? colbuf : msg_ns, tbuff, &tp);
                        *tp = '\0';
                        raw_notify(Owner(target), tbuff);
                        if(colbuf)
                                free_lbuf(colbuf);
                        free_lbuf(tbuff);
                }
                /*
                 * Check for @Listen match if it will be useful 
                 */

                pass_listen = 0;
                nargs = 0;
                if(check_listens && (key & (MSG_ME | MSG_INV_L)) && H_Listen(target)) {
                        tp = atr_get(target, A_LISTEN, &aowner, &aflags);
                        if(*tp && wild(tp, (char *) msg, args, 10)) {
                                for(nargs = 10;
                                        nargs && (!args[nargs - 1] || !(*args[nargs - 1]));
                                        nargs--);
                                pass_listen = 1;
                        }
                        free_lbuf(tp);
                }
                /*
                 * If we matched the @listen or are monitoring, check the * * 
                 * USE lock 
                 */

                if(sender < 0)
                        sender = GOD;
                pass_uselock = 0;
                if((key & MSG_ME) && check_listens && (pass_listen ||
                                                                                           Monitor(target)))
                        pass_uselock = could_doit(sender, target, A_LUSE);

                /*
                 * Process AxHEAR if we pass LISTEN, USElock and it's for me 
                 */

                if((key & MSG_ME) && pass_listen && pass_uselock) {
                        if(sender != target)
                                did_it(sender, target, 0, NULL, 0, NULL, A_AHEAR, args,
                                           nargs);
                        else
                                did_it(sender, target, 0, NULL, 0, NULL, A_AMHEAR, args,
                                           nargs);
                        did_it(sender, target, 0, NULL, 0, NULL, A_AAHEAR, args, nargs);
                }
                /*
                 * Get rid of match arguments. We don't need them anymore 
                 */

                if(pass_listen) {
                        for(i = 0; i < 10; i++)
                                if(args[i] != NULL)
                                        free_lbuf(args[i]);
                }
                /*
                 * Process ^-listens if for me, MONITOR, and we pass USElock 
                 */
                /*
                 * \todo Eventually come up with a cleaner method for making sure
                 * the sender isn't the same as the target.
                 */
                if((key & MSG_ME) && (sender != target || Staff(target))
                   && pass_uselock && Monitor(target)) {
                        (void) atr_match(target, sender, AMATCH_LISTEN, (char *) msg, 0);
                }
                /*
                 * Deliver message to forwardlist members 
                 */

                if((key & MSG_FWDLIST) && Audible(target) &&
                   check_filter(target, sender, A_FILTER, msg)) {
                        tbuff = dflt_from_msg(sender, target);
                        buff = add_prefix(target, sender, A_PREFIX, msg, tbuff);
                        free_lbuf(tbuff);

                        fp = fwdlist_get(target);
                        if(fp) {
                                for(i = 0; i < fp->count; i++) {
                                        recip = fp->data[i];
                                        if(!Good_obj(recip) || (recip == target))
                                                continue;
                                        notify_checked(recip, sender, buff,
                                                                   (MSG_ME | MSG_F_UP | MSG_F_CONTENTS |
                                                                        MSG_S_INSIDE));
                                }
                        }
                        free_lbuf(buff);
                }
                /*
                 * Deliver message through audible exits 
                 */

                if(key & MSG_INV_EXITS) {
                        DOLIST(obj, Exits(target)) {
                                recip = Location(obj);
                                if(Audible(obj) && ((recip != target) &&
                                                                        check_filter(obj, sender, A_FILTER,
                                                                                                 msg))) {
                                        buff =
                                                add_prefix(obj, target, A_PREFIX, msg,
                                                                   "From a distance,");
                                        notify_checked(recip, sender, buff,
                                                                   MSG_ME | MSG_F_UP | MSG_F_CONTENTS |
                                                                   MSG_S_INSIDE);
                                        free_lbuf(buff);
                                }
                        }
                }
                /*
                 * Deliver message through neighboring audible exits 
                 */

                if(has_neighbors && ((key & MSG_NBR_EXITS) ||
                                                         ((key & MSG_NBR_EXITS_A) && is_audible))) {

                        /*
                         * If from inside, we have to add the prefix string * 
                         * 
                         * *  * * of * the container. 
                         */

                        if(key & MSG_S_INSIDE) {
                                tbuff = dflt_from_msg(sender, target);
                                buff = add_prefix(target, sender, A_PREFIX, msg, tbuff);
                                free_lbuf(tbuff);
                        } else {
                                buff = (char *) msg;
                        }

                        DOLIST(obj, Exits(Location(target))) {
                                recip = Location(obj);
                                if(Good_obj(recip) && Audible(obj) && (recip != targetloc)
                                   && (recip != target) &&
                                   check_filter(obj, sender, A_FILTER, msg)) {
                                        tbuff =
                                                add_prefix(obj, target, A_PREFIX, buff,
                                                                   "From a distance,");
                                        notify_checked(recip, sender, tbuff,
                                                                   MSG_ME | MSG_F_UP | MSG_F_CONTENTS |
                                                                   MSG_S_INSIDE);
                                        free_lbuf(tbuff);
                                }
                        }
                        if(key & MSG_S_INSIDE) {
                                free_lbuf(buff);
                        }
                }
                /*
                 * Deliver message to contents 
                 */

                if(((key & MSG_INV) || ((key & MSG_INV_L) && pass_listen)) &&
                   (check_filter(target, sender, A_INFILTER, msg))) {

                        /*
                         * Don't prefix the message if we were given the * *
                         * * * MSG_NOPREFIX key. 
                         */

                        if(key & MSG_S_OUTSIDE) {
                                buff = add_prefix(target, sender, A_INPREFIX, msg, "");
                        } else {
                                buff = (char *) msg;
                        }
                        DOLIST(obj, Contents(target)) {
                                if(Slave(obj) && (key & MSG_NO_SLAVE))
                                        continue;
                                if(obj != target) {
                                        notify_checked(obj, sender, buff,
                                                                   MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE );
                                }
                        }
                        if(key & MSG_S_OUTSIDE)
                                free_lbuf(buff);
                }
                /*
                 * Deliver message to neighbors 
                 */

                if(has_neighbors && ((key & MSG_NBR) || ((key & MSG_NBR_A) &&
                                                                                                 is_audible &&
                                                                                                 check_filter(target, sender,
                                                                                                                          A_FILTER,
                                                                                                                          msg)))) {
                        if(key & MSG_S_INSIDE) {
                                tbuff = dflt_from_msg(sender, target);
                                buff = add_prefix(target, sender, A_PREFIX, msg, "");
                                free_lbuf(tbuff);
                        } else {
                                buff = (char *) msg;
                        }
                        DOLIST(obj, Contents(targetloc)) {
                                if((obj != target) && (obj != targetloc)) {
                                        notify_checked(obj, sender, buff,
                                                                   MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE | (key
                                                                                                                                                  &
                                                                                                                                                  MSG_COLORIZE));
                                }
                        }
                        if(key & MSG_S_INSIDE) {
                                free_lbuf(buff);
                        }
                }
                /*
                 * Deliver message to container 
                 */

                if(has_neighbors && ((key & MSG_LOC) || ((key & MSG_LOC_A) &&
                                                                                                 is_audible &&
                                                                                                 check_filter(target, sender,
                                                                                                                          A_FILTER,
                                                                                                                          msg)))) {
                        if(key & MSG_S_INSIDE) {
                                tbuff = dflt_from_msg(sender, target);
                                buff = add_prefix(target, sender, A_PREFIX, msg, tbuff);
                                free_lbuf(tbuff);
                        } else {
                                buff = (char *) msg;
                        }
                        notify_checked(targetloc, sender, buff,
                                                   MSG_ME | MSG_F_UP | MSG_S_INSIDE);
                        if(key & MSG_S_INSIDE) {
                                free_lbuf(buff);
                        }
                }
        }
        if(msg_ns)
                free_lbuf(msg_ns);
        mudstate.ntfy_nest_lev--;
}

void notify_except(dbref loc, dbref player, dbref exception, const char *msg)
{
        dbref first;

        if(loc != exception)
                notify_checked(loc, player, msg,
                                           (MSG_ME_ALL | MSG_F_UP | MSG_S_INSIDE |
                                                MSG_NBR_EXITS_A));
        DOLIST(first, Contents(loc)) {
                if(exception == NOSLAVE)
                        if(Slave(first))
                                continue;
                if(first != exception)
                        notify_checked(first, player, msg,
                                                   (MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE |
                                                        (exception == NOSLAVE ? MSG_NO_SLAVE : 0)));
        }
}

void notify_except2(dbref loc, dbref player, dbref exc1, dbref exc2,
                                        const char *msg)
{
        dbref first;

        if((loc != exc1) && (loc != exc2))
                notify_checked(loc, player, msg,
                                           (MSG_ME_ALL | MSG_F_UP | MSG_S_INSIDE |
                                                MSG_NBR_EXITS_A));
        DOLIST(first, Contents(loc)) {
                if(first != exc1 && first != exc2) {
                        notify_checked(first, player, msg,
                                                   (MSG_ME | MSG_F_DOWN | MSG_S_OUTSIDE));
                }
        }
}

void do_shutdown(dbref player, dbref cause, int key, char *message)
{
        FILE *fs;

        ResetSpecialObjects();
        if(player != NOTHING) {
                raw_broadcast(0, "Game: Shutdown by %s", Name(Owner(player)));
                STARTLOG(LOG_ALWAYS, "WIZ", "SHTDN") {
                        log_text((char *) "Shutdown by ");
                        log_name(player);
                        ENDLOG;
                }
        } else {
                raw_broadcast(0, "Game: Fatal Error: %s", message);
                STARTLOG(LOG_ALWAYS, "WIZ", "SHTDN") {
                        log_text((char *) "Fatal error: ");
                        log_text(message);
                        ENDLOG;
                }
        }
        STARTLOG(LOG_ALWAYS, "WIZ", "SHTDN") {
                log_text((char *) "Shutdown status: ");
                log_text(message);
                ENDLOG;
        }

        fs = fopen(mudconf.status_file, "w");
        fprintf(fs, "%s\n", message);
        fclose(fs);

        /*
         * Do we perform a normal or an emergency shutdown?  Normal shutdown
         * * * * * is handled by exiting the main loop in shovechars,
         * emergency  * * * * shutdown is done here. 
         */

        if(key & SHUTDN_PANIC) {

                /*
                 * Close down the network interface 
                 */

                emergency_shutdown();

                /*
                 * Close the attribute text db and dump the header db 
                 */

                pcache_sync();
                STARTLOG(LOG_ALWAYS, "DMP", "PANIC") {
                        log_text((char *) "Panic dump: ");
                        log_text(mudconf.crashdb);
                        ENDLOG;
                } dump_database_internal(DUMP_CRASHED);

                STARTLOG(LOG_ALWAYS, "DMP", "DONE") {
                        log_text((char *) "Panic dump complete: ");
                        log_text(mudconf.crashdb);
                        ENDLOG;
                }
        }
        /*
         * Set up for normal shutdown 
         */

        mudstate.shutdown_flag = 1;
        event_loopexit(NULL);
        return;
}

void dump_database_internal(int dump_type)
{
        char tmpfile[256], outfn[256], prevfile[256];
        FILE *f;

#ifdef USE_PYTHON
        runPythonHook("save");
#endif

        if(dump_type == DUMP_CRASHED) {
                unlink(mudconf.crashdb);
                f = fopen(mudconf.crashdb, "w");
                if(f != NULL) {
                        db_write(f, F_MUX, UNLOAD_VERSION | UNLOAD_OUTFLAGS);
                        fclose(f);
                } else {
                        log_perror("DMP", "FAIL", "Opening crash file", mudconf.crashdb);
                }
                if(mudconf.have_mailer)
                        if((f = fopen(mudconf.mail_db, "w"))) {
                                dump_mail(f);
                                fclose(f);
                        }
                if(mudconf.have_comsys || mudconf.have_macros)
                        save_comsys_and_macros(mudconf.commac_db);
                SaveSpecialObjects(DUMP_CRASHED);
                return;
        }

        if(dump_type == DUMP_RESTART) {
                f = fopen(mudconf.indb, "w");
                if(f != NULL) {
                        /* Write a flatfile */
                        db_write(f, F_MUX, UNLOAD_VERSION | UNLOAD_OUTFLAGS);
                        fclose(f);
                } else {
                        log_perror("DMP", "FAIL", "Opening restart file", mudconf.indb);
                }
                if(mudconf.have_mailer)
                        if((f = fopen(mudconf.mail_db, "w"))) {
                                dump_mail(f);
                                fclose(f);
                        }
                if(mudconf.have_comsys || mudconf.have_macros)
                        save_comsys_and_macros(mudconf.commac_db);
                if(mudconf.have_specials)
                        SaveSpecialObjects(DUMP_RESTART);
                return;
        }
        if(dump_type == DUMP_KILLED) {
                sprintf(tmpfile, "%s.KILLED", mudconf.indb);
                f = fopen(tmpfile, "w");
                if(f != NULL) {
                        /* Write a flatfile */
                        db_write(f, F_MUX, UNLOAD_VERSION | UNLOAD_OUTFLAGS);
                        fclose(f);
                } else {
                        log_perror("DMP", "FAIL", "Opening killed file", mudconf.indb);
                }
                if(mudconf.have_mailer)
                        if((f = fopen(mudconf.mail_db, "w"))) {
                                dump_mail(f);
                                fclose(f);
                        }
                if(mudconf.have_comsys || mudconf.have_macros)
                        save_comsys_and_macros(mudconf.commac_db);
                if(mudconf.have_specials)
                        SaveSpecialObjects(DUMP_KILLED);
                return;
        }

        sprintf(prevfile, "%s.prev", mudconf.outdb);
        sprintf(tmpfile, "%s.#%d#", mudconf.outdb, mudstate.epoch - 1);
        unlink(tmpfile);                        /*
                                                                 * nuke our predecessor 
                                                                 */
        sprintf(tmpfile, "%s.#%d#", mudconf.outdb, mudstate.epoch);

        if(mudconf.compress_db) {
                sprintf(tmpfile, "%s.#%d#.gz", mudconf.outdb, mudstate.epoch - 1);
                unlink(tmpfile);
                sprintf(tmpfile, "%s.#%d#.gz", mudconf.outdb, mudstate.epoch);
                StringCopy(outfn, mudconf.outdb);
                strcat(outfn, ".gz");
                f = popen(tprintf("%s > %s", mudconf.compress, tmpfile), "w");
                if(f) {
                        db_write(f, F_MUX, OUTPUT_VERSION | OUTPUT_FLAGS);
                        pclose(f);
                        rename(mudconf.outdb, prevfile);
                        if(rename(tmpfile, outfn) < 0)
                                log_perror("SAV", "FAIL",
                                                   "Renaming output file to DB file", tmpfile);
                } else {
                        log_perror("SAV", "FAIL", "Opening", tmpfile);
                }
        } else {
                f = fopen(tmpfile, "w");
                if(f) {
                        db_write(f, F_MUX, OUTPUT_VERSION | OUTPUT_FLAGS);
                        fclose(f);
                        rename(mudconf.outdb, prevfile);
                        if(rename(tmpfile, mudconf.outdb) < 0)
                                log_perror("SAV", "FAIL",
                                                   "Renaming output file to DB file", tmpfile);
                } else {
                        log_perror("SAV", "FAIL", "Opening", tmpfile);
                }
                rename(prevfile, mudconf.indb);
        }

        if(mudconf.have_mailer)
                if((f = fopen(mudconf.mail_db, "w"))) {
                        dump_mail(f);
                        fclose(f);
                }
        if(mudconf.have_comsys || mudconf.have_macros)
                save_comsys_and_macros(mudconf.commac_db);
        if(mudconf.have_specials)
                SaveSpecialObjects(DUMP_NORMAL);
}

void dump_database(void)
{
        char *buff;

        mudstate.epoch++;
        mudstate.dumping = 1;
        buff = alloc_mbuf("dump_database");
        sprintf(buff, "%s.#%d#", mudconf.outdb, mudstate.epoch);
        STARTLOG(LOG_DBSAVES, "DMP", "DUMP") {
                log_text((char *) "Dumping: ");
                log_text(buff);
                ENDLOG;
        } pcache_sync();

        dump_database_internal(DUMP_NORMAL);
        STARTLOG(LOG_DBSAVES, "DMP", "DONE") {
                log_text((char *) "Dump complete: ");
                log_text(buff);
                ENDLOG;
        } free_mbuf(buff);

        mudstate.dumping = 0;
}

void fork_and_dump(int key)
{
        char *buff;

        if(*mudconf.dump_msg)
                raw_broadcast(0, "%s", mudconf.dump_msg);

        check_mail_expiration();
        mudstate.epoch++;
        mudstate.dumping = 1;
        buff = alloc_mbuf("fork_and_dump");
        sprintf(buff, "%s.#%d#", mudconf.outdb, mudstate.epoch);
   
    log_error(LOG_DBSAVES, "DMP", "CHKPT", "Saving database: %s", buff);
    
    pcache_sync();
    
        if(!key || (key & DUMP_STRUCT)) {
                if(!fork()) {
            dprintk("child database write process starting.");
                        unbind_signals();
                        dump_database_internal(DUMP_NORMAL);
            dprintk("child database write process finished.");
            exit(0);
                }
        }

        mudstate.dumping = 0;

        if(*mudconf.postdump_msg)
                raw_broadcast(0, "%s", mudconf.postdump_msg);
}

static int load_game(void)
{
        FILE *f;
        int compressed;
        char infile[256];
        struct stat statbuf;
        int db_format, db_version, db_flags;

        f = NULL;
        compressed = 0;
        if(mudconf.compress_db) {
                StringCopy(infile, mudconf.indb);
                strcat(infile, ".gz");
                if(stat(infile, &statbuf) == 0) {
                        if((f = popen(tprintf(" %s < %s", mudconf.uncompress,
                                                                  infile), "r")) != NULL)
                                compressed = 1;
                }
        }
        if(compressed == 0) {
                StringCopy(infile, mudconf.indb);
                if((f = fopen(mudconf.indb, "r")) == NULL)
                        return -1;
        }
        /*
         * ok, read it in 
         */

        STARTLOG(LOG_STARTUP, "INI", "LOAD") {
                log_text((char *) "Loading: ");
                log_text(infile);
                ENDLOG;
        };
        if(db_read(f, &db_format, &db_version, &db_flags) < 0) {
                STARTLOG(LOG_ALWAYS, "INI", "FATAL") {
                        log_text((char *) "Error loading ");
                        log_text(infile);
                        ENDLOG;
                }
                if(compressed)
                        pclose(f);
                else
                        fclose(f);
                return -1;
        }
        if(compressed)
                pclose(f);
        else
                fclose(f);

        if(mudconf.have_comsys || mudconf.have_macros)
                load_comsys_and_macros(mudconf.commac_db);

        /* Load the mecha stuff.. */
        if(mudconf.have_specials)
                LoadSpecialObjects();

        if(mudconf.have_mailer)
                if((f = fopen(mudconf.mail_db, "r"))) {
                        load_mail(f);
                        fclose(f);
                }
        STARTLOG(LOG_STARTUP, "INI", "LOAD") {
                log_text((char *) "Load complete.");
                ENDLOG;
        }
        /*
         * everything ok 
         */
        return (0);
}

int list_check(dbref thing, dbref player, char type, char *str,
                           int check_parent)
{
        int match, limit;

        match = 0;
        limit = mudstate.db_top;
        while (thing != NOTHING) {
                if((thing != player) && (!(No_Command(thing)))) {
                        if(atr_match(thing, player, type, str, check_parent) > 0)
                                match = 1;
                }
                thing = Next(thing);
                if(--limit < 0)
                        return match;
        }
        return match;
}

int Hearer(dbref thing)
{
        char *as, *buff, *s;
        dbref aowner;
        int attr, aflags;
        ATTR *ap;

        if(mudstate.inpipe && (thing == mudstate.poutobj))
                return 1;

        if(Connected(thing) || Puppet(thing))
                return 1;

        if(Monitor(thing))
                buff = alloc_lbuf("Hearer");
        else
                buff = NULL;
        for(attr = atr_head(thing, &as); attr; attr = atr_next(&as)) {
                if(attr == A_LISTEN) {
                        if(buff)
                                free_lbuf(buff);
                        return 1;
                }
                if(Monitor(thing)) {
                        ap = atr_num(attr);
                        if(!ap || (ap->flags & AF_NOPROG))
                                continue;

                        atr_get_str(buff, thing, attr, &aowner, &aflags);

                        /*
                         * Make sure we can execute it 
                         */

                        if((buff[0] != AMATCH_LISTEN) || (aflags & AF_NOPROG))
                                continue;

                        /*
                         * Make sure there's a : in it 
                         */

                        for(s = buff + 1; *s && (*s != ':'); s++);
                        if(s) {
                                free_lbuf(buff);
                                return 1;
                        }
                }
        }
        if(buff)
                free_lbuf(buff);
        return 0;
}

void do_readcache(dbref player, dbref cause, int key)
{
        helpindex_load(player);
        fcache_load(player);
}

static void process_preload(void)
{
        dbref thing, parent, aowner;
        int aflags, lev, i;
        char *tstr;
        FWDLIST *fp;

        fp = (FWDLIST *) alloc_lbuf("process_preload.fwdlist");
        tstr = alloc_lbuf("process_preload.string");
        i = 0;
        DO_WHOLE_DB(thing) {

                /*
                 * Ignore GOING objects 
                 */

                if(Going(thing))
                        continue;

                do_top(10);

                /*
                 * Look for a STARTUP attribute in parents 
                 */

                ITER_PARENTS(thing, parent, lev) {
                        if(Flags(thing) & HAS_STARTUP) {
                                did_it(Owner(thing), thing, 0, NULL, 0, NULL, A_STARTUP,
                                           (char **) NULL, 0);
                                /*
                                 * Process queue entries as we add them 
                                 */

                                do_second();
                                do_top(10);
                                break;
                        }
                }

                /*
                 * Look for a FORWARDLIST attribute 
                 */

                if(H_Fwdlist(thing)) {
                        (void) atr_get_str(tstr, thing, A_FORWARDLIST, &aowner, &aflags);
                        if(*tstr) {
                                fwdlist_load(fp, GOD, tstr);
                                if(fp->count > 0)
                                        fwdlist_set(thing, fp);
                        }
                }
        }
        free_lbuf(fp);
        free_lbuf(tstr);
}

int main(int argc, char *argv[])
{
        int mindb;

        if((argc > 2) && (!strcmp(argv[1], "-s") && (argc > 3))) {
                fprintf(stderr, "Usage: %s [-s] [config-file]\n", argv[0]);
                exit(1);
        }

        event_init();

#if defined(HAVE_IEEEFP_H) && defined(HAVE_SYS_UCONTEXT_H)
        /*
         * Inhibit IEEE fp exception on overflow 
         */

        fpsetmask(fpgetmask() & ~FP_X_OFL);
#endif

        mindb = 0;                                      /* Are we creating a new db? */
        corrupt = 0;                            /* Database isn't corrupted. */
    memset(&mudstate, 0, sizeof(mudstate));
        time(&mudstate.start_time);
        time(&mudstate.restart_time);
        mudstate.executable_path = strdup(argv[0]);
    mudstate.db_top = -1;
        tcache_init();
        pcache_init();
        cf_init();
        init_rlimit();
        init_cmdtab();
        init_mactab();
        init_chantab();
        init_logout_cmdtab();
        init_flagtab();
        init_powertab();
        init_functab();
        init_attrtab();
        init_version();

#ifdef HUDINFO_SUPPORT
        init_hudinfo();
#endif

        hashinit(&mudstate.player_htab, 250 * HASH_FACTOR);
        nhashinit(&mudstate.mail_htab, 50 * HASH_FACTOR);
        nhashinit(&mudstate.fwdlist_htab, 25 * HASH_FACTOR);
        nhashinit(&mudstate.parent_htab, 5 * HASH_FACTOR);
        mudstate.desctree = rb_init(desc_cmp, NULL);
        vattr_init();

        if(argc > 1 && !strcmp(argv[1], "-s")) {
                mindb = 1;
                if(argc == 3)
                        cf_read(argv[2]);
                else
                        cf_read((char *) CONF_FILE);
        } else if(argc == 2) {
                cf_read(argv[1]);
        } else {
                cf_read((char *) CONF_FILE);
        }

        fcache_init();
        helpindex_init();
        db_free();

        mudstate.record_players = 0;

        if(mindb)
                db_make_minimal();
        else if(load_game() < 0) {
                STARTLOG(LOG_ALWAYS, "INI", "LOAD") {
                        log_text((char *) "Couldn't load: ");
                        log_text(mudconf.indb);
                        ENDLOG;
                } exit(2);
        }
#ifdef USE_PYTHON
        MUXPy_Init();
        runPythonHook("load");
#endif

        /* initialize random.. */
        srandom(getpid());
        /* set singnals.. */
        bind_signals();

        /*
         * Do a consistency check and set up the freelist 
         */

        do_dbck(NOTHING, NOTHING, 0);

        /*
         * Reset all the hash stats 
         */

        hashreset(&mudstate.command_htab);
        hashreset(&mudstate.macro_htab);
        hashreset(&mudstate.channel_htab);
        nhashreset(&mudstate.mail_htab);
        hashreset(&mudstate.logout_cmd_htab);
        hashreset(&mudstate.func_htab);
        hashreset(&mudstate.flags_htab);
        hashreset(&mudstate.attr_name_htab);
        hashreset(&mudstate.player_htab);
        nhashreset(&mudstate.fwdlist_htab);
        hashreset(&mudstate.news_htab);
        hashreset(&mudstate.help_htab);
        hashreset(&mudstate.wizhelp_htab);
        hashreset(&mudstate.plushelp_htab);
        hashreset(&mudstate.wiznews_htab);

        for(mindb = 0; mindb < MAX_GLOBAL_REGS; mindb++) {
                mudstate.global_regs[mindb] = alloc_lbuf("main.global_reg");
        memset(mudstate.global_regs[mindb], 0, LBUF_SIZE);
        }

        mudstate.now = time(NULL);
        process_preload();

        dnschild_init();

    if(!load_restart_db_xdr()) {
        load_restart_db();
    }

#ifdef SQL_SUPPORT
        sqlchild_init();
#endif

#ifdef ARBITRARY_LOGFILES
        logcache_init();
#endif

#ifdef MCHECK
        mtrace();
#endif

        /*
         * go do it 
         */

        mudstate.now = time(NULL);
        init_timer();
        shovechars(mudconf.port);

#ifdef MCHECK
        muntrace();
#endif

        close_sockets(0, (char *) "Going down - Bye");
        dump_database();

#ifdef ARBITRARY_LOGFILES
        logcache_destruct();
#endif
#ifdef SQL_SUPPORT
        sqlchild_destruct();
#endif

        exit(0);
}

static void init_rlimit(void)
{
#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_NOFILE)
        struct rlimit *rlp;

        rlp = (struct rlimit *) alloc_lbuf("rlimit");

        if(getrlimit(RLIMIT_NOFILE, rlp)) {
                log_perror("RLM", "FAIL", NULL, "getrlimit()");
                free_lbuf(rlp);
                return;
        }
        rlp->rlim_cur = rlp->rlim_max;
        if(setrlimit(RLIMIT_NOFILE, rlp))
                log_perror("RLM", "FAIL", NULL, "setrlimit()");
        free_lbuf(rlp);

#endif /*
            * HAVE_SETRLIMIT 
            */
}

---