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;
}