root/1.8.3/trunk/src/fundb.c

/**
 * \file fundb.c
 *
 * \brief Dbref-related functions for mushcode.
 *
 *
 */

#include "copyrite.h"

#include "config.h"
#include <string.h>
#include "conf.h"
#include "externs.h"
#include "dbdefs.h"
#include "flags.h"

#include "match.h"
#include "parse.h"
#include "command.h"
#include "game.h"
#include "mushdb.h"
#include "privtab.h"
#include "lock.h"
#include "log.h"
#include "attrib.h"
#include "function.h"
#include "confmagic.h"

#ifdef WIN32
#pragma warning( disable : 4761)        /* NJG: disable warning re conversion */
#endif

extern PRIV attr_privs_view[];
static lock_type get_locktype(char *str);
extern struct db_stat_info *get_stats(dbref owner);
static int lattr_helper(dbref player, dbref thing, dbref parent,
                        char const *pattern, ATTR *atr, void *args);
static dbref
 dbwalk(char *buff, char **bp, dbref executor, dbref enactor,
        int type, dbref loc, dbref after, int skipdark,
        int start, int count, int *retcount);


const char *
do_get_attrib(dbref executor, dbref thing, const char *attrib)
{
  ATTR *a;
  char const *value;

  a = atr_get(thing, strupper(attrib));
  if (a) {
    if (Can_Read_Attr(executor, thing, a)) {
      if (strlen(value = atr_value(a)) < BUFFER_LEN)
        return value;
      else
        return T("#-1 ATTRIBUTE LENGTH TOO LONG");
    }
    return T(e_atrperm);
  }
  a = atr_match(attrib);
  if (a) {
    if (Can_Read_Attr(executor, thing, a))
      return "";
    return T(e_atrperm);
  }
  if (!Can_Examine(executor, thing))
    return T(e_atrperm);
  return "";
}

/** Structure containing arguments for lattr_helper */
struct lh_args {
  int first;            /**< Is this is the first attribute, or later? */
  int nattr;
  int start;            /**< Where do we start counting? */
  int count;            /**< How many do we count? */
  char *buff;           /**< Buffer to store output */
  char **bp;            /**< Pointer to address of insertion point in buff */
  char delim;           /**< Delimiter */
};

/* this function produces a space-separated list of attributes that are
 * on an object.
 */
/* ARGSUSED */
static int
lattr_helper(dbref player __attribute__ ((__unused__)),
             dbref thing __attribute__ ((__unused__)),
             dbref parent __attribute__ ((__unused__)),
             char const *pattern __attribute__ ((__unused__)),
             ATTR *atr, void *args)
{
  struct lh_args *lh = args;
  lh->nattr++;
  if (lh->count < 1
      || (lh->nattr >= lh->start && lh->nattr < (lh->count + lh->start))) {
    if (lh->first)
      lh->first = 0;
    else
      safe_chr(lh->delim, lh->buff, lh->bp);
    safe_str(AL_NAME(atr), lh->buff, lh->bp);
    return 1;
  }
  return 1;
}

/* ARGSUSED */
FUNCTION(fun_nattr)
{
  dbref thing;
  int doparent;
  static const char *matchall = "**";   /* count atrees by default too */
  char *pattern;

  pattern = strchr(args[0], '/');
  if (pattern)
    *pattern++ = '\0';
  else
    pattern = (char *) matchall;        /* match anything */

  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }

  doparent = strchr(called_as, 'P') ? 1 : 0;

  if (!doparent && pattern == matchall && Can_Examine(executor, thing)) {
    safe_integer(AttrCount(thing), buff, bp);
  } else {
    safe_integer(atr_pattern_count(executor, thing, pattern, doparent,
                                   !Can_Examine(executor, thing)), buff, bp);
  }
}

/* ARGSUSED */
FUNCTION(fun_lattr)
{
  dbref thing;
  char *pattern;
  struct lh_args lh;
  char delim;

  lh.nattr = lh.start = lh.count = 0;

  if (*called_as == 'X') {
    if (!is_strict_integer(args[1]) || !is_strict_integer(args[2])) {
      safe_str(T(e_int), buff, bp);
      return;
    }

    lh.start = parse_integer(args[1]);
    lh.count = parse_integer(args[2]);

    if (lh.start < 1 || lh.count < 1) {
      safe_str(T("#-1 ARGUMENT OUT OF RANGE"), buff, bp);
      return;
    }

    if (!delim_check(buff, bp, nargs, args, 4, &delim))
      return;
  } else {
    /* lattr()/lattrp*( */
    if (!delim_check(buff, bp, nargs, args, 2, &delim))
      return;
  }

  pattern = strchr(args[0], '/');
  if (pattern)
    *pattern++ = '\0';
  else
    pattern = (char *) "*";     /* match anything */

  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  lh.first = 1;
  lh.buff = buff;
  lh.bp = bp;
  lh.delim = delim;

  if (strchr(called_as, 'P')) {
    (void) atr_iter_get_parent(executor, thing, pattern,
                               !Can_Examine(executor, thing), lattr_helper,
                               &lh);
  } else {
    (void) atr_iter_get(executor, thing, pattern,
                        !Can_Examine(executor, thing), lattr_helper, &lh);
  }
}

