mux/src/conf.cpp File Reference

#include "copyright.h"
#include "autoconf.h"
#include "config.h"
#include "externs.h"
#include "attrs.h"
#include "command.h"
#include "interface.h"

Include dependency graph for conf.cpp:

Go to the source code of this file.

Data Structures
struct	confparm
struct	DECODEIPV4
Typedefs
typedef confparm	CONF
Functions
void	cf_init (void)
void	cf_log_notfound (dbref player, char *cmd, const char *thingname, char *thing)
void DCL_CDECL	cf_log_syntax (dbref player, char *cmd, const char *fmt,...)
static int	cf_status_from_succfail (dbref player, char *cmd, int success, int failure)
static	CF_HAND (cf_int_array)
static	CF_HAND (cf_int)
static	CF_HAND (cf_dbref)
static	CF_HAND (cf_seconds)
static	CF_HAND (cf_bool)
static	CF_HAND (cf_option)
static	CF_HAND (cf_string)
static	CF_HAND (cf_string_dyn)
static	CF_HAND (cf_alias)
static	CF_HAND (cf_flagalias)
static	CF_HAND (cf_poweralias)
	CF_HAND (cf_modify_bits)
static	CF_HAND (cf_set_flags)
static	CF_HAND (cf_badname)
static bool	DecodeN (int nType, size_t len, const char *p, in_addr_t *pu32)
static bool	MakeCanonicalIPv4 (const char *str, in_addr_t *pnIP)
static bool	isValidSubnetMask (in_addr_t ulMask)
static	CF_HAND (cf_site)
static int	add_helpfile (dbref player, char *cmd, char *str, bool bRaw)
static	CF_HAND (cf_helpfile)
static	CF_HAND (cf_raw_helpfile)
static	CF_HAND (cf_hook)
static	CF_HAND (cf_include)
	CF_HAND (cf_cf_access)
int	cf_set (char *cp, char *ap, dbref player)
void	ValidateConfigurationDbrefs (void)
void	do_admin (dbref executor, dbref caller, dbref enactor, int extra, int nargs, char *kw, char *value)
int	cf_read (void)
void	list_cf_access (dbref player)
void	cf_display (dbref player, char *param_name, char *buff, char **bufc)
void	cf_list (dbref player, char *buff, char **bufc)
Variables
CONFDATA	mudconf
STATEDATA	mudstate
static NAMETAB	bool_names []
static NAMETAB	hook_names []
static CONF	conftable []
struct {
char **   pFilename
char *   pSuffix
}	DefaultSuffixes []

---

Typedef Documentation

typedef struct confparm CONF

---

Function Documentation

static int add_helpfile	(	dbref	player,
		char *	cmd,
		char *	str,
		bool	bRaw
	)			[static]

Definition at line 1435 of file conf.cpp.

References statedata::aHelpDesc, HELP_DESC::bEval, CA_PUBLIC, CMDENT_ONE_ARG::callseq, cf_log_syntax(), CMDENT_ONE_ARG::cmdname, statedata::command_htab, HELP_DESC::CommandName, CS_ONE_ARG, do_help(), CMDENT_ONE_ARG::extra, CMDENT_ONE_ARG::handler, hashaddLEN(), hashdeleteLEN(), CMDENT_ONE_ARG::hookmask, HELP_DESC::ht, ISOUTOFMEMORY, MEMALLOC, MEMFREE, statedata::mHelpDesc, mudstate, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), statedata::nHelpDesc, HELP_DESC::pBaseFilename, CMDENT_ONE_ARG::perms, SBUF_SIZE, StringClone(), CMDENT_ONE_ARG::switches, and tprintf().

Referenced by CF_HAND().

{
    // Parse the two arguments.
    //
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t\n\r");

    char *pCmdName = mux_strtok_parse(&tts);
    char *pBase = mux_strtok_parse(&tts);
    if (pBase == NULL)
    {
        cf_log_syntax(player, cmd, "Missing path for helpfile %s", pCmdName);
        return -1;
    }
    if (  pCmdName[0] == '_'
       && pCmdName[1] == '_')
    {
        cf_log_syntax(player, cmd,
            "Helpfile %s would conflict with the use of @addcommand.",
            pCmdName);
        return -1;
    }
    if (SBUF_SIZE <= strlen(pBase))
    {
        cf_log_syntax(player, cmd, "Helpfile '%s' filename too long", pBase);
        return -1;
    }

    // Allocate an empty place in the table of help file hashes.
    //
    if (mudstate.aHelpDesc == NULL)
    {
        mudstate.mHelpDesc = 4;
        mudstate.nHelpDesc = 0;
        mudstate.aHelpDesc = (HELP_DESC *)MEMALLOC(sizeof(HELP_DESC)
            *mudstate.mHelpDesc);
        ISOUTOFMEMORY(mudstate.aHelpDesc);
    }
    else if (mudstate.mHelpDesc <= mudstate.nHelpDesc)
    {
        int newsize = mudstate.mHelpDesc + 4;
        HELP_DESC *q = (HELP_DESC *)MEMALLOC(sizeof(HELP_DESC)*newsize);
        ISOUTOFMEMORY(q);
        memset(q, 0, sizeof(HELP_DESC)*newsize);
        memcpy(q, mudstate.aHelpDesc, sizeof(HELP_DESC)*mudstate.mHelpDesc);
        MEMFREE(mudstate.aHelpDesc);
        mudstate.aHelpDesc = q;
        mudstate.mHelpDesc = newsize;
    }

    // Build HELP_DESC
    //
    HELP_DESC *pDesc = mudstate.aHelpDesc + mudstate.nHelpDesc;
    pDesc->CommandName = StringClone(pCmdName);
    pDesc->ht = NULL;
    pDesc->pBaseFilename = StringClone(pBase);
    pDesc->bEval = !bRaw;

    // Build up Command Entry.
    //
    CMDENT_ONE_ARG *cmdp = (CMDENT_ONE_ARG *)MEMALLOC(sizeof(CMDENT_ONE_ARG));
    ISOUTOFMEMORY(cmdp);

    cmdp->callseq = CS_ONE_ARG;
    cmdp->cmdname = StringClone(pCmdName);
    cmdp->extra = mudstate.nHelpDesc;
    cmdp->handler = do_help;
    cmdp->hookmask = 0;
    cmdp->perms = CA_PUBLIC;
    cmdp->switches = NULL;

    // TODO: If a command is deleted with one or both of the two
    // hashdeleteLEN() calls below, what guarantee do we have that parts of
    // the command weren't dynamically allocated.  This might leak memory.
    //
    char *p = cmdp->cmdname;
    hashdeleteLEN(p, strlen(p), &mudstate.command_htab);
    hashaddLEN(p, strlen(p), cmdp, &mudstate.command_htab);

    p = tprintf("__%s", cmdp->cmdname);
    hashdeleteLEN(p, strlen(p), &mudstate.command_htab);
    hashaddLEN(p, strlen(p), cmdp, &mudstate.command_htab);

    mudstate.nHelpDesc++;

    return 0;
}

void cf_display	(	dbref	player,
		char *	param_name,
		char *	buff,
		char **	bufc
	)

Definition at line 2174 of file conf.cpp.

References check_access(), conftable, confparm::interpreter, confparm::loc, mux_stricmp(), confparm::pname, confparm::rperms, safe_chr, and safe_ltoa().

Referenced by FUNCTION().

{
    CONF *tp;

    for (tp = conftable; tp->pname; tp++)
    {
        if (!mux_stricmp(tp->pname, param_name))
        {
            if (check_access(player, tp->rperms))
            {
                if (tp->interpreter == cf_int)
                {
                    safe_ltoa(*(tp->loc), buff, bufc);
                    return;
                }
                else if (tp->interpreter == cf_dbref)
                {
                    safe_chr('#', buff, bufc);
                    safe_ltoa(*(tp->loc), buff, bufc);
                    return;
                }
                else if (tp->interpreter == cf_bool)
                {
                    bool *pb = (bool *)tp->loc;
                    safe_bool(*pb, buff, bufc);
                    return;
                }
                else if (tp->interpreter == cf_string)
                {
                    safe_str((char *)tp->loc, buff, bufc);
                    return;
                }
                else if (tp->interpreter == cf_string_dyn)
                {
                    safe_str(*(char **)tp->loc, buff, bufc);
                    return;
                }
                else if (tp->interpreter == cf_int_array)
                {
                    IntArray *pia = (IntArray *)(tp->loc);
                    ITL itl;
                    ItemToList_Init(&itl, buff, bufc);
                    for (int i = 0; i < pia->n; i++)
                    {
                        if (!ItemToList_AddInteger(&itl, pia->pi[i]))
                        {
                            break;
                        }
                    }
                    ItemToList_Final(&itl);
                    return;
                }
                else if (tp->interpreter == cf_seconds)
                {
                    CLinearTimeDelta *pltd = (CLinearTimeDelta *)(tp->loc);
                    safe_str(pltd->ReturnSecondsString(7), buff, bufc);
                    return;
                }
            }
            safe_noperm(buff, bufc);
            return;
        }
    }
    safe_nomatch(buff, bufc);
}

CF_HAND

(

cf_cf_access

)

Definition at line 1940 of file conf.cpp.

