root/1.8.3/trunk/src/access.c

/**
 * \file
 *
 * \brief Access control lists for PennMUSH.
 * \verbatim
 *
 * The file access.cnf in the game directory will control all 
 * access-related directives, replacing lockout.cnf and sites.cnf
 *
 * The format of entries in the file will be:
 *
 * wild-host-name    [!]option [!]option [!]option ... # comment
 *
 * A wild-host-name is a wildcard pattern to match hostnames with. 
 * The wildcard "*" will work like UNIX filename globbing, so
 * *.edu will match all sites with names ending in .edu, and
 * *.*.*.*.* will match all sites with 4 periods in their name.
 * 128.32.*.* will match all sites starting with 128.32 (UC Berkeley).
 * You can also use user@host to match specific users if you know that
 * the host is running ident and you trust its responses (nontrivial).
 *
 * The options that can be specified are:
 * *CONNECT              Allow connections to non-guest players
 * *GUEST                Allow connection to guests
 * *CREATE               Allow player creation at login screen
 * DEFAULT               All of the above
 * NONE                 None of the above
 * SUSPECT              Set all players connecting from the site suspect
 * REGISTER             Allow players to use the "register" connect command
 * DENY_SILENT          Don't log when someone's denied access from here
 * REGEXP               Treat the hostname pattern as a regular expression
 * *GOD                  God can connect from this pattern.
 * *WIZARD               Wizards can connect from this pattern.
 * *ADMIN                Admins can connect from this pattern.
 *
 * Options that are *'d can be prefaced by a !, meaning "Don't allow".
 *
 * The file is parsed line-by-line in order. This makes it possible
 * to explicitly allow only certain sites to connect and deny all others,
 * or vice versa. Sites can only do the options that are specified
 * in the first line they match.
 *
 * If a site is listed in the file with no options at all, it is
 * disallowed from any access (treated as !CONNECT, basically)
 *
 * If a site doesn't match any line in the file, it is allowed any
 * toggleable access (treated as DEFAULT) but isn't SUSPECT or REGISTER.
 *
 * "make access" produces access.cnf from lockout.cnf/sites.cnf
 *
 * @sitelock'd sites appear after the line "@sitelock" in the file
 * Using @sitelock writes out the file.
 * 
 * \endverbatim
 */

#include "config.h"
#include "copyrite.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifdef I_SYS_TYPES
#include <sys/types.h>
#endif
#include <fcntl.h>
#ifdef I_SYS_TIME
#include <sys/time.h>
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#endif
#else
#include <time.h>
#endif
#ifdef I_UNISTD
#include <unistd.h>
#endif
#include "conf.h"
#include "externs.h"
#include "mypcre.h"
#include "access.h"
#include "mymalloc.h"
#include "match.h"
#include "parse.h"
#include "log.h"
#include "mushdb.h"
#include "dbdefs.h"
#include "flags.h"
#include "confmagic.h"

/** An access flag. */
typedef struct a_acsflag acsflag;
/** An access flag.
 * This structure is used to build a table of access control flags.
 */
struct a_acsflag {
  const char *name;             /**< Name of the access flag */
  bool toggle;                   /**< Is this a negatable flag? */
  uint32_t flag;                     /**< Bitmask of the flag */
};
static acsflag acslist[] = {
  {"connect", 1, ACS_CONNECT},
  {"create", 1, ACS_CREATE},
  {"guest", 1, ACS_GUEST},
  {"default", 0, ACS_DEFAULT},
  {"register", 0, ACS_REGISTER},
  {"suspect", 0, ACS_SUSPECT},
  {"deny_silent", 0, ACS_DENY_SILENT},
  {"regexp", 0, ACS_REGEXP},
  {"god", 1, ACS_GOD},
  {"wizard", 1, ACS_WIZARD},
  {"admin", 1, ACS_ADMIN},
  {NULL, 0, 0}
};

static struct access *access_top;
static void free_access_list(void);

extern const unsigned char *tables;

