root/1.8.3/trunk/src/cque.c

/**
 * \file cque.c
 *
 * \brief Queue for PennMUSH.
 *
 *
 */

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

#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <signal.h>
#include <string.h>
#ifdef I_SYS_TIME
#include <sys/time.h>
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#endif
#else
#include <time.h>
#endif

#include "conf.h"
#include "command.h"
#include "mushdb.h"
#include "match.h"
#include "externs.h"
#include "parse.h"
#include "strtree.h"
#include "mymalloc.h"
#include "game.h"
#include "attrib.h"
#include "flags.h"
#include "dbdefs.h"
#include "log.h"
#include "confmagic.h"


EVAL_CONTEXT global_eval_context;

/** A queue entry.
 * This structure reprsents a queue entry on a linked list of queue
 * entries (a queue). It is used for all of the queues.
 */
typedef struct bque {
  struct bque *next;                    /**< pointer to next entry on queue */
  dbref player;                 /**< player who will do command */
  dbref queued;                 /**< object whose QUEUE gets incremented for this command */
  dbref cause;                  /**< player causing command (for %N) */
  dbref sem;                    /**< semaphore object to block on */
  char *semattr;                /**< semaphore attribute to block on */
  time_t left;                  /**< seconds left until execution */
  char *env[10];                /**< environment, from wild match */
  char *rval[NUMQ];             /**< environment, from setq() */
  char *comm;                   /**< command to be executed */
} BQUE;

slab *bque_slab = NULL; /**< slab for 'struct bque' allocations */

static BQUE *qfirst = NULL, *qlast = NULL, *qwait = NULL;
static BQUE *qlfirst = NULL, *qllast = NULL;
static BQUE *qsemfirst = NULL, *qsemlast = NULL;

static int add_to_generic(dbref player, int am, const char *name,
                          uint32_t flags);
static int add_to(dbref player, int am);
static int add_to_sem(dbref player, int am, const char *name);
static int queue_limit(dbref player);
void free_qentry(BQUE *point);
static int pay_queue(dbref player, const char *command);
void wait_que(dbref player, int waituntil, char *command,
              dbref cause, dbref sem, const char *semattr, int until);
int que_next(void);

static void show_queue(dbref player, dbref victim, int q_type,
                       int q_quiet, int q_all, BQUE *q_ptr, int *tot, int *self,
                       int *del);
static void do_raw_restart(dbref victim);
static int waitable_attr(dbref thing, const char *atr);
static void shutdown_a_queue(BQUE **head, BQUE **tail);

extern sig_atomic_t cpu_time_limit_hit; /**< Have we used too much CPU? */

/** Attribute flags to be set or checked on attributes to be used
 * as semaphores.
 */
#define SEMAPHORE_FLAGS (AF_LOCKED | AF_PRIVATE | AF_NOCOPY | AF_NODUMP)

/** Queue initializtion function. Must  be called before anything
 * is added to the queue.
 */
void
init_queue(void)
{
  bque_slab = slab_create("command queues", sizeof(BQUE));
  slab_set_opt(bque_slab, SLAB_ALLOC_BEST_FIT, 1);
}

/* Returns true if the attribute on thing can be used as a semaphore.
 * atr should be given in UPPERCASE. 
 */
static int
waitable_attr(dbref thing, const char *atr)
{
  ATTR *a;
  if (!atr || !*atr)
    return 0;
  a = atr_get_noparent(thing, atr);
  if (!a) {                     /* Attribute isn't set */
    a = atr_match(atr);
    if (!a)                     /* It's not a built in attribute */
      return 1;
    return !strcmp(AL_NAME(a), "SEMAPHORE");    /* Only allow SEMAPHORE for now */
  } else {                      /* Attribute is set. Check for proper owner and flags and value */
    if ((AL_CREATOR(a) == GOD) && (AL_FLAGS(a) == SEMAPHORE_FLAGS)) {
      char *v = atr_value(a);
      if (!*v || is_integer(v))
        return 1;
      else
        return 0;
    } else {
      return 0;
    }
  }
  return 0;                     /* Not reached */
}

