root/1.8.3/trunk/src/game.c

/**
 * \file game.c
 *
 * \brief The main game driver.
 *
 *
 */

#include "copyrite.h"
#include "config.h"

#include <ctype.h>
#include <fcntl.h>
#include <string.h>
#include <signal.h>
#ifdef I_SYS_TIME
#include <sys/time.h>
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#endif
#else
#include <time.h>
#endif
#ifdef WIN32
#include <process.h>
#include <windows.h>
#undef OPAQUE                   /* Clashes with flags.h */
void Win32MUSH_setup(void);
#endif
#ifdef I_SYS_TYPES
#include <sys/types.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#include <stdlib.h>
#include <stdarg.h>
#ifdef I_UNISTD
#include <unistd.h>
#endif
#include <errno.h>

#include "conf.h"
#include "externs.h"
#include "mushdb.h"
#include "game.h"
#include "attrib.h"
#include "match.h"
#include "case.h"
#include "extmail.h"
#include "extchat.h"
#ifdef HAS_OPENSSL
#include "myssl.h"
#endif
#include "getpgsiz.h"
#include "parse.h"
#include "access.h"
#include "version.h"
#include "strtree.h"
#include "command.h"
#include "htab.h"
#include "ptab.h"
#include "log.h"
#include "lock.h"
#include "dbdefs.h"
#include "flags.h"
#include "function.h"
#include "help.h"
#include "dbio.h"
#include "mypcre.h"
#ifndef WIN32
#include "wait.h"
#endif
#include "ansi.h"

#ifdef hpux
#include <sys/syscall.h>
#define getrusage(x,p)   syscall(SYS_GETRUSAGE,x,p)
#endif                          /* fix to HP-UX getrusage() braindamage */

#include "confmagic.h"

/* declarations */
GLOBALTAB globals = { 0, "", 0, 0, 0, 0, 0, 0, 0, 0 };
static int epoch = 0;
static int reserved;                    /**< Reserved file descriptor */
static dbref *errdblist = NULL; /**< List of dbrefs to return errors from */
static dbref *errdbtail = NULL;        /**< Pointer to end of errdblist */
#define ERRDB_INITIAL_SIZE 5
static int errdbsize = ERRDB_INITIAL_SIZE; /**< Current size of errdblist array */
static void errdb_grow(void);


extern void initialize_mt(void);
extern const unsigned char *tables;
extern void conf_default_set(void);
static bool dump_database_internal(void);
static FILE *db_open(const char *filename);
static FILE *db_open_write(const char *filename);
static void db_close(FILE * f);
static int fail_commands(dbref player);
void do_readcache(dbref player);
int check_alias(const char *command, const char *list);
static int list_check(dbref thing, dbref player, char type,
                      char end, char *str, int just_match);
int alias_list_check(dbref thing, const char *command, const char *type);
int loc_alias_check(dbref loc, const char *command, const char *type);
void do_poor(dbref player, char *arg1);
void do_writelog(dbref player, char *str, int ltype);
void bind_and_queue(dbref player, dbref cause, char *action, const char *arg,
                    const char *placestr);
void do_scan(dbref player, char *command, int flag);
void do_list(dbref player, char *arg, int lc);
void do_dolist(dbref player, char *list, char *command,
               dbref cause, unsigned int flags);
void do_uptime(dbref player, int mortal);
static char *make_new_epoch_file(const char *basename, int the_epoch);
#ifdef HAS_GETRUSAGE
void rusage_stats(void);
#endif

void do_list_memstats(dbref player);
void do_list_allocations(dbref player);
void st_stats_header(dbref player);
void st_stats(dbref player, StrTree *root, const char *name);
void do_timestring(char *buff, char **bp, const char *format,
                   unsigned long secs);

extern void create_minimal_db(void);    /* From db.c */

dbref orator = NOTHING;  /**< Last dbref to issue a speech command */

#ifdef COMP_STATS
extern void compress_stats(long *entries,
                           long *mem_used,
                           long *total_uncompressed, long *total_compressed);
#endif


pid_t forked_dump_pid = -1;

/** Open /dev/null to reserve a file descriptor that can be reused later. */
void
reserve_fd(void)
{
#ifndef WIN32
  reserved = open("/dev/null", O_RDWR);
#endif
}

/** Release the reserved file descriptor for other use. */
void
release_fd(void)
{
#ifndef WIN32
  close(reserved);
#endif
}

/** User command to dump the database.
 * \verbatim
 * This implements the @dump command.
 * \endverbatim
 * \param player the enactor, for permission checking.
 * \param num checkpoint interval, as a string.
 * \param flag type of dump.
 */