{
    UNUSED_PARAMETER(vp);

    CONF *tp;
    char *ap;

    for (ap = str; *ap && !mux_isspace(*ap); ap++)
    {
        ; // Nothing
    }
    if (*ap)
    {
        *ap++ = '\0';
    }

    for (tp = conftable; tp->pname; tp++)
    {
        if (!strcmp(tp->pname, str))
        {
            // Cannot modify parameters set CA_STATIC.
            //
            if (  tp->flags & CA_STATIC
               && !mudstate.bReadingConfiguration)
            {
                notify(player, NOPERM_MESSAGE);
                STARTLOG(LOG_CONFIGMODS, "CFG", "PERM");
                log_name(player);
                log_text(" tried to change access to static param: ");
                log_text(tp->pname);
                ENDLOG;
                return -1;
            }
            return cf_modify_bits(&tp->flags, ap, pExtra, nExtra, player, cmd);
        }
    }
    cf_log_notfound(player, cmd, "Config directive", str);
    return -1;
}

static CF_HAND

(

cf_include

)

[static]

Definition at line 1620 of file conf.cpp.

References alloc_lbuf, statedata::bReadingConfiguration, cf_log_notfound(), cf_set(), DebugTotalFiles, free_lbuf, LBUF_SIZE, mudstate, mux_isdigit, mux_isspace, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    if (!mudstate.bReadingConfiguration)
    {
        return -1;
    }

    FILE *fp = fopen(str, "rb");
    if (fp == NULL)
    {
        cf_log_notfound(player, cmd, "Config file", str);
        return -1;
    }
    DebugTotalFiles++;

    char *buf = alloc_lbuf("cf_include");
    fgets(buf, LBUF_SIZE, fp);
    while (!feof(fp))
    {
        char *zp = buf;

        // Remove comments.  Anything after the '#' is a comment except if it
        // matches:  whitespace + '#' + digit.
        //
        while (*zp != '\0')
        {
            if (  *zp == '#'
               && (  zp <= buf
                  || !mux_isspace(zp[-1])
                  || !mux_isdigit(zp[1])))
            {
                // Found a comment.
                //
                *zp = '\0';
            }
            else
            {
                zp++;
            }
        }

        // Trim trailing spaces.
        //
        while (  buf < zp
              && mux_isspace(zp[-1]))
        {
            *(--zp) = '\0';
        }

        // Process line.
        //
        char *cp = buf;

        // Trim leading spaces.
        //
        while (mux_isspace(*cp))
        {
            cp++;
        }

        // Skip over command.
        //
        char *ap;
        for (ap = cp; *ap && !mux_isspace(*ap); ap++)
        {
            ; // Nothing.
        }

        // Terminate command.
        //
        if (*ap)
        {
            *ap++ = '\0';
        }

        // Skip spaces between command and argument.
        //
        while (mux_isspace(*ap))
        {
            ap++;
        }

        if (*cp)
        {
            cf_set(cp, ap, player);
        }
        fgets(buf, LBUF_SIZE, fp);
    }
    free_lbuf(buf);
    if (fclose(fp) == 0)
    {
        DebugTotalFiles--;
    }
    return 0;
}

static CF_HAND

(

cf_hook

)

[static]

Definition at line 1558 of file conf.cpp.

References statedata::command_htab, GOD, hashfindLEN(), hook_names, CMDENT::hookmask, mudstate, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), search_nametab(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    char *hookcmd, *hookptr, playbuff[201];
    int hookflg;
    CMDENT *cmdp;

    int retval = -1;
    memset(playbuff, '\0', sizeof(playbuff));
    strncpy(playbuff, str, 200);
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, playbuff);
    mux_strtok_ctl(&tts, " \t");
    hookcmd = mux_strtok_parse(&tts);
    if (hookcmd != NULL)
    {
       cmdp = (CMDENT *)hashfindLEN(hookcmd, strlen(hookcmd), &mudstate.command_htab);
    }
    else
    {
       return retval;
    }
    if (!cmdp)
    {
       return retval;
    }

    *vp = cmdp->hookmask;
    strncpy(playbuff, str, 200);
    hookptr = mux_strtok_parse(&tts);
    while (hookptr != NULL)
    {
       if (  hookptr[0] == '!'
          && hookptr[1] != '\0')
       {
          if (search_nametab(GOD, hook_names, hookptr+1, &hookflg))
          {
             retval = 0;
             *vp = *vp & ~hookflg;
          }
       }
       else
       {
          if (search_nametab(GOD, hook_names, hookptr, &hookflg))
          {
             retval = 0;
             *vp = *vp | hookflg;
          }
       }
       hookptr = mux_strtok_parse(&tts);
    }
    cmdp->hookmask = *vp;
    return retval;
}

static CF_HAND

(

cf_raw_helpfile

)

[static]

Definition at line 1533 of file conf.cpp.

References add_helpfile(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    return add_helpfile(player, cmd, str, true);
}

static CF_HAND

(

cf_helpfile

)

[static]

Definition at line 1524 of file conf.cpp.

References add_helpfile(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    return add_helpfile(player, cmd, str, false);
}

static CF_HAND

(

cf_site

)

[static]

Definition at line 1302 of file conf.cpp.

References site_data::address, statedata::bReadingConfiguration, cf_log_syntax(), site_data::flag, is_integer(), ISOUTOFMEMORY, isValidSubnetMask(), MakeCanonicalIPv4(), site_data::mask, MEMALLOC, mudstate, mux_atol(), mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), site_data::next, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);

    SITE **ppv = (SITE **)vp;
    struct in_addr addr_num, mask_num;
    in_addr_t ulMask, ulNetBits;

    char *addr_txt;
    char *mask_txt = strchr(str, '/');
    if (!mask_txt)
    {
        // Standard IP range and netmask notation.
        //
        MUX_STRTOK_STATE tts;
        mux_strtok_src(&tts, str);
        mux_strtok_ctl(&tts, " \t=,");
        addr_txt = mux_strtok_parse(&tts);
        mask_txt = NULL;
        if (addr_txt)
        {
            mask_txt = mux_strtok_parse(&tts);
        }
        if (!addr_txt || !*addr_txt || !mask_txt || !*mask_txt)
        {
            cf_log_syntax(player, cmd, "Missing host address or mask.", "");
            return -1;
        }
        if (  !MakeCanonicalIPv4(mask_txt, &ulNetBits)
           || !isValidSubnetMask(ulMask = ntohl(ulNetBits)))
        {
            cf_log_syntax(player, cmd, "Malformed mask address: %s", mask_txt);
            return -1;
        }
        mask_num.s_addr = ulNetBits;
    }
    else
    {
        // RFC 1517, 1518, 1519, 1520: CIDR IP prefix notation
        //
        addr_txt = str;
        *mask_txt++ = '\0';
        if (!is_integer(mask_txt, NULL))
        {
            cf_log_syntax(player, cmd, "Mask field (%s) in CIDR IP prefix is not numeric.", mask_txt);
            return -1;
        }
        int mask_bits = mux_atol(mask_txt);
        if (  mask_bits < 0
           || 32 < mask_bits)
        {
            cf_log_syntax(player, cmd, "Mask bits (%d) in CIDR IP prefix out of range.", mask_bits);
            return -1;
        }
        else
        {
            // << [0,31] works. << 32 is problematic on some systems.
            //
            ulMask = 0;
            if (mask_bits > 0)
            {
                ulMask = (0xFFFFFFFFUL << (32 - mask_bits)) & 0xFFFFFFFFUL;
            }
            mask_num.s_addr = htonl(ulMask);
        }
    }
    if (!MakeCanonicalIPv4(addr_txt, &ulNetBits))
    {
        cf_log_syntax(player, cmd, "Malformed host address: %s", addr_txt);
        return -1;
    }
    addr_num.s_addr = ulNetBits;
    in_addr_t ulAddr = ntohl(addr_num.s_addr);

    if (ulAddr & ~ulMask)
    {
        // The given subnet address contains 'one' bits which are outside
        // the given subnet mask. If we don't clear these bits, they will
        // interfere with the subnet tests in site_check. The subnet spec
        // would be defunct and useless.
        //
        cf_log_syntax(player, cmd, "Non-zero host address bits outside the subnet mask (fixed): %s %s", addr_txt, mask_txt);
        ulAddr &= ulMask;
        addr_num.s_addr = htonl(ulAddr);
    }

    SITE *head = *ppv;

    // Parse the access entry and allocate space for it.
    //
    SITE *site = (SITE *)MEMALLOC(sizeof(SITE));
    ISOUTOFMEMORY(site);

    // Initialize the site entry.
    //
    site->address.s_addr = addr_num.s_addr;
    site->mask.s_addr = mask_num.s_addr;
    site->flag = nExtra;
    site->next = NULL;

    // Link in the entry. Link it at the start if not initializing, at the
    // end if initializing. This is so that entries in the config file are
    // processed as you would think they would be, while entries made while
    // running are processed first.
    //
    if (mudstate.bReadingConfiguration)
    {
        if (head == NULL)
        {
            *ppv = site;
        }
        else
        {
            SITE *last;
            for (last = head; last->next; last = last->next)
            {
                // Nothing
            }
            last->next = site;
        }
    }
    else
    {
        site->next = head;
        *ppv = site;
    }
    return 0;
}

static CF_HAND

(

cf_badname

)