/* ARGSUSED */
FUNCTION(fun_hasattr)
{
  dbref thing;
  ATTR *a;

  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  if (strchr(called_as, 'P'))
    a = atr_get(thing, upcasestr(args[1]));
  else
    a = atr_get_noparent(thing, upcasestr(args[1]));
  if (a && Can_Read_Attr(executor, thing, a)) {
    if (strchr(called_as, 'V'))
      safe_chr(*AL_STR(a) ? '1' : '0', buff, bp);
    else
      safe_chr('1', buff, bp);
    return;
  } else if (a || !Can_Examine(executor, thing)) {
    safe_str(T(e_perm), buff, bp);
    return;
  }
  safe_chr('0', buff, bp);
}

/* ARGSUSED */
FUNCTION(fun_get)
{
  dbref thing;
  char *s;

  s = strchr(args[0], '/');
  if (!s) {
    safe_str(T("#-1 BAD ARGUMENT FORMAT TO GET"), buff, bp);
    return;
  }
  *s++ = '\0';
  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  safe_str(do_get_attrib(executor, thing, s), buff, bp);
}

/* Functions like get, but uses the standard way of passing arguments */
/* to a function, and thus doesn't choke on nested functions within.  */

/* ARGSUSED */
FUNCTION(fun_xget)
{
  dbref thing;

  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  safe_str(do_get_attrib(executor, thing, args[1]), buff, bp);
}

/* Functions like get, but includes a default response if the
 * attribute isn't present or is null
 */
/* ARGSUSED */
FUNCTION(fun_default)
{
  dbref thing;
  ATTR *attrib;
  char *dp;
  const char *sp;
  char mstr[BUFFER_LEN];
  int i;
  /* find our object and attribute */
  for (i = 1; i < nargs; i++) {
    mstr[0] = '\0';
    dp = mstr;
    sp = args[i - 1];
    process_expression(mstr, &dp, &sp, executor, caller, enactor, PE_DEFAULT,
                       PT_DEFAULT, pe_info);
    *dp = '\0';
    parse_attrib(executor, mstr, &thing, &attrib);
    if (GoodObject(thing) && attrib && Can_Read_Attr(executor, thing, attrib)) {
      /* Ok, we've got it */
      dp = safe_atr_value(attrib);
      safe_str(dp, buff, bp);
      free(dp);
      return;
    }
  }
  /* We couldn't get it. Evaluate the last arg and return it */
  sp = args[nargs - 1];
  process_expression(buff, bp, &sp, executor, caller, enactor,
                     PE_DEFAULT, PT_DEFAULT, pe_info);
  return;
}