static int
add_to_generic(dbref player, int am, const char *name, uint32_t flags)
{
  int num = 0;
  ATTR *a;
  char buff[MAX_COMMAND_LEN];
  a = atr_get_noparent(player, name);
  if (a)
    num = parse_integer(atr_value(a));
  num += am;
  /* We set the attribute's value to 0 even if we're going to clear
   * it later, because clearing it may fail (perhaps someone's also
   * foolishly using it as a branch in an attribute tree)
   */
  snprintf(buff, sizeof buff, "%d", num);
  (void) atr_add(player, name, buff, GOD, flags);
  if (!num) {
    (void) atr_clr(player, name, GOD);
  }
  return num;
}

static int
add_to(dbref player, int am)
{
  return add_to_generic(player, am, "QUEUE", NOTHING);
}

static int
add_to_sem(dbref player, int am, const char *name)
{
  return add_to_generic(player, am, name ? name : "SEMAPHORE", SEMAPHORE_FLAGS);
}

static int
queue_limit(dbref player)
{
  /* returns 1 if player has exceeded his queue limit, and always
     increments QUEUE by one. */
  int nlimit;

  nlimit = add_to(player, 1);
  if (HugeQueue(player))
    return nlimit > (QUEUE_QUOTA + db_top);
  else
    return nlimit > QUEUE_QUOTA;
}

/** Free a queue entry.
 * \param point queue entry to free.
 */
void
free_qentry(BQUE *point)
{
  int a;
  for (a = 0; a < 10; a++)
    if (point->env[a]) {
      mush_free((Malloc_t) point->env[a], "bqueue_env");
    }
  for (a = 0; a < NUMQ; a++)
    if (point->rval[a]) {
      mush_free((Malloc_t) point->rval[a], "bqueue_rval");
    }
  if (point->semattr)
    mush_free((Malloc_t) point->semattr, "bqueue_semattr");
  if (point->comm)
    mush_free((Malloc_t) point->comm, "bqueue_comm");
  slab_free(bque_slab, point);
}

static int
pay_queue(dbref player, const char *command)
{
  int estcost;
  estcost =
    QUEUE_COST +
    (QUEUE_LOSS ? ((get_random_long(0, QUEUE_LOSS - 1) == 0) ? 1 : 0) : 0);
  if (!quiet_payfor(player, estcost)) {
    notify(Owner(player), T("Not enough money to queue command."));
    return 0;
  }
  if (!NoPay(player) && (estcost != QUEUE_COST) && Track_Money(Owner(player))) {
    char *preserve_wnxt[10];
    char *preserve_rnxt[NUMQ];
    char *val_wnxt[10];
    char *val_rnxt[NUMQ];
    char *preserves[10];
    char *preserveq[NUMQ];
    save_global_nxt("pay_queue_save", preserve_wnxt, preserve_rnxt, val_wnxt,
                    val_rnxt);
    save_global_regs("pay_queue_save", preserveq);
    save_global_env("pay_queue_save", preserves);
    notify_format(Owner(player),
                  T("GAME: Object %s(%s) lost a %s to queue loss."),
                  Name(player), unparse_dbref(player), MONEY);
    restore_global_regs("pay_queue_save", preserveq);
    restore_global_env("pay_queue_save", preserves);
    restore_global_nxt("pay_queue_save", preserve_wnxt, preserve_rnxt, val_wnxt,
                       val_rnxt);
  }
  if (queue_limit(QUEUE_PER_OWNER ? Owner(player) : player)) {
    notify_format(Owner(player),
                  T("Runaway object: %s(%s). Commands halted."),
                  Name(player), unparse_dbref(player));
    do_log(LT_TRACE, player, player, T("Runaway object %s executing: %s"),
           unparse_dbref(player), command);
    /* Refund the queue costs */
    giveto(player, QUEUE_COST);
    add_to(QUEUE_PER_OWNER ? Owner(player) : player, -1);
    /* wipe out that object's queue and set it HALT */
    do_halt(Owner(player), "", player);
    set_flag_internal(player, "HALT");
    return 0;
  }
  return 1;
}