[static]

Definition at line 1033 of file conf.cpp.

References badname_add(), badname_remove(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    if (nExtra)
    {
        badname_remove(str);
    }
    else
    {
        badname_add(str);
    }
    return 0;
}

static CF_HAND

(

cf_set_flags

)

[static]

Definition at line 955 of file conf.cpp.

References flag_name_entry::bPositive, cf_log_notfound(), flag_name_entry::fbe, FLAG_WORD1, FLAG_WORD3, flag_bit_entry::flagflag, statedata::flags_htab, flag_bit_entry::flagvalue, hashfindLEN(), MakeCanonicalFlagName(), mudstate, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    int success, failure;

    // Walk through the tokens.
    //
    success = failure = 0;
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t");
    char *sp = mux_strtok_parse(&tts);
    FLAGSET *fset = (FLAGSET *) vp;

    while (sp != NULL)
    {
        // Canonical Flag Name.
        //
        int  nName;
        bool bValid;
        char *pName = MakeCanonicalFlagName(sp, &nName, &bValid);
        FLAGNAMEENT *fp = NULL;
        if (bValid)
        {
            fp = (FLAGNAMEENT *)hashfindLEN(pName, nName, &mudstate.flags_htab);
        }
        if (fp != NULL)
        {
            // Set the appropriate bit.
            //
            if (success == 0)
            {
                for (int i = FLAG_WORD1; i <= FLAG_WORD3; i++)
                {
                    (*fset).word[i] = 0;
                }
            }
            FLAGBITENT *fbe = fp->fbe;
            if (fp->bPositive)
            {
                (*fset).word[fbe->flagflag] |= fbe->flagvalue;
            }
            else
            {
                (*fset).word[fbe->flagflag] &= ~(fbe->flagvalue);
            }
            success++;
        }
        else
        {
            cf_log_notfound(player, cmd, "Entry", sp);
            failure++;
        }

        // Get the next token
        //
        sp = mux_strtok_parse(&tts);
    }
    if ((success == 0) && (failure == 0))
    {
        for (int i = FLAG_WORD1; i <= FLAG_WORD3; i++)
        {
            (*fset).word[i] = 0;
        }
        return 0;
    }
    if (success > 0)
    {
        return ((failure == 0) ? 0 : 1);
    }
    return -1;
}

CF_HAND

(

cf_modify_bits

)

Definition at line 862 of file conf.cpp.

References cf_log_notfound(), cf_status_from_succfail(), GOD, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), search_nametab(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(nExtra);

    int f, success, failure;
    bool negate;

    // Walk through the tokens.
    //
    success = failure = 0;
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t");
    char *sp = mux_strtok_parse(&tts);
    while (sp != NULL)
    {
        // Check for negation.
        //
        negate = false;
        if (*sp == '!')
        {
            negate = true;
            sp++;
        }

        // Set or clear the appropriate bit.
        //
        if (search_nametab(GOD, (NAMETAB *)pExtra, sp, &f))
        {
            if (negate)
                *vp &= ~f;
            else
                *vp |= f;
            success++;
        }
        else
        {
            cf_log_notfound(player, cmd, "Entry", sp);
            failure++;
        }

        // Get the next token.
        //
        sp = mux_strtok_parse(&tts);
    }
    return cf_status_from_succfail(player, cmd, success, failure);
}

static CF_HAND

(

cf_poweralias

)

[static]

Definition at line 782 of file conf.cpp.

References cf_log_notfound(), hashaddLEN(), hashfindLEN(), MakeCanonicalFlagName(), mudstate, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), statedata::powers_htab, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t=,");
    char *alias = mux_strtok_parse(&tts);
    char *orig = mux_strtok_parse(&tts);

    bool success = false;
    int  nName;
    bool bValid;
    void *cp;
    char *pName = MakeCanonicalFlagName(orig, &nName, &bValid);
    if (bValid)
    {
        cp = hashfindLEN(pName, nName, &mudstate.powers_htab);
        if (cp)
        {
            pName = MakeCanonicalFlagName(alias, &nName, &bValid);
            if (bValid)
            {
                hashaddLEN(pName, nName, cp, &mudstate.powers_htab);
                success = true;
            }
        }
    }
    if (!success)
    {
        cf_log_notfound(player, cmd, "Power", orig);
    }
    return (success ? 0 : -1);
}

static CF_HAND

(

cf_flagalias

)

[static]

Definition at line 739 of file conf.cpp.

References cf_log_notfound(), statedata::flags_htab, hashaddLEN(), hashfindLEN(), MakeCanonicalFlagName(), mudstate, mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(vp);
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t=,");
    char *alias = mux_strtok_parse(&tts);
    char *orig = mux_strtok_parse(&tts);

    bool success = false;
    int  nName;
    bool bValid;
    void *cp;
    char *pName = MakeCanonicalFlagName(orig, &nName, &bValid);
    if (bValid)
    {
        cp = hashfindLEN(pName, nName, &mudstate.flags_htab);
        if (cp)
        {
            pName = MakeCanonicalFlagName(alias, &nName, &bValid);
            if (bValid)
            {
                if (!hashfindLEN(pName, nName, &mudstate.flags_htab))
                {
                    hashaddLEN(pName, nName, cp, &mudstate.flags_htab);
                    success = true;
               }
            }
        }
    }
    if (!success)
    {
        cf_log_notfound(player, cmd, "Flag", orig);
    }
    return (success ? 0 : -1);
}

static CF_HAND

(

cf_alias

)

[static]

Definition at line 702 of file conf.cpp.

References cf_log_notfound(), hashaddLEN(), hashfindLEN(), mux_strlwr(), mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), mux_strupr(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t=,");
    char *alias = mux_strtok_parse(&tts);
    char *orig = mux_strtok_parse(&tts);

    if (orig)
    {
        mux_strlwr(orig);
        void *cp = hashfindLEN(orig, strlen(orig), (CHashTable *) vp);
        if (cp == NULL)
        {
            mux_strupr(orig);
            cp = hashfindLEN(orig, strlen(orig), (CHashTable *) vp);
            if (cp == NULL)
            {
                cf_log_notfound(player, cmd, "Entry", orig);
                return -1;
            }
        }
        if (!hashfindLEN(alias, strlen(alias), (CHashTable *) vp))
        {
            hashaddLEN(alias, strlen(alias), cp, (CHashTable *) vp);
        }
        return 0;
    }
    return -1;
}

static CF_HAND

(

cf_string_dyn

)

[static]

Definition at line 660 of file conf.cpp.

References statedata::bReadingConfiguration, ENDLOG, Log, LOG_STARTUP, MEMFREE, mudstate, notify, STARTLOG, StringCloneLen(), CLogFile::tinyprintf(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);

    char **ppc = (char **)vp;

    // Allocate memory for buffer and copy string to it. If nExtra is non-zero,
    // then there is a size limitation as well.
    //
    int retval = 0;
    unsigned int nStr = strlen(str);
    if (nExtra && nStr >= nExtra)
    {
        nStr = nExtra - 1;
        if (mudstate.bReadingConfiguration)
        {
            STARTLOG(LOG_STARTUP, "CNF", "NFND");
            Log.tinyprintf("%s: String truncated", cmd);
            ENDLOG;
        }
        else
        {
            notify(player, "String truncated");
        }
        retval = 1;
    }
    char *confbuff = StringCloneLen(str, nStr);

    // Free previous memory for buffer.
    //
    if (*ppc != NULL)
    {
        MEMFREE(*ppc);
    }
    *ppc = confbuff;

    return retval;
}

static CF_HAND

(

cf_string

)

[static]

Definition at line 595 of file conf.cpp.

References alloc_sbuf, statedata::bReadingConfiguration, ENDLOG, free_sbuf, Log, LOG_STARTUP, confdata::mud_name, mudconf, mudstate, mux_isalnum, notify, SBUF_SIZE, CLogFile::SetPrefix(), STARTLOG, strip_ansi(), CLogFile::tinyprintf(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);

    char *pc = (char *)vp;

    // The following should never happen because extra is always a non-zero
    // constant in the config table.
    //
    if (nExtra <= 0)
    {
        return 1;
    }

    // Copy the string to the buffer if it is not too big.
    //
    int retval = 0;
    unsigned int nStr = strlen(str);
    if (nStr >= nExtra)
    {
        nStr = nExtra - 1;
        if (mudstate.bReadingConfiguration)
        {
            STARTLOG(LOG_STARTUP, "CNF", "NFND");
            Log.tinyprintf("%s: String truncated", cmd);
            ENDLOG;
        }
        else
        {
            notify(player, "String truncated");
        }
        retval = 1;
    }
    memcpy(pc, str, nStr+1);
    pc[nStr] = '\0';

    if (pc == mudconf.mud_name)
    {
        // We are changing the name of the MUD. Form a prefix from the
        // mudname and let the logger know.
        //
        char *buff = alloc_sbuf("cf_string.prefix");
        char *p = buff;
        char *q = strip_ansi(mudconf.mud_name);
        size_t nLen = 0;
        while (  *q
              && nLen < SBUF_SIZE)
        {
            if (mux_isalnum(*q))
            {
                *p++ = *q;
                nLen++;
            }
            q++;
        }
        *p = '\0';
        Log.SetPrefix(buff);
        free_sbuf(buff);
    }
    return retval;
}