static struct access *
sitelock_alloc(const char *host, dbref who,
               uint32_t can, uint32_t cant,
               const char *comment, const char **errptr)
  __attribute_malloc__;

    static struct access *sitelock_alloc(const char *host, dbref who,
                                         uint32_t can, uint32_t cant,
                                         const char *comment,
                                         const char **errptr)
{
  struct access *tmp;
  tmp = mush_malloc(sizeof(struct access), "sitelock.rule");
  if (!tmp) {
    static const char *memerr = "unable to allocate memory";
    if (errptr)
      *errptr = memerr;
    return NULL;
  }
  tmp->who = who;
  tmp->can = can;
  tmp->cant = cant;
  mush_strncpy(tmp->host, host, BUFFER_LEN);
  if (comment)
    mush_strncpy(tmp->comment, comment, BUFFER_LEN);
  else
    tmp->comment[0] = '\0';
  tmp->next = NULL;

  if (can & ACS_REGEXP) {
    int erroffset = 0;
    tmp->re = pcre_compile(host, 0, errptr, &erroffset, tables);
    if (!tmp->re) {
      mush_free(tmp, "sitelock.rule");
      return NULL;
    }
  } else
    tmp->re = NULL;

  return tmp;
}

static bool
add_access_node(const char *host, dbref who, uint32_t can,
                uint32_t cant, const char *comment, const char **errptr)
{
  struct access *end, *tmp;

  tmp = sitelock_alloc(host, who, can, cant, comment, errptr);
  if (!tmp)
    return false;

  if (!access_top) {
    /* Add to the beginning */
    access_top = tmp;
  } else {
    end = access_top;
    while (end->next)
      end = end->next;
    end->next = tmp;
  }
  return true;
}


/** Read the access.cnf file.
 * Initialize the access rules linked list and read in the access.cnf file.
 * \return true if successful, false if not
 */
bool
read_access_file(void)
{
  FILE *fp;
  char buf[BUFFER_LEN];
  char *p;
  uint32_t can, cant;
  int retval;
  dbref who;
  char *comment;
  const char *errptr = NULL;

  if (access_top) {
    /* We're reloading the file, so we've got to delete any current 
     * entries
     */
    free_access_list();
  }
  access_top = NULL;
  /* Be sure we have a file descriptor */
  release_fd();
  fp = fopen(ACCESS_FILE, FOPEN_READ);
  if (!fp) {
    do_rawlog(LT_ERR, T("Access file %s not found."), ACCESS_FILE);
    retval = 0;
  } else {
    do_rawlog(LT_ERR, "Reading %s", ACCESS_FILE);
    while (fgets(buf, BUFFER_LEN, fp)) {
      /* Strip end of line if it's \r\n or \n */
      if ((p = strchr(buf, '\r')))
        *p = '\0';
      else if ((p = strchr(buf, '\n')))
        *p = '\0';
      /* Find beginning of line; ignore blank lines */
      p = buf;
      if (*p && isspace((unsigned char) *p))
        p++;
      if (*p && *p != '#') {
        can = cant = 0;
        comment = NULL;
        /* Is this the @sitelock entry? */
        if (!strncasecmp(p, "@sitelock", 9)) {
          if (!add_access_node("@sitelock", AMBIGUOUS, ACS_SITELOCK, 0, "",
                               &errptr))
            do_log(LT_ERR, GOD, GOD, T("Failed to add sitelock node: %s"),
                   errptr);
        } else {
          if ((comment = strchr(p, '#'))) {
            *comment++ = '\0';
            while (*comment && isspace((unsigned char) *comment))
              comment++;
          }
          /* Move past the host name */
          while (*p && !isspace((unsigned char) *p))
            p++;
          if (*p)
            *p++ = '\0';
          if (!parse_access_options(p, &who, &can, &cant, NOTHING))
            /* Nothing listed, so assume we can't do anything! */
            cant = ACS_DEFAULT;
          if (!add_access_node(buf, who, can, cant, comment, &errptr))
            do_log(LT_ERR, GOD, GOD, T("Failed to add access node: %s"),
                   errptr);
        }
      }
    }
    retval = 1;
    fclose(fp);
  }
  reserve_fd();
  return retval;
}

/** Write the access.cnf file.
 * Writes out the access.cnf file from the linked list
 */