/** Add a new entry onto the player or object command queues.
 * This function adds a new entry to the back of the player or
 * object command queues (depending on whether the call was
 * caused by a player or an object).
 * \param player the enactor for the queued command.
 * \param command the command to enqueue.
 * \param cause the player or object causing the command to be queued.
 */
void
parse_que(dbref player, const char *command, dbref cause)
{
  int a;
  BQUE *tmp;
  if (!IsPlayer(player) && (Halted(player)))
    return;
  if (!pay_queue(player, command))      /* make sure player can afford to do it */
    return;
  tmp = slab_malloc(bque_slab, NULL);
  tmp->comm = mush_strdup(command, "bqueue_comm");
  tmp->semattr = NULL;
  tmp->player = player;
  tmp->queued = QUEUE_PER_OWNER ? Owner(player) : player;
  tmp->next = NULL;
  tmp->left = 0;
  tmp->cause = cause;
  for (a = 0; a < 10; a++)
    if (!global_eval_context.wnxt[a])
      tmp->env[a] = NULL;
    else {
      tmp->env[a] = mush_strdup(global_eval_context.wnxt[a], "bqueue_env");
    }
  for (a = 0; a < NUMQ; a++)
    if (!global_eval_context.rnxt[a] || !global_eval_context.rnxt[a][0])
      tmp->rval[a] = NULL;
    else {
      tmp->rval[a] = mush_strdup(global_eval_context.rnxt[a], "bqueue_rval");
    }
  if (IsPlayer(cause)) {
    if (qlast) {
      qlast->next = tmp;
      qlast = tmp;
    } else
      qlast = qfirst = tmp;
  } else {
    if (qllast) {
      qllast->next = tmp;
      qllast = tmp;
    } else
      qllast = qlfirst = tmp;
  }
}


/** Enqueue the action part of an attribute.
 * This function is a front-end to parse_que() that takes an attribute, 
 * removes ^....: or $....: from its value, and queues what's left.
 * \param executor object containing the attribute.
 * \param atrname attribute name.
 * \param enactor the enactor.
 * \param noparent if true, parents of executor are not checked for atrname.
 * \retval 0 failure.
 * \retval 1 success.
 */
int
queue_attribute_base(dbref executor, const char *atrname, dbref enactor,
                     int noparent)
{
  ATTR *a;

  a = queue_attribute_getatr(executor, atrname, noparent);
  if (!a)
    return 0;
  queue_attribute_useatr(executor, a, enactor);
  return 1;
}

ATTR *
queue_attribute_getatr(dbref executor, const char *atrname, int noparent)
{
  return (noparent ? atr_get_noparent(executor, strupper(atrname)) :
          atr_get(executor, strupper(atrname)));
}

int
queue_attribute_useatr(dbref executor, ATTR *a, dbref enactor)
{
  char *start, *command;
  start = safe_atr_value(a);
  command = start;
  /* Trim off $-command or ^-command prefix */
  if (*command == '$' || *command == '^') {
    do {
      command = strchr(command + 1, ':');
    } while (command && command[-1] == '\\');
    if (!command)
      /* Oops, had '$' or '^', but no ':' */
      command = start;
    else
      /* Skip the ':' */
      command++;
  }
  parse_que(executor, command, enactor);
  free(start);
  return 1;
}


/** Queue an entry on the wait or semaphore queues.
 * This function creates and adds a queue entry to the wait queue
 * or the semaphore queue. Wait queue entries are sorted by when
 * they're due to expire; semaphore queue entries are just added
 * to the back of the queue.
 * \param player the enqueuing object.
 * \param waittill time to wait, or 0.
 * \param command command to enqueue.
 * \param cause object that caused command to be enqueued.
 * \param sem object to serve as a semaphore, or NOTHING.
 * \param semattr attribute to serve as a semaphore, or NULL (to use SEMAPHORE).
 * \param until 1 if we wait until an absolute time.
 */