static CF_HAND

(

cf_option

)

[static]

Definition at line 578 of file conf.cpp.

References cf_log_notfound(), GOD, search_nametab(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(nExtra);

    int i;
    if (!search_nametab(GOD, (NAMETAB *)pExtra, str, &i))
    {
        cf_log_notfound(player, cmd, "Value", str);
        return -1;
    }
    *vp = i;
    return 0;
}

static CF_HAND

(

cf_bool

)

[static]

Definition at line 559 of file conf.cpp.

References bool_names, cf_log_notfound(), GOD, isTRUE, search_nametab(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);

    int i;
    if (!search_nametab(GOD, bool_names, str, &i))
    {
        cf_log_notfound(player, cmd, "Value", str);
        return -1;
    }
    bool *pb = (bool *)vp;
    *pb = isTRUE(i);
    return 0;
}

static CF_HAND

(

cf_seconds

)

[static]

Definition at line 533 of file conf.cpp.

References CLinearTimeDelta::SetSecondsString(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    CLinearTimeDelta *pltd = (CLinearTimeDelta *)vp;
    pltd->SetSecondsString(str);
    return 0;
}

static CF_HAND

(

cf_dbref

)

[static]

Definition at line 507 of file conf.cpp.

References mux_atol(), mux_isspace, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    char *p = str;
    while (mux_isspace(*p))
    {
        p++;
    }
    if (*p == '#')
    {
        p++;
    }

    // Copy the numeric value to the parameter.
    //
    *vp = mux_atol(p);
    return 0;
}

static CF_HAND

(

cf_int

)

[static]

Definition at line 491 of file conf.cpp.

References mux_atol(), and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(nExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    // Copy the numeric value to the parameter.
    //
    *vp = mux_atol(str);
    return 0;
}

static CF_HAND

(

cf_int_array

)

[static]

Definition at line 441 of file conf.cpp.

References is_integer(), ISOUTOFMEMORY, MEMALLOC, MEMFREE, mux_atol(), mux_strtok_ctl(), mux_strtok_parse(), mux_strtok_src(), tag_int_array::n, tag_int_array::pi, and UNUSED_PARAMETER.

{
    UNUSED_PARAMETER(pExtra);
    UNUSED_PARAMETER(player);
    UNUSED_PARAMETER(cmd);

    int *aPorts = (int *)MEMALLOC(nExtra*sizeof(int));
    ISOUTOFMEMORY(aPorts);
    unsigned int nPorts = 0;

    char *p;
    MUX_STRTOK_STATE tts;
    mux_strtok_src(&tts, str);
    mux_strtok_ctl(&tts, " \t\n\r");
    while ((p = mux_strtok_parse(&tts)) != NULL)
    {
        int unused;
        if (is_integer(p, &unused))
        {
            aPorts[nPorts++] = mux_atol(p);
            if (nPorts >= nExtra)
            {
                break;
            }
        }
    }

    IntArray *pia = (IntArray *)vp;
    if (nPorts)
    {
        if (pia->pi)
        {
            MEMFREE(pia->pi);
            pia->pi = NULL;
        }
        pia->pi = (int *)MEMALLOC(nPorts * sizeof(int));
        ISOUTOFMEMORY(pia->pi);
        pia->n = nPorts;
        for (unsigned int i = 0; i < nPorts; i++)
        {
            pia->pi[i] = aPorts[i];
        }
    }
    MEMFREE(aPorts);
    return 0;
}

void cf_init

(

void

)

Definition at line 39 of file conf.cpp.

References A_USER_START, statedata::access_list, confdata::active_q_chunk, AF_ODARK, statedata::aHelpDesc, confdata::allow_guest_from_registered_site, confdata::art_rules, statedata::attr_next, confdata::autozone, statedata::badname_head, statedata::bCanRestart, statedata::bReadingConfiguration, statedata::bStackLimitReached, confdata::cache_names, confdata::cache_pages, confdata::cache_tick_period, confdata::check_interval, confdata::check_offset, confdata::clone_copy_cost, confdata::cmd_quota_incr, confdata::cmd_quota_max, confdata::compress, confdata::compress_db, confdata::comsys_db, confdata::conn_file, confdata::conn_timeout, confdata::control_flags, confdata::crashdb, confdata::crea_file, confdata::createmax, confdata::createmin, confdata::creg_file, statedata::curr_cmd, statedata::curr_enactor, statedata::curr_executor, confdata::dark_sleepers, alist::data, statedata::db_size, statedata::db_top, statedata::debug_cmd, confdata::default_home, confdata::destroy_going_now, confdata::digcost, statedata::doing_hdr, confdata::down_file, confdata::downmotd_msg, confdata::dump_interval, confdata::dump_msg, confdata::dump_offset, statedata::dumped, statedata::dumper, statedata::dumping, statedata::epoch, confdata::eval_comtitle, confdata::events_daily_hour, statedata::events_flag, confdata::ex_flags, confdata::exam_public, confdata::exit_flags, confdata::exit_quota, confdata::fascist_tport, confdata::fixed_home_msg, confdata::fixed_tel_msg, FLAG_WORD1, FLAG_WORD3, confdata::fork_dump, statedata::freelist, confdata::full_file, confdata::fullmotd_msg, statedata::func_invk_ctr, confdata::func_invk_lim, statedata::func_nest_lev, confdata::func_nest_lim, confdata::game_dir, confdata::game_pag, statedata::generation, statedata::glob_reg_len, confdata::global_error_obj, statedata::global_regs, GOD, confdata::guest_char, confdata::guest_file, confdata::guest_nuker, confdata::guest_prefix, confdata::guests_channel, confdata::guests_channel_alias, confdata::have_comsys, confdata::have_mailer, confdata::have_zones, confdata::hook_obj, confdata::idle_interval, confdata::idle_timeout, confdata::idle_wiz_dark, statedata::in_loop, confdata::indb, confdata::indent_desc, confdata::init_size, statedata::inpipe, ISOUTOFMEMORY, statedata::iter_alist, confdata::killguarantee, confdata::killmax, confdata::killmin, alist::len, confdata::linkcost, statedata::lock_nest_lev, confdata::lock_nest_lim, LOG_ALWAYS, LOG_BUGS, LOG_CONFIGMODS, LOG_DBSAVES, confdata::log_info, LOG_LOGIN, LOG_NET, confdata::log_options, LOG_PCREATES, LOG_PROBLEMS, LOG_SECURITY, LOG_SHOUTS, LOG_STARTUP, LOG_SUSPECTCMDS, LOG_TIMEUSE, LOG_WIZARD, statedata::logging, LOGOPT_LOC, LOGOPT_TIMESTAMP, confdata::machinecost, confdata::mail_db, statedata::mail_db_size, statedata::mail_db_top, confdata::mail_expiration, confdata::mail_per_hour, confdata::many_coins, statedata::markbits, confdata::markdata, confdata::master_room, confdata::match_mine, confdata::match_mine_pl, confdata::max_cache_size, confdata::max_cmdsecs, MAX_GLOBAL_REGS, confdata::max_players, MEMALLOC, statedata::mHelpDesc, confdata::min_guests, statedata::min_size, statedata::mod_al_id, statedata::mod_alist, statedata::mod_alist_len, statedata::mod_size, confdata::motd_file, confdata::motd_msg, statedata::mstat_curr, statedata::mstat_idrss, statedata::mstat_isrss, statedata::mstat_ixrss, statedata::mstat_secs, confdata::mud_name, mudconf, mudstate, tag_int_array::n, confdata::name_spaces, alist::next, statedata::nHearNest, statedata::nHelpDesc, statedata::nObjEvalNest, NOTHING, confdata::nStackLimit, statedata::nStackNest, statedata::ntfy_nest_lev, confdata::ntfy_nest_lim, confdata::number_guests, statedata::olist, confdata::one_coin, confdata::opencost, confdata::outdb, confdata::output_limit, confdata::pagecost, statedata::panicking, confdata::paranoid_alloc, confdata::parent_nest_lim, confdata::paycheck, confdata::payfind, confdata::paylimit, confdata::paystart, confdata::pcreate_per_hour, confdata::pemit_any, confdata::pemit_players, tag_int_array::pi, statedata::pipe_nest_lev, confdata::player_flags, confdata::player_listen, confdata::player_quota, confdata::ports, confdata::postdump_msg, statedata::pout, statedata::poutbufc, statedata::poutnew, statedata::poutobj, confdata::pub_flags, confdata::public_channel, confdata::public_channel_alias, confdata::pueblo_msg, confdata::queue_chunk, confdata::queuemax, confdata::quiet_look, confdata::quiet_whisper, confdata::quit_file, confdata::quotas, confdata::read_rem_desc, confdata::read_rem_name, confdata::regf_file, confdata::reset_players, confdata::restrict_home, confdata::retry_limit, ROBOT, confdata::robot_flags, confdata::robot_speak, confdata::robotcost, confdata::room_flags, confdata::room_quota, confdata::rpt_cmdsecs, confdata::run_startup, SA_DFLT, confdata::sacadjust, confdata::sacfactor, confdata::safe_unowned, confdata::safe_wipe, confdata::safer_passwords, confdata::searchcost, confdata::see_own_dark, CLinearTimeDelta::SetSeconds(), statedata::shutdown_flag, confdata::sig_action, confdata::site_chars, confdata::site_file, confdata::space_compress, confdata::stack_limit, confdata::start_home, confdata::start_quota, confdata::start_room, confdata::status_file, StringClone(), statedata::suspect_list, confdata::sweep_dark, confdata::switch_df_all, confdata::terse_contents, confdata::terse_exits, confdata::terse_look, confdata::terse_movemsg, confdata::thing_flags, confdata::thing_quota, confdata::timeslice, confdata::toad_recipient, confdata::trace_limit, confdata::trace_topdown, statedata::train_nest_lev, confdata::uncompress, confdata::use_hostname, confdata::use_http, confdata::vattr_flags, confdata::vattr_per_hour, confdata::waitcost, statedata::wild_invk_ctr, confdata::wild_invk_lim, confdata::wizmotd_file, confdata::wizmotd_msg, flagset::word, statedata::write_protect, confdata::zone_nest_lim, and statedata::zone_nest_num.