void
do_dump(dbref player, char *num, enum dump_type flag)
{
  if (Wizard(player)) {
#ifdef ALWAYS_PARANOID
    if (1) {
#else
    if (flag != DUMP_NORMAL) {
#endif
      /* want to do a scan before dumping each object */
      globals.paranoid_dump = 1;
      if (num && *num) {
        /* checkpoint interval given */
        globals.paranoid_checkpt = atoi(num);
        if ((globals.paranoid_checkpt < 1)
            || (globals.paranoid_checkpt >= db_top)) {
          notify(player, T("Permission denied. Invalid checkpoint interval."));
          globals.paranoid_dump = 0;
          return;
        }
      } else {
        /* use a default interval */
        globals.paranoid_checkpt = db_top / 5;
        if (globals.paranoid_checkpt < 1)
          globals.paranoid_checkpt = 1;
      }
      if (flag == DUMP_PARANOID) {
        notify_format(player, T("Paranoid dumping, checkpoint interval %d."),
                      globals.paranoid_checkpt);
        do_rawlog(LT_CHECK,
                  "*** PARANOID DUMP *** done by %s(#%d),\n",
                  Name(player), player);
      } else {
        notify_format(player, T("Debug dumping, checkpoint interval %d."),
                      globals.paranoid_checkpt);
        do_rawlog(LT_CHECK,
                  "*** DEBUG DUMP *** done by %s(#%d),\n",
                  Name(player), player);
      }
      do_rawlog(LT_CHECK, T("\tcheckpoint interval %d, at %s"),
                globals.paranoid_checkpt, show_time(mudtime, 0));
    } else {
      /* normal dump */
      globals.paranoid_dump = 0;        /* just to be safe */
      notify(player, "Dumping...");
      do_rawlog(LT_CHECK, "** DUMP ** done by %s(#%d) at %s",
                Name(player), player, show_time(mudtime, 0));
    }
    fork_and_dump(1);
    globals.paranoid_dump = 0;
  } else {
    notify(player, T("Sorry, you are in a no dumping zone."));
  }
}


/** Print global variables to the trace log.
 * This function is used for error reporting.
 */
void
report(void)
{
  if (GoodObject(global_eval_context.cplr))
    do_rawlog(LT_TRACE, T("TRACE: Cmd:%s\tby #%d at #%d"),
              global_eval_context.ccom, global_eval_context.cplr,
              Location(global_eval_context.cplr));
  else
    do_rawlog(LT_TRACE, "TRACE: Cmd:%s\tby #%d", global_eval_context.ccom,
              global_eval_context.cplr);
  notify_activity(NOTHING, 0, 1);
}

#ifdef HAS_GETRUSAGE
/** Log process statistics to the error log.
 */
void
rusage_stats(void)
{
  struct rusage usage;
  int pid;
  int psize;

  pid = getpid();
  psize = getpagesize();
  getrusage(RUSAGE_SELF, &usage);

  do_rawlog(LT_ERR, T("Process statistics:"));
  do_rawlog(LT_ERR, T("Time used:   %10ld user   %10ld sys"),
            (long) usage.ru_utime.tv_sec, (long) usage.ru_stime.tv_sec);
  do_rawlog(LT_ERR, "Max res mem: %10ld pages  %10ld bytes",
            usage.ru_maxrss, (usage.ru_maxrss * psize));
  do_rawlog(LT_ERR, "Integral mem:%10ld shared %10ld private %10ld stack",
            usage.ru_ixrss, usage.ru_idrss, usage.ru_isrss);
  do_rawlog(LT_ERR,
            T("Page faults: %10ld hard   %10ld soft    %10ld swapouts"),
            usage.ru_majflt, usage.ru_minflt, usage.ru_nswap);
  do_rawlog(LT_ERR, T("Disk I/O:    %10ld reads  %10ld writes"),
            usage.ru_inblock, usage.ru_oublock);
  do_rawlog(LT_ERR, T("Network I/O: %10ld in     %10ld out"), usage.ru_msgrcv,
            usage.ru_msgsnd);
  do_rawlog(LT_ERR, T("Context swi: %10ld vol    %10ld forced"),
            usage.ru_nvcsw, usage.ru_nivcsw);
  do_rawlog(LT_ERR, "Signals:     %10ld", usage.ru_nsignals);
}

#endif                          /* HAS_GETRUSAGE */

/** User interface to shut down the MUSH.
 * \verbatim
 * This implements the @shutdown command.
 * \endverbatim
 * \param player the enactor, for permission checking.
 * \param flag type of shutdown to perform.
 */
void
do_shutdown(dbref player, enum shutdown_type flag)
{
  if (flag == SHUT_PANIC && !God(player)) {
    notify(player, T("It takes a God to make me panic."));
    return;
  }
  if (Wizard(player)) {
    flag_broadcast(0, 0, T("GAME: Shutdown by %s"), Name(player));
    do_log(LT_ERR, player, NOTHING, T("SHUTDOWN by %s(%s)\n"),
           Name(player), unparse_dbref(player));

    if (flag == SHUT_PANIC) {
      mush_panic("@shutdown/panic");
    } else {
      if (flag == SHUT_PARANOID) {
        globals.paranoid_checkpt = db_top / 5;
        if (globals.paranoid_checkpt < 1)
          globals.paranoid_checkpt = 1;
        globals.paranoid_dump = 1;
      }
      shutdown_flag = 1;
    }
  } else {
    notify(player, T("Your delusions of grandeur have been duly noted."));
  }
}

jmp_buf db_err;

static bool
dump_database_internal(void)
{
  char realdumpfile[2048];
  char realtmpfl[2048];
  char tmpfl[2048];
  FILE *f = NULL;

#ifndef PROFILING
#ifndef WIN32
  ignore_signal(SIGPROF);
#endif
#endif

  if (setjmp(db_err)) {
    /* The dump failed. Disk might be full or something went bad with the
       compression slave. Boo! */
    do_rawlog(LT_ERR, T("ERROR! Database save failed."));
    flag_broadcast("WIZARD ROYALTY", 0,
                   T("GAME: ERROR! Database save failed!"));
    if (f)
      db_close(f);
#ifndef PROFILING
#ifdef HAS_ITIMER
    install_sig_handler(SIGPROF, signal_cpu_limit);
#endif
#endif
    return false;
  } else {
    local_dump_database();

#ifdef ALWAYS_PARANOID
    globals.paranoid_checkpt = db_top / 5;
    if (globals.paranoid_checkpt < 1)
      globals.paranoid_checkpt = 1;
#endif

    sprintf(realdumpfile, "%s%s", globals.dumpfile, options.compresssuff);
    strcpy(tmpfl, make_new_epoch_file(globals.dumpfile, epoch));
    sprintf(realtmpfl, "%s%s", tmpfl, options.compresssuff);

    if ((f = db_open_write(tmpfl)) != NULL) {
      switch (globals.paranoid_dump) {
      case 0:
#ifdef ALWAYS_PARANOID
        db_paranoid_write(f, 0);
#else
        db_write(f, 0);
#endif
        break;
      case 1:
        db_paranoid_write(f, 0);
        break;
      case 2:
        db_paranoid_write(f, 1);
        break;
      }
      db_close(f);
      if (rename_file(realtmpfl, realdumpfile) < 0) {
        penn_perror(realtmpfl);
        longjmp(db_err, 1);
      }
    } else {
      penn_perror(realtmpfl);
      longjmp(db_err, 1);
    }
    sprintf(realdumpfile, "%s%s", options.mail_db, options.compresssuff);
    strcpy(tmpfl, make_new_epoch_file(options.mail_db, epoch));
    sprintf(realtmpfl, "%s%s", tmpfl, options.compresssuff);
    if (mdb_top >= 0) {
      if ((f = db_open_write(tmpfl)) != NULL) {
        dump_mail(f);
        db_close(f);
        if (rename_file(realtmpfl, realdumpfile) < 0) {
          penn_perror(realtmpfl);
          longjmp(db_err, 1);
        }
      } else {
        penn_perror(realtmpfl);
        longjmp(db_err, 1);
      }
    }
    sprintf(realdumpfile, "%s%s", options.chatdb, options.compresssuff);
    strcpy(tmpfl, make_new_epoch_file(options.chatdb, epoch));
    sprintf(realtmpfl, "%s%s", tmpfl, options.compresssuff);
    if ((f = db_open_write(tmpfl)) != NULL) {
      save_chatdb(f);
      db_close(f);
      if (rename_file(realtmpfl, realdumpfile) < 0) {
        penn_perror(realtmpfl);
        longjmp(db_err, 1);
      }
    } else {
      penn_perror(realtmpfl);
      longjmp(db_err, 1);
    }
    time(&globals.last_dump_time);
  }

#ifndef PROFILING
#ifdef HAS_ITIMER
  install_sig_handler(SIGPROF, signal_cpu_limit);
#endif
#endif

  return true;
}

/** Crash gracefully.
 * This function is called when something disastrous happens - typically
 * a failure to malloc memory or a signal like segfault.
 * It logs the fault, does its best to dump a panic database, and
 * exits abruptly. This function does not return.
 * \param message message to log to the error log.
 */
void
mush_panic(const char *message)
{
  const char *panicfile = options.crash_db;
  FILE *f = NULL;
  static int already_panicking = 0;

  if (already_panicking) {
    do_rawlog(LT_ERR,
              T
              ("PANIC: Attempted to panic because of '%s' while already panicking. Run in circles, scream and shout!"),
              message);
    _exit(133);
  }

  already_panicking = 1;
  do_rawlog(LT_ERR, "PANIC: %s", message);
  report();
  flag_broadcast(0, 0, "EMERGENCY SHUTDOWN: %s", message);

  /* turn off signals */
  block_signals();

  /* shut down interface */
  emergency_shutdown();

  /* dump panic file if we have a database read. */
  if (globals.database_loaded) {
    if (setjmp(db_err)) {
      /* Dump failed. We're in deep doo-doo */
      do_rawlog(LT_ERR, T("CANNOT DUMP PANIC DB. OOPS."));
      _exit(134);
    } else {
      if ((f = fopen(panicfile, FOPEN_WRITE)) == NULL) {
        do_rawlog(LT_ERR, T("CANNOT OPEN PANIC FILE, YOU LOSE"));
        _exit(135);
      } else {
        do_rawlog(LT_ERR, T("DUMPING: %s"), panicfile);
        db_write(f, DBF_PANIC);
        dump_mail(f);
        save_chatdb(f);
        fclose(f);
        do_rawlog(LT_ERR, T("DUMPING: %s (done)"), panicfile);
      }
    }
  } else {
    do_rawlog(LT_ERR, T("Skipping panic dump because database isn't loaded."));
  }
  _exit(136);
}

/** Crash gracefully.
 * Calls mush_panic() with its arguments formatted.
 * \param msg printf()-style format string.
 */
void
mush_panicf(const char *msg, ...)
{
#ifdef HAS_VSNPRINTF
  char c[BUFFER_LEN];
#else
  char c[BUFFER_LEN * 3];
#endif
  va_list args;

  va_start(args, msg);

#ifdef HAS_VSNPRINTF
  vsnprintf(c, sizeof c, msg, args);
#else
  vsprintf(c, msg, args);
#endif
  c[BUFFER_LEN - 1] = '\0';
  va_end(args);

  mush_panic(c);
  _exit(136);                   /* Not reached but kills warnings */
}

/** Dump the database.
 * This function is a wrapper for dump_database_internal() that does
 * a little logging before and after the dump.
 */
void
dump_database(void)
{
  epoch++;

  do_rawlog(LT_ERR, "DUMPING: %s.#%d#", globals.dumpfile, epoch);
  if (dump_database_internal())
    do_rawlog(LT_ERR, "DUMPING: %s.#%d# (done)", globals.dumpfile, epoch);
}

/** Dump a database, possibly by forking the process.
 * This function calls dump_database_internal() to dump the MUSH
 * databases. If we're configured to do so, it forks first, so that
 * the child process can perform the dump while the parent continues
 * to run the MUSH for the players. If we can't fork, this function
 * warns players online that a dump is taking place and the game
 * may pause.
 * \param forking if 1, attempt a forking dump.
 */
void
fork_and_dump(int forking)
{
  pid_t child;
  bool nofork, status, split;
  epoch++;

#ifdef LOG_CHUNK_STATS
  chunk_stats(NOTHING, 0);
  chunk_stats(NOTHING, 1);
#endif
  do_rawlog(LT_CHECK, "CHECKPOINTING: %s.#%d#", globals.dumpfile, epoch);
  if (NO_FORK)
    nofork = 1;
  else
    nofork = !forking || (globals.paranoid_dump == 2);  /* Don't fork for dump/debug */
#if defined(WIN32) || !defined(HAVE_FORK)
  nofork = 1;
#endif
  split = 0;
  if (!nofork && chunk_num_swapped()) {
#ifndef WIN32
    /* Try to clone the chunk swapfile. */
    if (chunk_fork_file()) {
      split = 1;
    } else {
      /* Ack, can't fork, 'cause we have stuff on disk... */
      do_log(LT_ERR, 0, 0,
             "fork_and_dump: Data are swapped to disk, so nonforking dumps will be used.");
      flag_broadcast("WIZARD", 0,
                     "DUMP: Data are swapped to disk, so nonforking dumps will be used.");
      nofork = 1;
    }
#endif
  }
  if (!nofork) {