void
wait_que(dbref player, int waittill, char *command, dbref cause, dbref sem,
         const char *semattr, int until)
{
  BQUE *tmp;
  int a;
  if (waittill == 0) {
    if (sem != NOTHING)
      add_to_sem(sem, -1, semattr);
    parse_que(player, command, cause);
    return;
  }
  if (!pay_queue(player, command))      /* make sure player can afford to do it */
    return;
  tmp = slab_malloc(bque_slab, NULL);
  tmp->comm = mush_strdup(command, "bqueue_comm");
  tmp->player = player;
  tmp->queued = QUEUE_PER_OWNER ? Owner(player) : player;
  tmp->cause = cause;
  tmp->semattr = NULL;
  tmp->next = NULL;
  for (a = 0; a < 10; a++) {
    if (!global_eval_context.wnxt[a])
      tmp->env[a] = NULL;
    else {
      tmp->env[a] = mush_strdup(global_eval_context.wnxt[a], "bqueue_env");
    }
  }
  for (a = 0; a < NUMQ; a++) {
    if (!global_eval_context.rnxt[a] || !global_eval_context.rnxt[a][0])
      tmp->rval[a] = NULL;
    else {
      tmp->rval[a] = mush_strdup(global_eval_context.rnxt[a], "bqueue_rval");
    }
  }

  if (until) {
    tmp->left = (time_t) waittill;
  } else {
    if (waittill >= 0)
      tmp->left = mudtime + waittill;
    else
      tmp->left = 0;            /* semaphore wait without a timeout */
  }
  tmp->sem = sem;
  if (sem == NOTHING) {
    /* No semaphore, put on normal wait queue, sorted by time */
    BQUE *point, *trail = NULL;

    for (point = qwait;
         point && (point->left <= tmp->left); point = point->next)
      trail = point;

    tmp->next = point;
    if (trail != NULL)
      trail->next = tmp;
    else
      qwait = tmp;
  } else {

    /* Put it on the end of the semaphore queue */
    tmp->semattr =
      mush_strdup(semattr ? semattr : "SEMAPHORE", "bqueue_semattr");
    if (qsemlast != NULL) {
      qsemlast->next = tmp;
      qsemlast = tmp;
    } else {
      qsemfirst = qsemlast = tmp;
    }
  }
}

/** Once-a-second check for queued commands.
 * This function is called every second to check for commands
 * on the wait queue or semaphore queue, and to move a command
 * off the low priority object queue and onto the normal priority
 * player queue.
 */
void
do_second(void)
{
  BQUE *trail = NULL, *point, *next;
  /* move contents of low priority queue onto end of normal one 
   * this helps to keep objects from getting out of control since 
   * its effects on other objects happen only after one second 
   * this should allow @halt to be typed before getting blown away 
   * by scrolling text.
   */
  if (qlfirst) {
    if (qlast)
      qlast->next = qlfirst;
    else
      qfirst = qlfirst;
    qlast = qllast;
    qllast = qlfirst = NULL;
  }
  /* check regular wait queue */

  while (qwait && qwait->left <= mudtime) {
    point = qwait;
    qwait = point->next;
    point->next = NULL;
    point->left = 0;
    if (IsPlayer(point->cause)) {
      if (qlast) {
        qlast->next = point;
        qlast = point;
      } else
        qlast = qfirst = point;
    } else {
      if (qllast) {
        qllast->next = point;
        qllast = point;
      } else
        qllast = qlfirst = point;
    }
  }

  /* check for semaphore timeouts */

  for (point = qsemfirst, trail = NULL; point; point = next) {
    if (point->left == 0 || point->left > mudtime) {
      next = (trail = point)->next;
      continue;                 /* skip non-timed and those that haven't gone off yet */
    }
    if (trail != NULL)
      trail->next = next = point->next;
    else
      qsemfirst = next = point->next;
    if (point == qsemlast)
      qsemlast = trail;
    add_to_sem(point->sem, -1, point->semattr);
    point->sem = NOTHING;
    point->next = NULL;
    if (IsPlayer(point->cause)) {
      if (qlast) {
        qlast->next = point;
        qlast = point;
      } else
        qlast = qfirst = point;
    } else {
      if (qllast) {
        qllast->next = point;
        qllast = point