Referenced by dbconvert(), and main().

{
    int i;

    mudconf.indb = StringClone("netmux.db");
    mudconf.outdb = StringClone("");
    mudconf.crashdb = StringClone("");
    mudconf.game_dir = StringClone("");
    mudconf.game_pag = StringClone("");
    mudconf.mail_db   = StringClone("mail.db");
    mudconf.comsys_db = StringClone("comsys.db");

    mudconf.compress_db = false;
    mudconf.compress = StringClone("gzip");
    mudconf.uncompress = StringClone("gzip -d");
    mudconf.status_file = StringClone("shutdown.status");
    mudconf.max_cache_size = 1*1024*1024;

    mudconf.ports.n = 1;
    mudconf.ports.pi = (int *)MEMALLOC(sizeof(int));
    ISOUTOFMEMORY(mudconf.ports.pi);
    mudconf.ports.pi[0] = 2860;

    mudconf.init_size = 1000;
    mudconf.guest_char = -1;
    mudconf.guest_nuker = GOD;
    mudconf.number_guests = 30;
    mudconf.min_guests = 1;
    strcpy(mudconf.guest_prefix, "Guest");
    mudconf.guest_file     = StringClone("text/guest.txt");
    mudconf.conn_file      = StringClone("text/connect.txt");
    mudconf.creg_file      = StringClone("text/register.txt");
    mudconf.regf_file      = StringClone("text/create_reg.txt");
    mudconf.motd_file      = StringClone("text/motd.txt");
    mudconf.wizmotd_file   = StringClone("text/wizmotd.txt");
    mudconf.quit_file      = StringClone("text/quit.txt");
    mudconf.down_file      = StringClone("text/down.txt");
    mudconf.full_file      = StringClone("text/full.txt");
    mudconf.site_file      = StringClone("text/badsite.txt");
    mudconf.crea_file      = StringClone("text/newuser.txt");
    mudconf.motd_msg[0] = '\0';
    mudconf.wizmotd_msg[0] = '\0';
    mudconf.downmotd_msg[0] = '\0';
    mudconf.fullmotd_msg[0] = '\0';
    mudconf.dump_msg[0] = '\0';
    mudconf.postdump_msg[0] = '\0';
    mudconf.fixed_home_msg[0] = '\0';
    mudconf.fixed_tel_msg[0] = '\0';
    strcpy(mudconf.public_channel, "Public");
    strcpy(mudconf.public_channel_alias, "pub");
    strcpy(mudconf.guests_channel, "Guests");
    strcpy(mudconf.guests_channel_alias, "g");
    strcpy(mudconf.pueblo_msg, "</xch_mudtext><img xch_mode=html>");
    mudconf.art_rules = NULL;
    mudconf.indent_desc = false;
    mudconf.name_spaces = true;
#ifndef WIN32
    mudconf.fork_dump = true;
    mudstate.dumping  = false;
    mudstate.dumper   = 0;
    mudstate.dumped   = 0;
    mudstate.write_protect = false;
#endif
    mudconf.restrict_home = false;
    mudconf.have_comsys = true;
    mudconf.have_mailer = true;
    mudconf.have_zones = true;
    mudconf.paranoid_alloc = false;
    mudconf.sig_action = SA_DFLT;
    mudconf.max_players = -1;
    mudconf.dump_interval = 3600;
    mudconf.check_interval = 600;
    mudconf.events_daily_hour = 7;
    mudconf.dump_offset = 0;
    mudconf.check_offset = 300;
    mudconf.idle_timeout = 3600;
    mudconf.conn_timeout = 120;
    mudconf.idle_interval = 60;
    mudconf.retry_limit = 3;
    mudconf.output_limit = 16384;
    mudconf.paycheck = 0;
    mudconf.paystart = 0;
    mudconf.paylimit = 10000;
#ifdef REALITY_LVLS
    mudconf.no_levels = 0;
    mudconf.def_room_rx = 1;
    mudconf.def_room_tx = ~(RLEVEL)0;
    mudconf.def_player_rx = 1;
    mudconf.def_player_tx = 1;
    mudconf.def_exit_rx = 1;
    mudconf.def_exit_tx = 1;
    mudconf.def_thing_rx = 1;
    mudconf.def_thing_tx = 1;
#endif /* REALITY_LVLS */
    mudconf.start_quota = 20;
    mudconf.site_chars = 25;
    mudconf.payfind = 0;
    mudconf.digcost = 10;
    mudconf.linkcost = 1;
    mudconf.opencost = 1;
    mudconf.createmin = 10;
    mudconf.createmax = 505;
    mudconf.killmin = 10;
    mudconf.killmax = 100;
    mudconf.killguarantee = 100;
    mudconf.robotcost = 1000;
    mudconf.pagecost = 10;
    mudconf.searchcost = 100;
    mudconf.waitcost = 10;
    mudconf.machinecost = 64;
    mudconf.exit_quota = 1;
    mudconf.player_quota = 1;
    mudconf.room_quota = 1;
    mudconf.thing_quota = 1;
    mudconf.mail_expiration = 14;
    mudconf.queuemax = 100;
    mudconf.queue_chunk = 10;
    mudconf.active_q_chunk  = 10;
    mudconf.sacfactor       = 5;
    mudconf.sacadjust       = -1;
    mudconf.trace_limit     = 200;

    mudconf.autozone        = true;
    mudconf.use_hostname    = true;
    mudconf.clone_copy_cost = false;
    mudconf.dark_sleepers   = true;
    mudconf.ex_flags        = true;
    mudconf.exam_public     = true;
    mudconf.fascist_tport   = false;
    mudconf.idle_wiz_dark   = false;
    mudconf.match_mine      = true;
    mudconf.match_mine_pl   = true;
    mudconf.pemit_players   = false;
    mudconf.pemit_any       = false;
    mudconf.player_listen   = false;
    mudconf.pub_flags       = true;
    mudconf.quiet_look      = true;
    mudconf.quiet_whisper   = true;
    mudconf.quotas          = false;
    mudconf.read_rem_desc   = false;
    mudconf.read_rem_name   = false;
    mudconf.reset_players   = false;
    mudconf.robot_speak     = true;
    mudconf.safe_unowned    = false;
    mudconf.safer_passwords = false;
    mudconf.see_own_dark    = true;
    mudconf.sweep_dark      = false;
    mudconf.switch_df_all   = true;
    mudconf.terse_contents  = true;
    mudconf.terse_exits     = true;
    mudconf.terse_look      = true;
    mudconf.terse_movemsg   = true;
    mudconf.trace_topdown   = true;
    mudconf.use_http        = false;

    // -- ??? Running SC on a non-SC DB may cause problems.
    //
    mudconf.space_compress = true;
    mudconf.allow_guest_from_registered_site = true;
    mudconf.start_room = 0;
    mudconf.start_home = NOTHING;
    mudconf.default_home = NOTHING;
    mudconf.master_room = NOTHING;

    for (i = FLAG_WORD1; i <= FLAG_WORD3; i++)
    {
        mudconf.player_flags.word[i] = 0;
        mudconf.room_flags.word[i] = 0;
        mudconf.exit_flags.word[i] = 0;
        mudconf.thing_flags.word[i] = 0;
        mudconf.robot_flags.word[i] = 0;
    }
    mudconf.robot_flags.word[FLAG_WORD1] |= ROBOT;

    mudconf.vattr_flags = AF_ODARK;
    strcpy(mudconf.mud_name, "MUX");
    strcpy(mudconf.one_coin, "penny");
    strcpy(mudconf.many_coins, "pennies");
    mudconf.timeslice.SetSeconds(1);
    mudconf.cmd_quota_max = 100;
    mudconf.cmd_quota_incr = 1;
    mudconf.rpt_cmdsecs.SetSeconds(120);
    mudconf.max_cmdsecs.SetSeconds(60);
    mudconf.cache_tick_period.SetSeconds(30);
    mudconf.control_flags = 0xffffffff; // Everything for now...
    mudconf.log_options = LOG_ALWAYS | LOG_BUGS | LOG_SECURITY |
        LOG_NET | LOG_LOGIN | LOG_DBSAVES | LOG_CONFIGMODS |
        LOG_SHOUTS | LOG_STARTUP | LOG_WIZARD | LOG_SUSPECTCMDS |
        LOG_PROBLEMS | LOG_PCREATES | LOG_TIMEUSE;
    mudconf.log_info = LOGOPT_TIMESTAMP | LOGOPT_LOC;
    mudconf.markdata[0] = 0x01;
    mudconf.markdata[1] = 0x02;
    mudconf.markdata[2] = 0x04;
    mudconf.markdata[3] = 0x08;
    mudconf.markdata[4] = 0x10;
    mudconf.markdata[5] = 0x20;
    mudconf.markdata[6] = 0x40;
    mudconf.markdata[7] = 0x80;
    mudconf.func_nest_lim = 50;
    mudconf.func_invk_lim = 2500;
    mudconf.wild_invk_lim = 100000;
    mudconf.ntfy_nest_lim = 20;
    mudconf.lock_nest_lim = 20;
    mudconf.parent_nest_lim = 10;
    mudconf.zone_nest_lim = 20;
    mudconf.stack_limit = 50;
    mudconf.cache_names = true;
    mudconf.toad_recipient = -1;
    mudconf.eval_comtitle = true;
    mudconf.run_startup = true;
    mudconf.safe_wipe = false;
    mudconf.destroy_going_now = false;
    mudconf.nStackLimit = 10000;
    mudconf.hook_obj = NOTHING;
    mudconf.global_error_obj = NOTHING;
    mudconf.cache_pages = 40;
    mudconf.mail_per_hour = 50;
    mudconf.vattr_per_hour = 5000;
    mudconf.pcreate_per_hour = 100;

    mudstate.events_flag = 0;
    mudstate.bReadingConfiguration = false;
    mudstate.bCanRestart = false;
    mudstate.panicking = false;
    mudstate.logging = 0;
    mudstate.epoch = 0;
    mudstate.generation = 0;
    mudstate.curr_executor = NOTHING;
    mudstate.curr_enactor = NOTHING;
    mudstate.shutdown_flag  = false;
    mudstate.attr_next = A_USER_START;
    mudstate.debug_cmd = "< init >";
    mudstate.curr_cmd  = "< none >";
    strcpy(mudstate.doing_hdr, "Doing");
    mudstate.access_list = NULL;
    mudstate.suspect_list = NULL;
    mudstate.badname_head = NULL;
    mudstate.mstat_ixrss[0] = 0;
    mudstate.mstat_ixrss[1] = 0;
    mudstate.mstat_idrss[0] = 0;
    mudstate.mstat_idrss[1] = 0;
    mudstate.mstat_isrss[0] = 0;
    mudstate.mstat_isrss[1] = 0;
    mudstate.mstat_secs[0] = 0;
    mudstate.mstat_secs[1] = 0;
    mudstate.mstat_curr = 0;
    mudstate.iter_alist.data = NULL;
    mudstate.iter_alist.len = 0;
    mudstate.iter_alist.next = NULL;
    mudstate.mod_alist = NULL;
    mudstate.mod_alist_len = 0;
    mudstate.mod_size = 0;
    mudstate.mod_al_id = NOTHING;
    mudstate.olist = NULL;
    mudstate.min_size = 0;
    mudstate.db_top = 0;
    mudstate.db_size = 0;
    mudstate.mail_db_top = 0;
    mudstate.mail_db_size = 0;
    mudstate.freelist = NOTHING;
    mudstate.markbits = NULL;
    mudstate.func_nest_lev = 0;
    mudstate.func_invk_ctr = 0;
    mudstate.wild_invk_ctr = 0;
    mudstate.ntfy_nest_lev = 0;
    mudstate.train_nest_lev = 0;
    mudstate.lock_nest_lev = 0;
    mudstate.zone_nest_num = 0;
    mudstate.pipe_nest_lev = 0;
    mudstate.inpipe = false;
    mudstate.pout = NULL;
    mudstate.poutnew = NULL;
    mudstate.poutbufc = NULL;
    mudstate.poutobj = NOTHING;
    for (i = 0; i < MAX_GLOBAL_REGS; i++)
    {
        mudstate.global_regs[i] = NULL;
        mudstate.glob_reg_len[i] = 0;
    }
    mudstate.nObjEvalNest = 0;
    mudstate.in_loop = 0;
    mudstate.bStackLimitReached = false;
    mudstate.nStackNest = 0;
    mudstate.nHearNest  = 0;
    mudstate.aHelpDesc = NULL;
    mudstate.mHelpDesc = 0;
    mudstate.nHelpDesc = 0;
}