void
write_access_file(void)
{
  FILE *fp;
  char tmpf[BUFFER_LEN];
  struct access *ap;
  acsflag *c;

  snprintf(tmpf, BUFFER_LEN, "%s.tmp", ACCESS_FILE);
  /* Be sure we have a file descriptor */
  release_fd();
  fp = fopen(tmpf, FOPEN_WRITE);
  if (!fp) {
    do_log(LT_ERR, GOD, GOD, T("Unable to open %s."), tmpf);
  } else {
    for (ap = access_top; ap; ap = ap->next) {
      if (strcmp(ap->host, "@sitelock") == 0) {
        fprintf(fp, "@sitelock\n");
        continue;
      }
      fprintf(fp, "%s %d ", ap->host, ap->who);
      switch (ap->can) {
      case ACS_SITELOCK:
        break;
      case ACS_DEFAULT:
        fprintf(fp, "DEFAULT ");
        break;
      default:
        for (c = acslist; c->name; c++)
          if (ap->can & c->flag)
            fprintf(fp, "%s ", c->name);
        break;
      }
      switch (ap->cant) {
      case ACS_DEFAULT:
        fprintf(fp, "NONE ");
        break;
      default:
        for (c = acslist; c->name; c++)
          if (c->toggle && (ap->cant & c->flag))
            fprintf(fp, "!%s ", c->name);
        break;
      }
      if (ap->comment && *ap->comment)
        fprintf(fp, "# %s\n", ap->comment);
      else
        fprintf(fp, "\n");
    }
    fclose(fp);
    rename_file(tmpf, ACCESS_FILE);
  }
  reserve_fd();
  return;
}

#ifdef FORCE_IPV4
static char *
ip4_to_ip6(const char *addr)
{
  static char tbuf1[BUFFER_LEN];
  char *bp;
  bp = tbuf1;
  safe_format(tbuf1, &bp, "::ffff:%s", addr);
  *bp = '\0';
  return tbuf1;
}
#endif


/** Decide if a host can access someway.
 * \param hname a host or user+host pattern.
 * \param flag the access type we're testing.
 * \param who the player attempting access.
 * \retval 1 access permitted.
 * \retval 0 access denied.
 * \verbatim
 * Given a hostname and a flag decide if the host can do it.
 * Here's how it works:
 * We run the linked list and take the first match.
 *  (If the hostname is user@host, we try to match both user@host
 *   and just host to each line in the file.)
 * If we make a match, and the line tells us whether the site can/can't
 *   do the action, we're done.
 * Otherwise, we assume that the host can do any toggleable option
 *   (can create, connect, guest), and don't have any special
 *   flags (can't register, isn't suspect)
 * \endverbatim
 */
bool
site_can_access(const char *hname, uint32_t flag, dbref who)
{
  struct access *ap;
  acsflag *c;
  const char *p;

  if (!hname || !*hname)
    return 0;

  if ((p = strchr(hname, '@')))
    p++;

  for (ap = access_top; ap; ap = ap->next) {
    if (!(ap->can & ACS_SITELOCK)
        && ((ap->can & ACS_REGEXP)
            ? (qcomp_regexp_match(ap->re, hname)
               || (p && qcomp_regexp_match(ap->re, p))
#ifdef FORCE_IPV4
               || qcomp_regexp_match(ip4_to_ip6(ap->re), hname)
               || (p && qcomp_regexp_match(ip4_to_ip6(ap->re), p))
#endif
            )
            : (quick_wild(ap->host, hname)
               || (p && quick_wild(ap->host, p))
#ifdef FORCE_IPV4
               || quick_wild(ip4_to_ip6(ap->host), hname)
               || (p && quick_wild(ip4_to_ip6(ap->host), p))
#endif
            ))
        && (ap->who == AMBIGUOUS || ap->who == who)) {
      /* Got one */
      if (flag & ACS_CONNECT) {
        if ((ap->cant & ACS_GOD) && God(who))   /* God can't connect from here */
          return 0;
        else if ((ap->cant & ACS_WIZARD) && Wizard(who))
          /* Wiz can't connect from here */
          return 0;
        else if ((ap->cant & ACS_ADMIN) && Hasprivs(who))
          /* Wiz and roy can't connect from here */
          return 0;
      }
      if (ap->cant && ((ap->cant & flag) == flag))
        return 0;
      if (ap->can && (ap->can & flag))
        return 1;

      /* Hmm. We don't know if we can or not, so continue */
      break;
    }
  }

  /* Flag was neither set nor unset. If the flag was a toggle,
   * then the host can do it. If not, the host can't */
  for (c = acslist; c->name; c++) {
    if (flag & c->flag)
      return c->toggle ? 1 : 0;
  }
  /* Should never reach here, but just in case */
  return 1;
}