/* ARGSUSED */
FUNCTION(fun_eval)
{
  /* like xget, except pronoun substitution is done */

  dbref thing;
  char *tbuf;
  char const *tp;
  ATTR *a;

  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  a = atr_get(thing, upcasestr(args[1]));
  if (a && Can_Read_Attr(executor, thing, a)) {
    if (!CanEvalAttr(executor, thing, a)) {
      safe_str(T(e_perm), buff, bp);
      return;
    }
    tp = tbuf = safe_atr_value(a);
    add_check("fun_eval.attr_value");
    process_expression(buff, bp, &tp, thing, executor, executor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    mush_free((Malloc_t) tbuf, "fun_eval.attr_value");
    return;
  } else if (a || !Can_Examine(executor, thing)) {
    safe_str(T(e_atrperm), buff, bp);
    return;
  }
  return;
}

/* ARGSUSED */
FUNCTION(fun_get_eval)
{
  /* like eval, except uses obj/attr syntax. 2.x compatibility */

  dbref thing;
  char *tbuf, *s;
  char const *tp;
  ATTR *a;

  s = strchr(args[0], '/');
  if (!s) {
    safe_str(T("#-1 BAD ARGUMENT FORMAT TO GET_EVAL"), buff, bp);
    return;
  }
  *s++ = '\0';
  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  a = atr_get(thing, upcasestr(s));
  if (a && Can_Read_Attr(executor, thing, a)) {
    if (!CanEvalAttr(executor, thing, a)) {
      safe_str(T(e_perm), buff, bp);
      return;
    }
    tp = tbuf = safe_atr_value(a);
    add_check("fun_eval.attr_value");
    process_expression(buff, bp, &tp, thing, executor, executor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    mush_free((Malloc_t) tbuf, "fun_eval.attr_value");
    return;
  } else if (a || !Can_Examine(executor, thing)) {
    safe_str(T(e_atrperm), buff, bp);
    return;
  }
  return;
}

/* Functions like eval, but includes a default response if the
 * attribute isn't present or is null
 */
/* ARGSUSED */
FUNCTION(fun_edefault)
{
  dbref thing;
  ATTR *attrib;
  char *dp, *sbuf;
  char const *sp;
  char mstr[BUFFER_LEN];
  /* find our object and attribute */
  dp = mstr;
  sp = args[0];
  process_expression(mstr, &dp, &sp, executor, caller, enactor,
                     PE_DEFAULT, PT_DEFAULT, pe_info);
  *dp = '\0';
  parse_attrib(executor, mstr, &thing, &attrib);
  if (GoodObject(thing) && attrib && Can_Read_Attr(executor, thing, attrib)) {
    if (!CanEvalAttr(executor, thing, attrib)) {
      safe_str(T(e_perm), buff, bp);
      return;
    }
    /* Ok, we've got it */
    sp = sbuf = safe_atr_value(attrib);
    add_check("fun_edefault.attr_value");
    process_expression(buff, bp, &sp, thing, executor, executor,
                       PE_DEFAULT, PT_DEFAULT, pe_info);
    mush_free((Malloc_t) sbuf, "fun_edefault.attr_value");
    return;
  }
  /* We couldn't get it. Evaluate args[1] and return it */
  sp = args[1];
  process_expression(buff, bp, &sp, executor, caller, enactor,
                     PE_DEFAULT, PT_DEFAULT, pe_info);
  return;
}

/* ARGSUSED */
FUNCTION(fun_v)
{
  /* handle 0-9, va-vz, n, l, # */

  int c;

  if (args[0][0] && !args[0][1]) {
    switch (c = args[0][0]) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      if (global_eval_context.wenv[c - '0'])
        safe_str(global_eval_context.wenv[c - '0'], buff, bp);
      return;
    case '#':
      /* enactor dbref */
      safe_dbref(enactor, buff, bp);
      return;
    case '@':
      /* caller dbref */
      safe_dbref(caller, buff, bp);
      return;
    case '!':
      /* executor dbref */
      safe_dbref(executor, buff, bp);
      return;
    case 'n':
    case 'N':
      /* enactor name */
      safe_str(Name(enactor), buff, bp);
      return;
    case 'l':
    case 'L':
      /* giving the location does not violate security,
       * since the object is the enactor.  */
      safe_dbref(Location(enactor), buff, bp);
      return;
    case 'c':
    case 'C':
      safe_str(global_eval_context.ccom, buff, bp);
      return;
    }
  }
  safe_str(do_get_attrib(executor, executor, args[0]), buff, bp);
}

/* ARGSUSED */
FUNCTION(fun_flags)
{
  dbref thing;
  char *p;
  ATTR *a;
  if (nargs == 0) {
    safe_str(list_all_flags("FLAG", NULL, executor, 0x1), buff, bp);
    return;
  }
  if ((p = strchr(args[0], '/')))
    *p++ = '\0';
  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  if (p) {
    /* Attribute flags, you must be able to read the attribute */
    a = atr_get_noparent(thing, upcasestr(p));
    if (!a || !Can_Read_Attr(executor, thing, a)) {
      safe_str("#-1", buff, bp);
      return;
    }
    safe_str(privs_to_letters(attr_privs_view, AL_FLAGS(a)), buff, bp);
    if (atr_sub_branch(a))
      safe_chr('`', buff, bp);
  } else {
    /* Object flags, visible to all */
    safe_str(unparse_flags(thing, executor), buff, bp);
  }
}

/* ARGSUSED */
FUNCTION(fun_lflags)
{
  dbref thing;
  char *p;
  ATTR *a;
  if (nargs == 0) {
    safe_str(list_all_flags("FLAG", NULL, executor, 0x2), buff, bp);
    return;
  }
  if ((p = strchr(args[0], '/')))
    *p++ = '\0';
  thing = match_thing(executor, args[0]);
  if (!GoodObject(thing)) {
    safe_str(T(e_notvis), buff, bp);
    return;
  }
  if (p) {<