void cf_list	(	dbref	player,
		char *	buff,
		char **	bufc
	)

Definition at line 2243 of file conf.cpp.

References check_access(), conftable, ItemToList_AddString(), ItemToList_Init(), confparm::pname, and confparm::rperms.

Referenced by FUNCTION().

{
    CONF *tp;
    ITL itl;
    ItemToList_Init(&itl, buff, bufc);

    for (tp = conftable; tp->pname; tp++)
    {
        if (check_access(player, tp->rperms))
        {
            if (!ItemToList_AddString(&itl, tp->pname))
            {
                break;
            }
        }
    }
    ItemToList_Final(&itl);
    return;
}

void cf_log_notfound	(	dbref	player,
		char *	cmd,
		const char *	thingname,
		char *	thing
	)

Definition at line 331 of file conf.cpp.

References statedata::bReadingConfiguration, ENDLOG, Log, LOG_STARTUP, mudstate, notify, STARTLOG, CLogFile::tinyprintf(), and tprintf().

Referenced by CF_HAND().

{
    if (mudstate.bReadingConfiguration)
    {
        STARTLOG(LOG_STARTUP, "CNF", "NFND");
        Log.tinyprintf("%s: %s %s not found", cmd, thingname, thing);
        ENDLOG;
    }
    else
    {
        notify(player, tprintf("%s %s not found", thingname, thing));
    }
}

void DCL_CDECL cf_log_syntax	(	dbref	player,
		char *	cmd,
		const char *	fmt,
			...
	)

Definition at line 348 of file conf.cpp.

References alloc_lbuf, statedata::bReadingConfiguration, ENDLOG, free_lbuf, LBUF_SIZE, LOG_STARTUP, log_text(), mudstate, mux_vsnprintf(), notify, and STARTLOG.

Referenced by add_helpfile(), and CF_HAND().

{
    va_list ap;
    va_start(ap, fmt);

    char *buf = alloc_lbuf("cf_log_syntax");
    mux_vsnprintf(buf, LBUF_SIZE, fmt, ap);
    if (mudstate.bReadingConfiguration)
    {
        STARTLOG(LOG_STARTUP, "CNF", "SYNTX")
        log_text(cmd);
        log_text(": ");
        log_text(buf);
        ENDLOG;
    }
    else
    {
        notify(player, buf);
    }
    free_lbuf(buf);
    va_end(ap);
}

int cf_read

(

void

)

Definition at line 2118 of file conf.cpp.

References statedata::bReadingConfiguration, confdata::config_file, DefaultSuffixes, confdata::indb, ISOUTOFMEMORY, MEMALLOC, MEMFREE, mudconf, mudstate, pFilename, and pSuffix.

Referenced by main().

{
    int retval;

    mudstate.bReadingConfiguration = true;
    retval = cf_include(NULL, mudconf.config_file, (void *)0, 0, 0, "init");
    mudstate.bReadingConfiguration = false;

    // Fill in missing DB file names.
    //
    unsigned int nInDB = strlen(mudconf.indb);
    for (int i = 0; DefaultSuffixes[i].pFilename; i++)
    {
        char **p = DefaultSuffixes[i].pFilename;
        if (**p == '\0')
        {
            // The filename is an empty string so we should construct
            // a default filename.
            //
            char *pSuffix = DefaultSuffixes[i].pSuffix;
            int nSuffix = strlen(pSuffix);
            char *buff = (char *)MEMALLOC(nInDB + nSuffix + 1);
            ISOUTOFMEMORY(buff);
            memcpy(buff, mudconf.indb, nInDB);
            memcpy(buff + nInDB, pSuffix, nSuffix+1);
            MEMFREE(*p);
            *p = buff;
        }
    }
    return retval;
}

int cf_set	(	char *	cp,
		char *	ap,
		dbref	player
	)

Definition at line 1983 of file conf.cpp.

References alloc_lbuf, statedata::bReadingConfiguration, check_access(), conftable, confparm::flags, mudstate, NOPERM_MESSAGE, notify, and confparm::pname.

Referenced by CF_HAND(), and do_admin().

{
    CONF *tp;
    int i;
    char *buff = 0;

    // Search the config parameter table for the command. If we find
    // it, call the handler to parse the argument.
    //
    for (tp = conftable; tp->pname; tp++)
    {
        if (!strcmp(tp->pname, cp))
        {
            if (  !mudstate.bReadingConfiguration
               && !check_access(player, tp->flags))
            {
                notify(player, NOPERM_MESSAGE);
                return -1;
            }
            if (!mudstate.bReadingConfiguration)
            {
                buff = alloc_lbuf("cf_set");
                strcpy(buff, ap);
            }
            i = tp->interpreter(tp->loc, ap, tp->pExtra, tp->nExtra, player, cp);
            if (!mudstate.bReadingConfiguration)
            {
                STARTLOG(LOG_CONFIGMODS, "CFG", "UPDAT");
                log_name(player);
                log_text(" entered config directive: ");
                log_text(cp);
                log_text(" with args '");
                log_text(buff);
                log_text("'.  Status: ");
                switch (i)
                {
                case 0:
                    log_text("Success.");
                    break;

                case 1:
                    log_text("Partial success.");
                    break;

                case -1:
                    log_text("Failure.");
                    break;

                default:
                    log_text("Strange.");
                }
                ENDLOG;
                free_lbuf(buff);
            }
            return i;
        }
    }

    // Config directive not found.  Complain about it.
    //
    cf_log_notfound(player, "Set", "Config directive", cp);
    return -1;
}