/** Return the first access rule that matches a host.
 * \param hname a host or user+host pattern.
 * \param who the player attempting access.
 * \param rulenum pointer to rule position.
 * \return pointer to first matching access rule or NULL.
 */
struct access *
site_check_access(const char *hname, dbref who, int *rulenum)
{
  struct access *ap;
  const char *p;

  *rulenum = 0;
  if (!hname || !*hname)
    return 0;

  if ((p = strchr(hname, '@')))
    p++;

  for (ap = access_top; ap; ap = ap->next) {
    (*rulenum)++;
    if (!(ap->can & ACS_SITELOCK)
        && ((ap->can & ACS_REGEXP)
            ? (qcomp_regexp_match(ap->re, hname)
               || (p && qcomp_regexp_match(ap->re, p))
#ifdef FORCE_IPV4
               || qcomp_regexp_match(ip4_to_ip6(ap->host), hname)
               || (p && qcomp_regexp_match(ip4_to_ip6(ap->host), p))
#endif
            )
            : (quick_wild(ap->host, hname)
               || (p && quick_wild(ap->host, p))
#ifdef FORCE_IPV4
               || quick_wild(ip4_to_ip6(ap->host), hname)
               || (p && quick_wild(ip4_to_ip6(ap->host), p))
#endif
            ))
        && (ap->who == AMBIGUOUS || ap->who == who)) {
      /* Got one */
      return ap;
    }
  }
  return NULL;
}

/** Display an access rule.
 * \param ap pointer to access rule.
 * \param rulenum access rule's number in the list.
 * \param who unused.
 * \param buff buffer to store output.
 * \param bp pointer into buff.
 * This function provides an appealing display of an access rule
 * in the list.
 */
void
format_access(struct access *ap, int rulenum,
              dbref who __attribute__ ((__unused__)), char *buff, char **bp)
{
  if (ap) {
    safe_format(buff, bp, T("Matched line %d: %s %s"), rulenum, ap->host,
                (ap->can & ACS_REGEXP) ? "(regexp)" : "");
    safe_chr('\n', buff, bp);
    safe_format(buff, bp, T("Comment: %s"), ap->comment);
    safe_chr('\n', buff, bp);
    safe_str(T("Connections allowed by: "), buff, bp);
    if (ap->cant & ACS_CONNECT)
      safe_str(T("No one"), buff, bp);
    else if (ap->cant & ACS_ADMIN)
      safe_str(T("All but admin"), buff, bp);
    else if (ap->cant & ACS_WIZARD)
      safe_str(T("All but wizards"), buff, bp);
    else if (ap->cant & ACS_GOD)
      safe_str(T("All but God"), buff, bp);
    else
      safe_str(T("All"), buff, bp);
    safe_chr('\n', buff, bp);
    if (ap->cant & ACS_GUEST)
      safe_str(T("Guest connections are NOT allowed"), buff, bp);
    else
      safe_str(T("Guest connections are allowed"), buff, bp);
    safe_chr('\n', buff, bp);
    if (ap->cant & ACS_CREATE)
      safe_str(T("Creation is NOT allowed"), buff, bp);
    else
      safe_str(T("Creation is allowed"), buff, bp);
    safe_chr('\n', buff, bp);
    if (ap->can & ACS_REGISTER)
      safe_str(T("Email registration is allowed"), buff, bp);
    if (ap->can & ACS_SUSPECT)
      safe_str(T("Players connecting are set SUSPECT"), buff, bp);
    if (ap->can & ACS_DENY_SILENT)
      safe_str(T("Denied connections are not logged"), buff, bp);
  } else {
    safe_str(T("No matching access rule"), buff, bp);
  }
}


/** Add an access rule to the linked list.
 * \param player enactor.
 * \param host host pattern to add.
 * \param who player to which rule applies, or AMBIGUOUS.
 * \param can flags of allowed actions.
 * \param cant flags of disallowed actions.
 * \retval 1 success.
 * \retval 0 failure.
 * \verbatim
 * This function adds an access rule after the @sitelock entry.
 * If there is no @sitelock entry, a