static int cf_status_from_succfail	(	dbref	player,
		char *	cmd,
		int	success,
		int	failure
	)			[static]

Definition at line 374 of file conf.cpp.

References alloc_lbuf, statedata::bReadingConfiguration, ENDLOG, free_lbuf, LOG_STARTUP, log_text(), mudstate, notify, and STARTLOG.

Referenced by CF_HAND().

{
    char *buff;

    // If any successes, return SUCCESS(0) if no failures or
    // PARTIAL_SUCCESS(1) if any failures.
    //
    if (success > 0)
        return ((failure == 0) ? 0 : 1);

    // No successes.  If no failures indicate nothing done. Always return
    // FAILURE(-1)
    //
    if (failure == 0)
    {
        if (mudstate.bReadingConfiguration)
        {
            STARTLOG(LOG_STARTUP, "CNF", "NDATA")
            buff = alloc_lbuf("cf_status_from_succfail.LOG");
            sprintf(buff, "%s: Nothing to set", cmd);
            log_text(buff);
            free_lbuf(buff);
            ENDLOG
        }
        else
        {
            notify(player, "Nothing to set");
        }
    }
    return -1;
}

static bool DecodeN	(	int	nType,
		size_t	len,
		const char *	p,
		in_addr_t *	pu32
	)			[static]

Definition at line 1060 of file conf.cpp.

References mux_tolower, and DECODEIPV4::nShift.

Referenced by MakeCanonicalIPv4().

{
    static DECODEIPV4 DecodeIPv4Table[4] =
    {
        { 8,         255UL,  3,  3, 2 },
        { 16,      65535UL,  6,  5, 4 },
        { 24,   16777215UL,  8,  8, 6 },
        { 32, 4294967295UL, 11, 10, 8 }
    };

    *pu32  = (*pu32 << DecodeIPv4Table[nType].nShift) & 0xFFFFFFFFUL;
    if (len == 0)
    {
        return false;
    }
    in_addr_t ul = 0;
    in_addr_t ul2;
    if (  len >= 3
       && p[0] == '0'
       && mux_tolower(p[1]) == 'x')
    {
        // Hexadecimal Path
        //
        // Skip the leading zeros.
        //
        p += 2;
        len -= 2;
        while (*p == '0' && len)
        {
            p++;
            len--;
        }
        if (len > DecodeIPv4Table[nType].maxHexLen)
        {
            return false;
        }
        while (len)
        {
            unsigned char ch = mux_tolower(*p);
            ul2 = ul;
            ul  = (ul << 4) & 0xFFFFFFFFUL;
            if (ul < ul2)
            {
                // Overflow
                //
                return false;
            }
            if ('0' <= ch && ch <= '9')
            {
                ul |= ch - '0';
            }
            else if ('a' <= ch && ch <= 'f')
            {
                ul |= ch - 'a';
            }
            else
            {
                return false;
            }
            p++;
            len--;
        }
    }
    else if (len >= 1 && p[0] == '0')
    {
        // Octal Path
        //
        // Skip the leading zeros.
        //
        p++;
        len--;
        while (*p == '0' && len)
        {
            p++;
            len--;
        }
        if (len > DecodeIPv4Table[nType].maxOctLen)
        {
            return false;
        }
        while (len)
        {
            unsigned char ch = *p;
            ul2 = ul;
            ul  = (ul << 3) & 0xFFFFFFFFUL;
            if (ul < ul2)
            {
                // Overflow
                //
                return false;
            }
            if ('0' <= ch && ch <= '7')
            {
                ul |= ch - '0';
            }
            else
            {
                return false;
            }
            p++;
            len--;
        }
    }
    else
    {
        // Decimal Path
        //
        if (len > DecodeIPv4Table[nType].maxDecLen)
        {
            return false;
        }
        while (len)
        {
            unsigned char ch = *p;
            ul2 = ul;
            ul  = (ul * 10) & 0xFFFFFFFFUL;
            if (ul < ul2)
            {
                // Overflow
                //
                return false;
            }
            ul2 = ul;
            if ('0' <= ch && ch <= '9')
            {
                ul += ch - '0';
            }
            else
            {
                return false;
            }
            if (ul < ul2)
            {
                // Overflow
                //
                return false;
            }
            p++;
            len--;
        }
    }
    if (ul > DecodeIPv4Table[nType].maxValue)
    {
        return false;
    }
    *pu32 |= ul;
    return true;
}

void do_admin	(	dbref	executor,
		dbref	caller,
		dbref	enactor,
		int	extra,
		int	nargs,
		char *	kw,
		char *	value
	)

Definition at line 2078 of file conf.cpp.

References cf_set(), notify, Quiet, UNUSED_PARAMETER, and ValidateConfigurationDbrefs().

{
    UNUSED_PARAMETER(caller);
    UNUSED_PARAMETER(enactor);
    UNUSED_PARAMETER(extra);
    UNUSED_PARAMETER(nargs);

    int i = cf_set(kw, value, executor);
    if ((i >= 0) && !Quiet(executor))
    {
        notify(executor, "Set.");
    }
    ValidateConfigurationDbrefs();
}

static bool isValidSubnetMask

(

in_addr_t

ulMask

)

[static]

Definition at line 1285 of file conf.cpp.

Referenced by CF_HAND().

{
    in_addr_t ulTest = 0xFFFFFFFFUL;
    for (int i = 0; i <= 32; i++)
    {
        if (ulMask == ulTest)
        {
            return true;
        }
        ulTest = (ulTest << 1) & 0xFFFFFFFFUL;
    }
    return false;
}

void list_cf_access

(

dbref

player

)

Definition at line 2153 of file conf.cpp.

References access_nametab, alloc_mbuf, check_access(), conftable, confparm::flags, God, listset_nametab(), and confparm::pname.

Referenced by do_list().

{
    CONF *tp;
    char *buff;

    buff = alloc_mbuf("list_cf_access");
    for (tp = conftable; tp->pname; tp++)
    {
        if (God(player) || check_access(player, tp->flags))
        {
            sprintf(buff, "%s:", tp->pname);
            listset_nametab(player, access_nametab, tp->flags, buff, true);
        }
    }
    free_mbuf(buff);
}

static bool MakeCanonicalIPv4	(	const char *	str,
		in_addr_t *	pnIP
	)			[static]

Definition at line 1235 of file conf.cpp.

References DecodeN().

Referenced by CF_HAND().

{
    *pnIP = 0;
    if (!str)
    {
        return false;
    }

    // Skip leading spaces.
    //
    const char *q = str;
    while (*q == ' ')
    {
        q++;
    }

    const char *p = strchr(q, '.');
    int n = 0;
    while (p)
    {
        // Decode
        //
        n++;
        if (n > 3)
        {
            return false;
        }
        if (!DecodeN(0, p-q, q, pnIP))
        {
            return false;
        }
        q = p + 1;
        p = strchr(q, '.');
    }

    // Decode last element.
    //
    size_t len = strlen(q);
    if (!DecodeN(3-n, len, q, pnIP))
    {
        return false;
    }
    *pnIP = htonl(*pnIP);
    return true;
}

void ValidateConfigurationDbrefs

(

void

)

Definition at line 2049 of file conf.cpp.

References statedata::db_top, confdata::default_home, confdata::guest_char, confdata::guest_nuker, confdata::master_room, mudconf, mudstate, NOTHING, confdata::start_home, and confdata::start_room.

Referenced by do_admin(), and main().

{
    static dbref *Table[] =
    {
        &mudconf.default_home,
        &mudconf.guest_char,
        &mudconf.guest_nuker,
        &mudconf.master_room,
        &mudconf.start_home,
        &mudconf.start_room,
        0
    };

    for (int i = 0; Table[i]; i++)
    {
        if (*Table[i] != NOTHING)
        {
            if (*Table[i] < 0 || mudstate.db_top <= *Table[i])
            {
                *Table[i] = NOTHING;
            }
        }
    }
}

---

Variable Documentation

NAMETAB bool_names[] [static]

Initial value:

{
    {"true",    1,  0,  true},
    {"false",   1,  0,  false},
    {"yes",     1,  0,  true},
    {"no",      1,  0,  false},
    {"1",       1,  0,  true},
    {"0",       1,  0,  false},
    {NULL,      0,  0,  0}
}

Definition at line 548 of file conf.cpp.

Referenced by CF_HAND().

CONF conftable[] [static]

Definition at line 1723 of file conf.cpp.

Referenced by cf_display(), CF_HAND(), cf_list(), cf_set(), and list_cf_access().

struct { ... } DefaultSuffixes[] [static]

Referenced by cf_read().

NAMETAB hook_names[] [static]

Initial value:

{
    {"after",      3, 0, HOOK_AFTER},
    {"before",     3, 0, HOOK_BEFORE},
    {"fail",       3, 0, HOOK_AFAIL},
    {"ignore",     3, 0, HOOK_IGNORE},
    {"igswitch",   3, 0, HOOK_IGSWITCH},
    {"permit",     3, 0, HOOK_PERMIT},
    {NULL,         0, 0, 0}
}

Definition at line 1547 of file conf.cpp.

Referenced by CF_HAND().

CONFDATA mudconf

Definition at line 33 of file conf.cpp.

Referenced by CGuests::AddToGuestChannel(), AddToPublicChannel(), announce_connect(), announce_disconnect(), anum_extend(), bCanReadAttr(), BuildChannelMessage(), CallBack_HaltQueue(), CallBack_NotifySemaphoreDrainOrAll(), can_see(), canpayfees(), CF_HAND(), cf_init(), cf_read(), check_command(), check_connect(), check_dead_refs(), check_events(), check_floating(), check_idle(), check_mail_expiration(), check_zone_handler(), chown_all(), CGuests::CleanUp(), CLI_CallBack(), connect_player(), count_quota(), CGuests::Create(), create_obj(), db_grow(), db_read(), default_home(), desc_reload(), destroy_obj(), destroyable(), CGuests::DestroyGuestChar(), dispatch_CacheTick(), dispatch_CheckEvents(), dispatch_DatabaseDump(), dispatch_FreeListReconstruction(), dispatch_IdleCheck(), do_addcom(), do_allcom(), do_apply_marked(), do_backup(), do_cemit(), do_chanlist(), do_channelwho(), do_chboot(), do_chopen(), do_chown(), do_chzone(), do_clearcom(), do_clone(), do_comlist(), do_command(), do_comtitle(), do_delcom(), do_destroy(), do_destroychannel(), do_editchannel(), do_entrances(), do_examine(), do_find(), do_global(), do_kill(), do_list(), do_logged_out_internal(), do_look(), do_mail(), do_mail_stats(), do_malias(), do_markall(), do_motd(), do_move(), do_pcreate(), do_pemit_single(), do_postpend(), do_prepend(), do_processcom(), do_quota(), do_restart(), do_score(), do_search(), do_shutdown(), do_sweep(), do_switch(), do_teleport(), do_teleport_single(), do_toad(), do_unlink(), do_verb(), do_wipe(), dump_database(), dump_database_internal(), dump_info(), dump_users(), eval_boolexp(), exam_wildattrs(), fh_going_bit(), filter_handler(), fork_and_dump(), FUNCTION(), get_slave_result(), get_stats(), give_money(), halt_que(), higcheck(), hook_fail(), init_timer(), initializesock(), link_exit(), list_costs(), list_df_flags(), list_options(), CGuests::ListAll(), load_game(), load_restart_db(), log_name(), log_name_and_loc(), look_contents(), look_in(), look_simple(), main(), CGuests::MakeGuestChar(), match_master_exit(), mkattr(), Moniker(), move_object(), move_via_exit(), move_via_teleport(), mux_exec(), new_connection(), notify_check(), ok_password(), open_exit(), page_check(), parse_connect(), parse_to(), parse_to_cleanup(), pool_alloc(), pool_alloc_lbuf(), pool_free(), pool_free_lbuf(), process_cmdent(), process_command(), process_enter_loc(), process_leave_loc(), process_preload(), PureName(), queue_write_LEN(), QueueMax(), quick_wild(), ReleaseAllResources(), report_timecheck(), CScheduler::RunTasks(), s_Moniker(), s_Name(), scan_zone(), setup_que(), SetupGlobalThrottle(), SetupThrottle(), show_a_desc(), sighandler(), sp_ok(), start_home(), start_log(), CGuests::StartUp(), string_compare(), sweep_check(), Task_ProcessCommand(), Task_RunQueueEntry(), tcache_add(), CHashFile::Tick(), TrimCache(), trimmed_site(), u_comp(), update_quotas(), ValidateConfigurationDbrefs(), ValidatePlayerName(), wait_que(), where_room(), and wild1().

STATEDATA mudstate

Definition at line 34 of file conf.cpp.

Referenced by add_comsys(), add_helpfile(), add_player_name(), al_add(), al_delete(), al_fetch(), al_store(), announce_connect(), announce_disconnect(), anum_extend(), MailList::AppendItem(), AssertionFailed(), atr_add(), atr_clr(), atr_free(), atr_head(), atr_match(), atr_match1(), atr_pop(), atr_push(), atr_str(), badname_add(), badname_check(), badname_list(), badname_remove(), bCanReadAttr(), bind_and_queue(), build_version(), cache_del(), cache_get(), cache_put(), CF_HAND(), cf_init(), cf_log_notfound(), cf_log_syntax(), cf_read(), cf_set(), cf_status_from_succfail(), check_access(), check_command(), check_connect(), check_dead_refs(), check_events(), check_filter(), check_floating(), check_panicking(), check_zone_handler(), CLI_CallBack(), commands_no_arg_add(), commands_one_arg_add(), commands_one_arg_cmdarg_add(), commands_two_arg_add(), commands_two_arg_argv_add(), commands_two_arg_argv_cmdarg_add(), commands_two_arg_cmdarg_add(), Commer(), create_obj(), db_free(), db_grow(), db_read(), db_write(), db_write_object(), dbclean_CheckANHtoAT(), dbclean_CheckATtoANH(), dbclean_RemoveStaleAttributeNames(), dbclean_RenumberAttributes(), decode_power(), del_comsys(), delete_player_name(), desc_addhash(), desc_delhash(), destroy_bad_obj(), destroy_obj(), did_it(), dispatch_CacheTick(), dispatch_CanRestart(), dispatch_CheckEvents(), dispatch_DatabaseDump(), dispatch_FreeListReconstruction(), dispatch_IdleCheck(), do_addcommand(), do_backup(), do_chanlist(), do_channelnuke(), do_command(), do_createchannel(), do_dbck(), do_dbclean(), do_delcommand(), do_destroychannel(), do_doing(), do_dolist(), do_dump(), do_flag(), do_force(), do_function(), do_hook(), do_icmd(), do_if(), do_listchannels(), do_listcommands(), do_logged_out_internal(), do_mail_debug(), do_prog(), do_quitprog(), do_restart(), do_shutdown(), do_stats(), do_switch(), do_timewarp(), do_train(), do_version(), do_wait(), dump_database(), dump_database_internal(), dump_info(), dump_mail(), dump_restart_db(), dump_users(), end_log(), eval_boolexp(), exit_displayable(), exit_visible(), failconn(), filter_handler(), find_flag(), find_power(), find_wild_attrs(), MailList::FirstItem(), flag_rename(), fork_and_dump(), FUNCTION(), function_add(), functions_add(), fwdlist_ck(), fwdlist_clr(), fwdlist_get(), fwdlist_load(), fwdlist_set(), GetProcessorUsage(), handle_prog(), Hearer(), help_helper(), help_write(), helpindex_clean(), helpindex_load(), helpindex_read(), init_attrtab(), init_cmdtab(), init_dbfile(), init_flagtab(), init_logout_cmdtab(), init_powertab(), init_timer(), init_version(), initializesock(), CHashFile::Insert(), iter_value(), list_check(), list_hashstats(), list_options(), list_process(), list_siteinfo(), list_vattrs(), load_comsystem(), load_restart_db(), log_name(), log_perror(), look_atrs(), look_atrs1(), lookup_player(), mail_db_grow(), main(), make_freelist(), MessageAdd(), mux_exec(), new_connection(), notify_check(), ok_password(), olist_add(), olist_first(), olist_next(), olist_pop(), olist_push(), OutOfMemory(), parse_attrib_wild(), parse_boolexp(), parse_boolexp_L(), parse_range(), Pennies(), pool_alloc(), pool_alloc_lbuf(), pool_err(), pool_free(), pool_free_lbuf(), process_cmdent(), process_command(), process_input(), process_output(), QueueMax(), quick_wild(), raw_notify(), raw_notify_html(), raw_notify_newline(), CHashPage::ReadPage(), real_regmatch(), MailList::RemoveAll(), MailList::RemoveItem(), report(), report_timecheck(), ReportMatchedTopics(), ReportTopic(), restore_global_regs(), room_list(), s_Pennies(), save_and_clear_global_regs(), save_comsystem(), save_global_regs(), search_perform(), select_channel(), SetupGlobalThrottle(), shovechars(), shutdownsock(), sighandler(), CMuxAlarm::Sleep(), start_log(), string_compare(), sweep_check(), CHashFile::Sync(), Task_RunQueueEntry(), ThrottlePlayerCreate(), TrimCache(), u_comp(), unparse_boolexp1(), ValidateConfigurationDbrefs(), ValidateHelpFileIndex(), ValidatePlayerName(), vattr_alloc_LEN(), vattr_define_LEN(), vattr_delete_LEN(), vattr_find_LEN(), vattr_first(), vattr_next(), vattr_rename_LEN(), wild(), wild1(), wild_match(), CHashFile::WriteDirectory(), and CHashPage::WritePage().

char** pFilename

Definition at line 2106 of file conf.cpp.

Referenced by cf_read(), and do_log().

char* pSuffix

Definition at line 2107 of file conf.cpp.

Referenced by cf_read().

---