src/conf.c

Go to the documentation of this file.

/*
 * conf.c:      set up configuration information and static data
 */

#include "copyright.h"
#include "config.h"

#include "mudconf.h"
#include "db.h"
#include "externs.h"
#include "interface.h"
#include "command.h"
#include "htab.h"
#include "alloc.h"
#include "attrs.h"
#include "flags.h"
#include "powers.h"
#ifdef SQL_SUPPORT
#include "sqlchild.h"
#endif

/* default (runtime-resettable) cache parameters */

#define CACHE_DEPTH     10
#define CACHE_WIDTH     20

/*
 * ---------------------------------------------------------------------------
 * * CONFPARM: Data used to find fields in CONFDATA.
 */

typedef struct confparm CONF;
struct confparm {
        char *pname;                            /* parm name */
        int (*interpreter) ();          /* routine to interp parameter */
        int flags;                                      /* control flags */
        int *loc;                                       /* where to store value */
        long extra;                                     /* extra data for interpreter */
};

/*
 * ---------------------------------------------------------------------------
 * * External symbols.
 */

CONFDATA mudconf;
STATEDATA mudstate;

extern NAMETAB logdata_nametab[];
extern NAMETAB logoptions_nametab[];
extern NAMETAB access_nametab[];
extern NAMETAB attraccess_nametab[];
extern NAMETAB list_names[];
#if 0
extern NAMETAB sigactions_nametab[];
#endif

extern CONF conftable[];

/*
 * ---------------------------------------------------------------------------
 * * cf_init: Initialize mudconf to default values.
 */

void cf_init(void)
{
        int i;

        StringCopy(mudconf.indb, "tinymush.db");
        StringCopy(mudconf.outdb, "");
        StringCopy(mudconf.crashdb, "");
        StringCopy(mudconf.gdbm, "");
        StringCopy(mudconf.mail_db, "mail.db");
        StringCopy(mudconf.commac_db, "commac.db");
        StringCopy(mudconf.hcode_db, "hcode.db");
#ifdef BT_ADVANCED_ECON
        StringCopy(mudconf.econ_db, "econ.db");
#endif
        StringCopy(mudconf.mech_db, "mechs");
        StringCopy(mudconf.map_db, "maps");
        mudconf.compress_db = 0;
        StringCopy(mudconf.compress, "gzip");
        StringCopy(mudconf.uncompress, "gzip -d");
        StringCopy(mudconf.status_file, "shutdown.status");
        mudconf.allow_unloggedwho = 0;
        mudconf.btech_explode_reactor = 1;
        mudconf.btech_explode_time = 120;
        mudconf.btech_explode_ammo = 1;
        mudconf.btech_explode_stop = 0;
        mudconf.btech_stackpole = 1;
        mudconf.btech_phys_use_pskill = 1;
        mudconf.btech_erange = 1;
        mudconf.btech_dig_only_fs = 0;
        mudconf.btech_digbonus = 3;
        mudconf.btech_vcrit = 2;
        mudconf.btech_dynspeed = 1;
        mudconf.btech_ic = 1;
        mudconf.btech_parts = 1;
        mudconf.btech_slowdown = 2;
        mudconf.btech_fasaturn = 1;
        mudconf.btech_fasacrit = 0;
        mudconf.btech_fasaadvvtolcrit = 0;
        mudconf.btech_fasaadvvhlcrit = 0;
        mudconf.btech_fasaadvvhlfire = 0;
        mudconf.btech_divrotordamage = 0;
        mudconf.btech_moddamagewithrange = 0;
        mudconf.btech_moddamagewithwoods = 0;
        mudconf.btech_hotloadaddshalfbthmod = 0;
        mudconf.btech_nofusionvtolfuel = 0;
        mudconf.btech_tankfriendly = 0;
        mudconf.btech_newterrain = 0;
        mudconf.btech_skidcliff = 0;
        mudconf.btech_xp_bthmod = 0;
        mudconf.btech_xp_missilemod = 100;
        mudconf.btech_xp_ammomod = 100;
        mudconf.btech_defaultweapdam = 5;
        mudconf.btech_xp_modifier = 100;
        mudconf.btech_defaultweapbv = 120;
        mudconf.btech_xp_usePilotBVMod = 1;
        mudconf.btech_oldxpsystem = 1;
        mudconf.btech_xp_vrtmod = 0;
        mudconf.btech_limitedrepairs = 0;
        mudconf.btech_newcharge = 0;
        mudconf.btech_tl3_charge = 0;
        mudconf.btech_xploss = 666;
        mudconf.btech_critlevel = 100;
        mudconf.btech_tankshield = 0;
        mudconf.btech_newstagger = 0;
        mudconf.btech_extendedmovemod = 1;
        mudconf.btech_stacking = 2;
        mudconf.btech_stackdamage = 100;
        mudconf.btech_mw_losmap = 1;
        mudconf.btech_seismic_see_stopped = 0;
        mudconf.btech_exile_stun_code = 0;
        mudconf.btech_roll_on_backwalk = 1;
        mudconf.btech_usedmechstore = 0;
        mudconf.btech_ooc_comsys = 0;
        mudconf.btech_idf_requires_spotter = 1;
        mudconf.btech_vtol_ice_causes_fire = 1;
        mudconf.btech_glancing_blows = 1;
        mudconf.btech_inferno_penalty = 0;
        mudconf.btech_perunit_xpmod = 1;
#ifdef BT_FREETECHTIME
        mudconf.btech_freetechtime = 0;
#endif
#ifdef BT_COMPLEXREPAIRS
        mudconf.btech_complexrepair = 1;
#endif
#ifdef HUDINFO_SUPPORT
        mudconf.hudinfo_show_mapinfo = 0;
        mudconf.hudinfo_enabled;
#endif
        mudconf.namechange_days = 60;
        mudconf.allow_chanlurking = 0;
        mudconf.afterlife_dbref = 220;
        mudconf.afterscen_dbref = 801;
        mudconf.port = 6250;
        mudconf.conc_port = 6251;
        mudconf.init_size = 1000;
        mudconf.guest_char = -1;
        mudconf.guest_nuker = 1;
        mudconf.number_guests = 30;
        StringCopy(mudconf.guest_prefix, "Guest");
        StringCopy(mudconf.guest_file, "text/guest.txt");
        StringCopy(mudconf.conn_file, "text/connect.txt");
        StringCopy(mudconf.conn_dir, "");
        StringCopy(mudconf.creg_file, "text/register.txt");
        StringCopy(mudconf.regf_file, "text/create_reg.txt");
        StringCopy(mudconf.motd_file, "text/motd.txt");
        StringCopy(mudconf.wizmotd_file, "text/wizmotd.txt");
        StringCopy(mudconf.quit_file, "text/quit.txt");
        StringCopy(mudconf.down_file, "text/down.txt");
        StringCopy(mudconf.full_file, "text/full.txt");
        StringCopy(mudconf.site_file, "text/badsite.txt");
        StringCopy(mudconf.crea_file, "text/newuser.txt");
        StringCopy(mudconf.help_file, "text/help.txt");
        StringCopy(mudconf.help_indx, "text/help.indx");
        StringCopy(mudconf.news_file, "text/news.txt");
        StringCopy(mudconf.news_indx, "text/news.indx");
        StringCopy(mudconf.whelp_file, "text/wizhelp.txt");
        StringCopy(mudconf.whelp_indx, "text/wizhelp.indx");
        StringCopy(mudconf.plushelp_file, "text/plushelp.txt");
        StringCopy(mudconf.plushelp_indx, "text/plushelp.indx");
        StringCopy(mudconf.wiznews_file, "text/wiznews.txt");
        StringCopy(mudconf.wiznews_indx, "text/wiznews.indx");
        StringCopy(mudconf.motd_msg, "");
        StringCopy(mudconf.wizmotd_msg, "");
        StringCopy(mudconf.downmotd_msg, "");
        StringCopy(mudconf.fullmotd_msg, "");
        StringCopy(mudconf.dump_msg, "");
        StringCopy(mudconf.postdump_msg, "");
        StringCopy(mudconf.fixed_home_msg, "");
        StringCopy(mudconf.fixed_tel_msg, "");
        StringCopy(mudconf.public_channel, "Public");
        StringCopy(mudconf.guests_channel, "Guests");
        mudconf.indent_desc = 0;
        mudconf.name_spaces = 1;
        mudconf.fork_dump = 1;
        mudconf.fork_vfork = 0;
        mudconf.have_specials = 1;
        mudconf.have_comsys = 1;
        mudconf.have_macros = 1;
        mudconf.have_mailer = 1;
        mudconf.have_zones = 1;
        mudconf.paranoid_alloc = 0;
        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;
        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.use_http = 0;
        mudconf.queuemax = 100;
        mudconf.queue_chunk = 10;
        mudconf.active_q_chunk = 10;
        mudconf.sacfactor = 5;
        mudconf.sacadjust = -1;
        mudconf.use_hostname = 1;
        mudconf.quotas = 0;
        mudconf.ex_flags = 1;
        mudconf.robot_speak = 1;
        mudconf.clone_copy_cost = 0;
        mudconf.pub_flags = 1;
        mudconf.quiet_look = 1;
        mudconf.exam_public = 1;
        mudconf.read_rem_desc = 0;
        mudconf.read_rem_name = 0;
        mudconf.sweep_dark = 0;
        mudconf.player_listen = 0;
        mudconf.quiet_whisper = 1;
        mudconf.dark_sleepers = 1;
        mudconf.see_own_dark = 1;
        mudconf.idle_wiz_dark = 0;
        mudconf.pemit_players = 0;
        mudconf.pemit_any = 0;
        mudconf.match_mine = 0;
        mudconf.match_mine_pl = 0;
        mudconf.switch_df_all = 1;
        mudconf.fascist_tport = 0;
        mudconf.terse_look = 1;
        mudconf.terse_contents = 1;
        mudconf.terse_exits = 1;
        mudconf.terse_movemsg = 1;
        mudconf.trace_topdown = 1;
        mudconf.trace_limit = 200;
        mudconf.safe_unowned = 0;
        /*
         * -- ??? Running SC on a non-SC DB may cause problems
         */
        mudconf.space_compress = 1;
        mudconf.start_room = 0;
        mudconf.start_home = -1;
        mudconf.default_home = -1;
        mudconf.master_room = -1;
        mudconf.player_flags.word1 = 0;
        mudconf.player_flags.word2 = 0;
        mudconf.room_flags.word1 = 0;
        mudconf.room_flags.word2 = 0;
        mudconf.exit_flags.word1 = 0;
        mudconf.exit_flags.word2 = 0;
        mudconf.thing_flags.word1 = 0;
        mudconf.thing_flags.word2 = 0;
        mudconf.robot_flags.word1 = ROBOT;
        mudconf.robot_flags.word2 = 0;
        mudconf.vattr_flags = AF_ODARK;
        StringCopy(mudconf.mud_name, "TinyMUX");
        StringCopy(mudconf.one_coin, "penny");
        StringCopy(mudconf.many_coins, "pennies");
        mudconf.timeslice = 100;
        mudconf.cmd_quota_max = 100;
        mudconf.cmd_quota_incr = 5;
        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_PROBLEMS | LOG_PCREATES;
        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.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_trim = 0;
        mudconf.cache_depth = CACHE_DEPTH;
        mudconf.cache_width = CACHE_WIDTH;
        mudconf.cache_names = 1;

        mudstate.events_flag = 0;
        mudstate.events_lasthour = -1;
        mudstate.initializing = 0;
        mudstate.panicking = 0;
        mudstate.dumping = 0;
        mudstate.logging = 0;
        mudstate.epoch = 0;
        mudstate.generation = 0;
        mudstate.curr_player = NOTHING;
        mudstate.curr_enactor = NOTHING;
        mudstate.shutdown_flag = 0;
        mudstate.attr_next = A_USER_START;
        mudstate.debug_cmd = (char *) "< init >";
        StringCopy(mudstate.doing_hdr, "Doing");
        mudstate.access_list = NULL;
        mudstate.suspect_list = NULL;
        mudstate.qhead = NULL;
        mudstate.qtail = NULL;
        mudstate.qwait = NULL;
        mudstate.qsemfirst = NULL;
        mudstate.qsemlast = 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_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.mail_freelist = 0;
        mudstate.freelist = NOTHING;
        mudstate.markbits = NULL;
        mudstate.func_nest_lev = 0;
        mudstate.func_invk_ctr = 0;
        mudstate.ntfy_nest_lev = 0;
        mudstate.lock_nest_lev = 0;
        mudstate.zone_nest_num = 0;
        mudstate.inpipe = 0;
        mudstate.pout = NULL;
        mudstate.poutnew = NULL;
        mudstate.poutbufc = NULL;
        mudstate.poutobj = -1;
        for(i = 0; i < MAX_GLOBAL_REGS; i++)
                mudstate.global_regs[i] = NULL;
#ifdef SQL_SUPPORT
        memset(mudconf.sqlDB_type_A, '\0', 128);
        memset(mudconf.sqlDB_hostname_A, '\0', 128);
        memset(mudconf.sqlDB_username_A, '\0', 128);
        memset(mudconf.sqlDB_password_A, '\0', 128);
        memset(mudconf.sqlDB_dbname_A, '\0', 128);
        memset(mudconf.sqlDB_type_B, '\0', 128);
        memset(mudconf.sqlDB_hostname_B, '\0', 128);
        memset(mudconf.sqlDB_username_B, '\0', 128);
        memset(mudconf.sqlDB_password_B, '\0', 128);
        memset(mudconf.sqlDB_dbname_B, '\0', 128);
        memset(mudconf.sqlDB_type_C, '\0', 128);
        memset(mudconf.sqlDB_hostname_C, '\0', 128);
        memset(mudconf.sqlDB_username_C, '\0', 128);
        memset(mudconf.sqlDB_password_C, '\0', 128);
        memset(mudconf.sqlDB_dbname_C, '\0', 128);
        memset(mudconf.sqlDB_type_D, '\0', 128);
        memset(mudconf.sqlDB_hostname_D, '\0', 128);
        memset(mudconf.sqlDB_username_D, '\0', 128);
        memset(mudconf.sqlDB_password_D, '\0', 128);
        memset(mudconf.sqlDB_dbname_D, '\0', 128);
        memset(mudconf.sqlDB_type_E, '\0', 128);
        memset(mudconf.sqlDB_hostname_E, '\0', 128);
        memset(mudconf.sqlDB_username_E, '\0', 128);
        memset(mudconf.sqlDB_password_E, '\0', 128);
        memset(mudconf.sqlDB_dbname_E, '\0', 128);
        mudconf.sqlDB_init_A = 0;
        mudconf.sqlDB_init_B = 0;
        mudconf.sqlDB_init_C = 0;
        mudconf.sqlDB_init_D = 0;
        mudconf.sqlDB_init_E = 0;
        mudconf.sqlDB_max_queries = 4;
        memset(mudconf.sqlDB_mysql_socket, '\0', 128);
#endif
        mudconf.exit_parent = 0;
        mudconf.room_parent = 0;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_log_notfound: Log a 'parameter not found' error.
 */
void cf_log_notfound(dbref player, char *cmd, const char *thingname,
                                         char *thing)
{
        char *buff;

        if(mudstate.initializing) {
        log_error(LOG_STARTUP, "CNF", "NFND", "%s: %s %s not found.", cmd,
            thingname, thing);
        } else {
                buff = alloc_lbuf("cf_log_notfound");
                sprintf(buff, "%s %s not found", thingname, thing);
                notify(player, buff);
                free_lbuf(buff);
        }
}

/*
 * ---------------------------------------------------------------------------
 * * cf_log_syntax: Log a syntax error.
 */

void cf_log_syntax(dbref player, char *cmd, const char *template, char *arg)
{
        if(mudstate.initializing) {
        log_error(LOG_STARTUP, "CNF", "SYNTX", "%s: %s %s", cmd, template, arg);
        } else {
        notify_printf(player, template, arg);
        }
}

/*
 * ---------------------------------------------------------------------------
 * * cf_status_from_succfail: Return command status from succ and fail info
 */

int cf_status_from_succfail(dbref player, char *cmd, int success, int failure)
{
        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.initializing) {
            log_error(LOG_STARTUP, "CNF", "NDATA", "%s: Nothing to set", cmd);
                } else {
                        notify(player, "Nothing to set");
                }
        }
        return -1;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_int: Set integer parameter.
 */

int cf_int(int *vp, char *str, long extra, dbref player, char *cmd)
{
        /*
         * Copy the numeric value to the parameter
         */

        sscanf(str, "%d", vp);
        return 0;
}
/* *INDENT-OFF* */

/* ---------------------------------------------------------------------------
 * cf_bool: Set boolean parameter.
 */

NAMETAB bool_names[] = {
    {(char *)"true",    1,      0,      1},
    {(char *)"false",   1,      0,      0},
    {(char *)"yes",             1,      0,      1},
    {(char *)"no",              1,      0,      0},
    {(char *)"1",               1,      0,      1},
    {(char *)"0",               1,      0,      0},
    {NULL,                      0,      0,      0}};

/* *INDENT-ON* */

int cf_bool(int *vp, char *str, long extra, dbref player, char *cmd)
{
        *vp = (int) search_nametab(GOD, bool_names, str);
        if(*vp < 0)
                *vp = (long) 0;
        return 0;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_option: Select one option from many choices.
 */

int cf_option(int *vp, char *str, long extra, dbref player, char *cmd)
{
        int i;

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

/*
 * ---------------------------------------------------------------------------
 * * cf_string: Set string parameter.
 */

int cf_string(int *vp, char *str, long extra, dbref player, char *cmd)
{
        int retval;
        char *buff;

        /*
         * Copy the string to the buffer if it is not too big
         */

        retval = 0;
        if(strlen(str) >= extra) {
                str[extra - 1] = '\0';
                if(mudstate.initializing) {
            log_error(LOG_STARTUP, "CNF", "NFND", "%s: String truncated", cmd);
                } else {
                        notify(player, "String truncated");
                }
                retval = 1;
        }
        StringCopy((char *) vp, str);
        return retval;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_alias: define a generic hash table alias.
 */

int cf_alias(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *alias, *orig, *p;
        int *cp = NULL;

        alias = strtok(str, " \t=,");
        orig = strtok(NULL, " \t=,");
        if(orig) {
                for(p = orig; *p; p++)
                        *p = ToLower(*p);
                cp = hashfind(orig, (HASHTAB *) vp);
                if(cp == NULL) {
                        for(p = orig; *p; p++)
                                *p = ToUpper(*p);
                        cp = hashfind(orig, (HASHTAB *) vp);
                        if(cp == NULL) {
                                cf_log_notfound(player, cmd, "Entry", orig);
                                return -1;
                        }
                }
        }

        if(cp == NULL) {
                return -1;
        }

        hashadd(alias, cp, (HASHTAB *) vp);
        return 0;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_flagalias: define a flag alias.
 */

int cf_flagalias(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *alias, *orig;
        int *cp, success;

        success = 0;
        alias = strtok(str, " \t=,");
        orig = strtok(NULL, " \t=,");

        cp = hashfind(orig, &mudstate.flags_htab);
        if(cp != NULL) {
                hashadd(alias, cp, &mudstate.flags_htab);
                success++;
        }
        if(!success)
                cf_log_notfound(player, cmd, "Flag", orig);
        return ((success > 0) ? 0 : -1);
}

/*
 * ---------------------------------------------------------------------------
 * * cf_or_in_bits: OR in bits from namelist to a word.
 */

int cf_or_in_bits(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *sp;
        int f, success, failure;

        /*
         * Walk through the tokens
         */

        success = failure = 0;
        sp = strtok(str, " \t");
        while (sp != NULL) {

                /*
                 * Set the appropriate bit
                 */

                f = search_nametab(GOD, (NAMETAB *) extra, sp);
                if(f > 0) {
                        *vp |= f;
                        success++;
                } else {
                        cf_log_notfound(player, cmd, "Entry", sp);
                        failure++;
                }

                /*
                 * Get the next token
                 */

                sp = strtok(NULL, " \t");
        }
        return cf_status_from_succfail(player, cmd, success, failure);
}

/*
 * ---------------------------------------------------------------------------
 * * cf_modify_bits: set or clear bits in a flag word from a namelist.
 */
int cf_modify_bits(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *sp;
        int f, negate, success, failure;

        /*
         * Walk through the tokens
         */

        success = failure = 0;
        sp = strtok(str, " \t");
        while (sp != NULL) {

                /*
                 * Check for negation
                 */

                negate = 0;
                if(*sp == '!') {
                        negate = 1;
                        sp++;
                }
                /*
                 * Set or clear the appropriate bit
                 */

                f = search_nametab(GOD, (NAMETAB *) extra, sp);
                if(f > 0) {
                        if(negate)
                                *vp &= ~f;
                        else
                                *vp |= f;
                        success++;
                } else {
                        cf_log_notfound(player, cmd, "Entry", sp);
                        failure++;
                }

                /*
                 * Get the next token
                 */

                sp = strtok(NULL, " \t");
        }
        return cf_status_from_succfail(player, cmd, success, failure);
}

/*
 * ---------------------------------------------------------------------------
 * * cf_set_bits: Clear flag word and then set specified bits from namelist.
 */

int cf_set_bits(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *sp;
        int f, success, failure;

        /*
         * Walk through the tokens
         */

        success = failure = 0;
        *vp = 0;
        sp = strtok(str, " \t");
        while (sp != NULL) {

                /*
                 * Set the appropriate bit
                 */

                f = search_nametab(GOD, (NAMETAB *) extra, sp);
                if(f > 0) {
                        *vp |= f;
                        success++;
                } else {
                        cf_log_notfound(player, cmd, "Entry", sp);
                        failure++;
                }

                /*
                 * Get the next token
                 */

                sp = strtok(NULL, " \t");
        }
        return cf_status_from_succfail(player, cmd, success, failure);
}

/*
 * ---------------------------------------------------------------------------
 * * cf_set_flags: Clear flag word and then set from a flags htab.
 */

int cf_set_flags(int *vp, char *str, long extra, dbref player, char *cmd)
{
        char *sp;
        FLAGENT *fp;
        FLAGSET *fset;

        int success, failure;

        /*
         * Walk through the tokens
         */

        success = failure = 0;
        sp = strtok(str, " \t");
        fset = (FLAGSET *) vp;

        while (sp != NULL) {

                /*
                 * Set the appropriate bit
                 */

                fp = (FLAGENT *) hashfind(sp, &mudstate.flags_htab);
                if(fp != NULL) {
                        if(success == 0) {
                                (*fset).word1 = 0;
                                (*fset).word2 = 0;
                        }
                        if(fp->flagflag & FLAG_WORD3)
                                (*fset).word3 |= fp->flagvalue;
                        else if(fp->flagflag & FLAG_WORD2)
                                (*fset).word2 |= fp->flagvalue;
                        else
                                (*fset).word1 |= fp->flagvalue;
                        success++;
                } else {
                        cf_log_notfound(player, cmd, "Entry", sp);
                        failure++;
                }

                /*
                 * Get the next token
                 */

                sp = strtok(NULL, " \t");
        }
        if((success == 0) && (failure == 0)) {
                (*fset).word1 = 0;
                (*fset).word2 = 0;
                return 0;
        }
        if(success > 0)
                return ((failure == 0) ? 0 : 1);
        return -1;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_badname: Disallow use of player name/alias.
 */

int cf_badname(int *vp, char *str, long extra, dbref player, char *cmd)
{
        if(extra)
                badname_remove(str);
        else
                badname_add(str);
        return 0;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_site: Update site information
 */

int cf_site(long **vp, char *str, long extra, dbref player, char *cmd)
{
        SITE *site, *last, *head;
        char *addr_txt, *mask_txt;
        struct in_addr addr_num, mask_num;

        addr_txt = strtok(str, " \t=,");
        mask_txt = NULL;
        if(addr_txt)
                mask_txt = strtok(NULL, " \t=,");
        if(!addr_txt || !*addr_txt || !mask_txt || !*mask_txt) {
                cf_log_syntax(player, cmd, "Missing host address or mask.", (char *) "");
                return -1;
        }

        addr_num.s_addr = inet_addr(addr_txt);
        mask_num.s_addr = inet_addr(mask_txt);

        if(addr_num.s_addr == -1) {
                cf_log_syntax(player, cmd, "Bad host address: ", addr_txt);
                return -1;
        }
        head = (SITE *) * vp;
        /*
         * Parse the access entry and allocate space for it
         */

        site = (SITE *) malloc(sizeof(SITE));

        /*
         * Initialize the site entry
         */

        site->address.s_addr = addr_num.s_addr;
        site->mask.s_addr = mask_num.s_addr;
        site->flag = extra;
        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.initializing) {
                if(head == NULL) {
                        *vp = (long *) site;
                } else {
                        for(last = head; last->next; last = last->next);
                        last->next = site;
                }
        } else {
                site->next = head;
                *vp = (long *) site;
        }
        return 0;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_cf_access: Set access on config directives
 */

int cf_cf_access(int *vp, char *str, long extra, dbref player, char *cmd)
{
        CONF *tp;
        char *ap;

        for(ap = str; *ap && !isspace(*ap); ap++);
        if(*ap)
                *ap++ = '\0';

        for(tp = conftable; tp->pname; tp++) {
                if(!strcmp(tp->pname, str)) {
                        return (cf_modify_bits(&tp->flags, ap, extra, player, cmd));
                }
        }
        cf_log_notfound(player, cmd, "Config directive", str);
        return -1;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_include: Read another config file.  Only valid during startup.
 */

int cf_include(int *vp, char *str, long extra, dbref player, char *cmd)
{
        FILE *fp;
        char *cp, *ap, *zp, *buf;

        extern int cf_set(char *, char *, dbref);

        if(!mudstate.initializing)
                return -1;

        fp = fopen(str, "r");
        if(fp == NULL) {
                cf_log_notfound(player, cmd, "Config file", str);
                return -1;
        }
        buf = alloc_lbuf("cf_include");
        while (1) {
                if(!fgets(buf, LBUF_SIZE, fp))
                        break;
                cp = buf;
                if(!cp || !*cp || *cp == '#' || *cp == '\n')
                        continue;

                /*
                 * Not a comment line or an empty one. Strip off the NL and any
                 * characters following it. Then, split the line into the command
                 * and argument portions (separated by a space). Also, trim off the
                 * trailing comment, if any (delimited by #)
                 */

                for(cp = buf; *cp && *cp != '\n'; cp++);
                *cp = '\0';                             /* strip \n */

                for(cp = buf; *cp && isspace(*cp); cp++);       /* strip spaces */
                if(*cp == '\0')                 /* skip line if nothing left */
                        continue;

                for(ap = cp; *ap && !isspace(*ap); ap++);       /* skip over command */
                if(*ap)
                        *ap++ = '\0';           /* trim command */

                for(; *ap && isspace(*ap); ap++);       /* skip spaces */

                for(zp = ap; *zp && (*zp != '#'); zp++);        /* find comment */

                if(*zp)
                        *zp = '\0';                     /* zap comment */

                for(zp = zp - 1; zp >= ap && isspace(*zp); zp--)
                        *zp = '\0';                     /* zap trailing spaces */

                cf_set(cp, ap, player);
        }
        if(ferror(fp))
                fprintf(stderr, "Error reading config file: %s\n", strerror(errno));
        free_lbuf(buf);
        fclose(fp);
        return 0;
}

extern int cf_access(long *, char *, long, dbref, char *);
extern int cf_cmd_alias(long *, char *, long, dbref, char *);
extern int cf_acmd_access(long *, char *, long, dbref, char *);
extern int cf_attr_access(long *, char *, long, dbref, char *);
extern int cf_func_access(long *, char *, long, dbref, char *);

/* ---------------------------------------------------------------------------
 * conftable: Table for parsing the configuration file.
 */

CONF conftable[] = {
        {(char *) "access",
         cf_access, CA_GOD, NULL,
         (long) access_nametab},
        {(char *) "alias",
         cf_cmd_alias, CA_GOD, (int *) &mudstate.command_htab, 0},
        {(char *) "allow_unloggedwho",
         cf_int, CA_GOD, &mudconf.allow_unloggedwho, 0},
        {(char *) "attr_access",
         cf_attr_access, CA_GOD, NULL,
         (long) attraccess_nametab},
        {(char *) "attr_alias",
         cf_alias, CA_GOD, (int *) &mudstate.attr_name_htab, 0},
        {(char *) "attr_cmd_access",
         cf_acmd_access, CA_GOD, NULL,
         (long) access_nametab},
        {(char *) "bad_name",
         cf_badname, CA_GOD, NULL, 0},
        {(char *) "badsite_file",
         cf_string, CA_DISABLED, (void *) mudconf.site_file, 32},
        {(char *) "btech_explode_reactor",
         cf_int, CA_GOD, &mudconf.btech_explode_reactor, 0},
        {(char *) "btech_explode_time",
         cf_int, CA_GOD, &mudconf.btech_explode_time, 0},
        {(char *) "btech_explode_ammo",
         cf_int, CA_GOD, &mudconf.btech_explode_ammo, 0},
        {(char *) "btech_explode_stop",
         cf_int, CA_GOD, &mudconf.btech_explode_stop, 0},
        {(char *) "btech_failures",
         cf_int, CA_GOD, &mudconf.btech_parts, 0},
        {(char *) "btech_ic",
         cf_int, CA_GOD, &mudconf.btech_ic, 0},
        {(char *) "btech_afterlife_dbref",
         cf_int, CA_GOD, &mudconf.afterlife_dbref, 0},
        {(char *) "btech_afterscen_dbref",
         cf_int, CA_GOD, &mudconf.afterscen_dbref, 0},
        {(char *) "btech_vcrit",
         cf_int, CA_GOD, &mudconf.btech_vcrit, 0},
        {(char *) "btech_dynspeed",
         cf_int, CA_GOD, &mudconf.btech_dynspeed, 0},
        {(char *) "btech_slowdown",
         cf_int, CA_GOD, &mudconf.btech_slowdown, 0},
        {(char *) "btech_fasaturn",
         cf_int, CA_GOD, &mudconf.btech_fasaturn, 0},
        {(char *) "btech_fasacrit",
         cf_int, CA_GOD, &mudconf.btech_fasacrit, 0},
        {(char *) "btech_fasaadvvtolcrit",
         cf_int, CA_GOD, &mudconf.btech_fasaadvvtolcrit, 0},
        {(char *) "btech_fasaadvvhlcrit",
         cf_int, CA_GOD, &mudconf.btech_fasaadvvhlcrit, 0},
        {(char *) "btech_fasaadvvhlfire",
         cf_int, CA_GOD, &mudconf.btech_fasaadvvhlfire, 0},
        {(char *) "btech_divrotordamage",
         cf_int, CA_GOD, &mudconf.btech_divrotordamage, 0},
        {(char *) "btech_moddamagewithrange",
         cf_int, CA_GOD, &mudconf.btech_moddamagewithrange, 0},
        {(char *) "btech_moddamagewithwoods",
         cf_int, CA_GOD, &mudconf.btech_moddamagewithwoods, 0},
        {(char *) "btech_hotloadaddshalfbthmod",
         cf_int, CA_GOD, &mudconf.btech_hotloadaddshalfbthmod, 0},
        {(char *) "btech_nofusionvtolfuel",
         cf_int, CA_GOD, &mudconf.btech_nofusionvtolfuel, 0},
        {(char *) "btech_tankfriendly",
         cf_int, CA_GOD, &mudconf.btech_tankfriendly, 0},
        {(char *) "btech_newcharge",
         cf_int, CA_GOD, &mudconf.btech_newcharge, 0},
        {(char *) "btech_tl3_charge",
         cf_int, CA_GOD, &mudconf.btech_tl3_charge, 0},
        {(char *) "btech_newterrain",
         cf_int, CA_GOD, &mudconf.btech_newterrain, 0},
        {(char *) "btech_xploss",
         cf_int, CA_GOD, &mudconf.btech_xploss, 0},
        {(char *) "btech_critlevel",
         cf_int, CA_GOD, &mudconf.btech_critlevel, 0},
        {(char *) "btech_tankshield",
         cf_int, CA_GOD, &mudconf.btech_tankshield, 0},
        {(char *) "btech_newstagger",
         cf_int, CA_GOD, &mudconf.btech_newstagger, 0},
        {(char *) "namechange_days",
         cf_int, CA_GOD, &mudconf.namechange_days, 0},
        {(char *) "allow_chanlurking",
         cf_int, CA_GOD, &mudconf.allow_chanlurking, 0},
        {(char *) "btech_skidcliff",
         cf_int, CA_GOD, &mudconf.btech_skidcliff, 0},
        {(char *) "btech_xp_bthmod",
         cf_int, CA_GOD, &mudconf.btech_xp_bthmod, 0},
        {(char *) "btech_xp_missilemod",
         cf_int, CA_GOD, &mudconf.btech_xp_missilemod, 0},
        {(char *) "btech_xp_ammomod",
         cf_int, CA_GOD, &mudconf.btech_xp_ammomod, 0},
        {(char *) "btech_defaultweapdam",
         cf_int, CA_GOD, &mudconf.btech_defaultweapdam, 0},
        {(char *) "btech_xp_modifier",
         cf_int, CA_GOD, &mudconf.btech_xp_modifier, 0},
        {(char *) "btech_defaultweapbv",
         cf_int, CA_GOD, &mudconf.btech_defaultweapbv, 0},
        {(char *) "btech_xp_usePilotBVMod",
         cf_int, CA_GOD, &mudconf.btech_xp_usePilotBVMod, 0},
        {(char *) "btech_oldxpsystem",
         cf_int, CA_GOD, &mudconf.btech_oldxpsystem, 0},
        {(char *) "btech_xp_vrtmod",
         cf_int, CA_GOD, &mudconf.btech_xp_vrtmod, 0},
        {(char *) "btech_extendedmovemod",
         cf_int, CA_GOD, &mudconf.btech_extendedmovemod, 0},
        {(char *) "btech_stacking",
         cf_int, CA_GOD, &mudconf.btech_stacking, 0},
        {(char *) "btech_stackdamage",
         cf_int, CA_GOD, &mudconf.btech_stackdamage, 0},
        {(char *) "btech_mw_losmap",
         cf_int, CA_GOD, &mudconf.btech_mw_losmap, 0},
        {(char *) "btech_exile_stun_code",
         cf_int, CA_GOD, &mudconf.btech_exile_stun_code, 0},
        {(char *) "btech_roll_on_backwalk",
         cf_int, CA_GOD, &mudconf.btech_roll_on_backwalk, 0},
        {(char *) "btech_usedmechstore",
         cf_int, CA_GOD, &mudconf.btech_usedmechstore, 0},
        {(char *) "btech_ooc_comsys",
         cf_int, CA_GOD, &mudconf.btech_ooc_comsys, 0},
        {(char *) "btech_idf_requires_spotter",
         cf_int, CA_GOD, &mudconf.btech_idf_requires_spotter, 0},
        {(char *) "btech_perunit_xpmod",
         cf_int, CA_GOD, &mudconf.btech_perunit_xpmod, 0},
        {(char *) "btech_vtol_ice_causes_fire",
        cf_int, CA_GOD, &mudconf.btech_vtol_ice_causes_fire, 0},
        {(char *) "btech_glancing_blows", cf_int, CA_GOD, &mudconf.btech_glancing_blows, 0},
        {(char *) "btech_inferno_penalty",
         cf_int, CA_GOD, &mudconf.btech_inferno_penalty, 0},
#ifdef BT_FREETECHTIME
        {(char *) "btech_freetechtime",
         cf_int, CA_GOD, &mudconf.btech_freetechtime, 0},
#endif
#ifdef BT_COMPLEXREPAIRS
        {(char *) "btech_complexrepair",
         cf_int, CA_GOD, &mudconf.btech_complexrepair, 0},
#endif
#ifdef HUDINFO_SUPPORT
        {(char *) "hudinfo_show_mapinfo",
         cf_int, CA_GOD, &mudconf.hudinfo_show_mapinfo, 0},
        {(char *) "hudinfo_enabled",
         cf_int, CA_GOD, &mudconf.hudinfo_enabled, 0},
#endif
        {(char *) "btech_seismic_see_stopped",
         cf_int, CA_GOD, &mudconf.btech_seismic_see_stopped, 0},
        {(char *) "btech_limitedrepairs",
         cf_int, CA_GOD, &mudconf.btech_limitedrepairs, 0},
        {(char *) "btech_stackpole",
         cf_int, CA_GOD, &mudconf.btech_stackpole, 0},
        {(char *) "btech_phys_use_pskill",
         cf_int, CA_GOD, &mudconf.btech_phys_use_pskill, 0},
        {(char *) "btech_erange",
         cf_int, CA_GOD, &mudconf.btech_erange, 0},
        {(char *) "btech_dig_only_fs",
         cf_int, CA_GOD, &mudconf.btech_dig_only_fs, 0},
        {(char *) "btech_digbonus",
         cf_int, CA_GOD, &mudconf.btech_digbonus, 0},
        {(char *) "cache_depth",
         cf_int, CA_DISABLED, &mudconf.cache_depth, 0},
        {(char *) "cache_names",
         cf_bool, CA_DISABLED, &mudconf.cache_names, 0},
        {(char *) "cache_trim",
         cf_bool, CA_GOD, &mudconf.cache_trim, 0},
        {(char *) "cache_width",
         cf_int, CA_DISABLED, &mudconf.cache_width, 0},
        {(char *) "check_interval",
         cf_int, CA_GOD, &mudconf.check_interval, 0},
        {(char *) "check_offset",
         cf_int, CA_GOD, &mudconf.check_offset, 0},
        {(char *) "clone_copies_cost",
         cf_bool, CA_GOD, &mudconf.clone_copy_cost, 0},
        {(char *) "commac_database",
         cf_string, CA_GOD, (void *) mudconf.commac_db, 128},
        {(char *) "command_quota_increment",
         cf_int, CA_GOD, &mudconf.cmd_quota_incr, 0},
        {(char *) "command_quota_max",
         cf_int, CA_GOD, &mudconf.cmd_quota_max, 0},
        {(char *) "compress_program",
         cf_string, CA_DISABLED, (void *) mudconf.compress, 128},
        {(char *) "compression",
         cf_bool, CA_GOD, &mudconf.compress_db, 0},
        {(char *) "concentrator_port",
         cf_int, CA_DISABLED, &mudconf.conc_port, 0},
        {(char *) "config_access",
         cf_cf_access, CA_GOD, NULL,
         (long) access_nametab},
        {(char *) "conn_timeout",
         cf_int, CA_GOD, &mudconf.conn_timeout, 0},
        {(char *) "connect_dir",
         cf_string, CA_DISABLED, (void *) mudconf.conn_dir, 32},
        {(char *) "connect_file",
         cf_string, CA_DISABLED, (void *) mudconf.conn_file, 32},
        {(char *) "connect_reg_file",
         cf_string, CA_DISABLED, (void *) mudconf.creg_file, 32},
        {(char *) "crash_database",
         cf_string, CA_DISABLED, (void *) mudconf.crashdb, 128},
        {(char *) "create_max_cost",
         cf_int, CA_GOD, &mudconf.createmax, 0},
        {(char *) "create_min_cost",
         cf_int, CA_GOD, &mudconf.createmin, 0},
        {(char *) "dark_sleepers",
         cf_bool, CA_GOD, &mudconf.dark_sleepers, 0},
        {(char *) "default_home",
         cf_int, CA_GOD, &mudconf.default_home, 0},
        {(char *) "dig_cost",
         cf_int, CA_GOD, &mudconf.digcost, 0},
        {(char *) "down_file",
         cf_string, CA_DISABLED, (void *) mudconf.down_file, 32},
        {(char *) "down_motd_message",
         cf_string, CA_GOD, (void *) mudconf.downmotd_msg, 4096},
        {(char *) "dump_interval",
         cf_int, CA_GOD, &mudconf.dump_interval, 0},
        {(char *) "dump_message",
         cf_string, CA_GOD, (void *) mudconf.dump_msg, 128},
        {(char *) "postdump_message",
         cf_string, CA_GOD, (void *) mudconf.postdump_msg, 128},
        {(char *) "dump_offset",
         cf_int, CA_GOD, &mudconf.dump_offset, 0},
        {(char *) "earn_limit",
         cf_int, CA_GOD, &mudconf.paylimit, 0},
        {(char *) "examine_flags",
         cf_bool, CA_GOD, &mudconf.ex_flags, 0},
        {(char *) "examine_public_attrs",
         cf_bool, CA_GOD, &mudconf.exam_public, 0},
        {(char *) "exit_flags",
         cf_set_flags, CA_GOD, (int *) &mudconf.exit_flags, 0},
        {(char *) "exit_quota",
         cf_int, CA_GOD, &mudconf.exit_quota, 0},
        {(char *) "events_daily_hour",
         cf_int, CA_GOD, &mudconf.events_daily_hour, 0},
        {(char *) "fascist_teleport",
         cf_bool, CA_GOD, &mudconf.fascist_tport, 0},
        {(char *) "fixed_home_message",
         cf_string, CA_DISABLED, (void *) mudconf.fixed_home_msg, 128},
        {(char *) "fixed_tel_message",
         cf_string, CA_DISABLED, (void *) mudconf.fixed_tel_msg, 128},
        {(char *) "find_money_chance",
         cf_int, CA_GOD, &mudconf.payfind, 0},
        {(char *) "flag_alias",
         cf_flagalias, CA_GOD, NULL, 0},
        {(char *) "forbid_site",
         cf_site, CA_GOD, (int *) &mudstate.access_list,
         H_FORBIDDEN},
        {(char *) "fork_dump",
         cf_bool, CA_GOD, &mudconf.fork_dump, 0},
        {(char *) "fork_vfork",
         cf_bool, CA_GOD, &mudconf.fork_vfork, 0},
        {(char *) "full_file",
         cf_string, CA_DISABLED, (void *) mudconf.full_file, 32},
        {(char *) "full_motd_message",
         cf_string, CA_GOD, (void *) mudconf.fullmotd_msg, 4096},
        {(char *) "function_access",
         cf_func_access, CA_GOD, NULL,
         (long) access_nametab},
        {(char *) "function_alias",
         cf_alias, CA_GOD, (int *) &mudstate.func_htab, 0},
        {(char *) "function_invocation_limit",
         cf_int, CA_GOD, &mudconf.func_invk_lim, 0},
        {(char *) "function_recursion_limit",
         cf_int, CA_GOD, &mudconf.func_nest_lim, 0},
        {(char *) "gdbm_database",
         cf_string, CA_DISABLED, (void *) mudconf.gdbm, 128},
        {(char *) "good_name",
         cf_badname, CA_GOD, NULL, 1},
        {(char *) "guest_char_num",
         cf_int, CA_DISABLED, &mudconf.guest_char, 0},
        {(char *) "guest_nuker",
         cf_int, CA_GOD, &mudconf.guest_nuker, 0},
        {(char *) "guest_prefix",
         cf_string, CA_DISABLED, (void *) mudconf.guest_prefix, 32},
        {(char *) "number_guests",
         cf_int, CA_DISABLED, &mudconf.number_guests, 0},
        {(char *) "guest_file",
         cf_string, CA_DISABLED, (void *) mudconf.guest_file, 32},
        {(char *) "guests_channel",
         cf_string, CA_DISABLED, (void *) mudconf.guests_channel, 32},
        {(char *) "have_specials",
         cf_bool, CA_DISABLED, &mudconf.have_specials, 0},
        {(char *) "have_comsys",
         cf_bool, CA_DISABLED, &mudconf.have_comsys, 0},
        {(char *) "have_macros",
         cf_bool, CA_DISABLED, &mudconf.have_macros, 0},
        {(char *) "have_mailer",
         cf_bool, CA_DISABLED, &mudconf.have_mailer, 0},
        {(char *) "have_zones",
         cf_bool, CA_DISABLED, &mudconf.have_zones, 0},
        {(char *) "hcode_database",
         cf_string, CA_GOD, (void *) mudconf.hcode_db, 128},
#ifdef BT_ADVANCED_ECON
        {(char *) "econ_database",
         cf_string, CA_GOD, (void *) mudconf.econ_db, 128},
#endif
        {(char *) "help_file",
         cf_string, CA_DISABLED, (void *) mudconf.help_file, 32},
        {(char *) "help_index",
         cf_string, CA_DISABLED, (void *) mudconf.help_indx, 32},
        {(char *) "hostnames",
         cf_bool, CA_GOD, &mudconf.use_hostname, 0},
        {(char *) "use_http",
         cf_bool, CA_DISABLED, &mudconf.use_http, 0},
        {(char *) "idle_wiz_dark",
         cf_bool, CA_GOD, &mudconf.idle_wiz_dark, 0},
        {(char *) "idle_interval",
         cf_int, CA_GOD, &mudconf.idle_interval, 0},
        {(char *) "idle_timeout",
         cf_int, CA_GOD, &mudconf.idle_timeout, 0},
        {(char *) "include",
         cf_include, CA_DISABLED, NULL, 0},
        {(char *) "indent_desc",
         cf_bool, CA_GOD, &mudconf.indent_desc, 0},
        {(char *) "initial_size",
         cf_int, CA_DISABLED, &mudconf.init_size, 0},
        {(char *) "input_database",
         cf_string, CA_DISABLED, (void *) mudconf.indb, 128},
        {(char *) "kill_guarantee_cost",
         cf_int, CA_GOD, &mudconf.killguarantee, 0},
        {(char *) "kill_max_cost",
         cf_int, CA_GOD, &mudconf.killmax, 0},
        {(char *) "kill_min_cost",
         cf_int, CA_GOD, &mudconf.killmin, 0},
        {(char *) "link_cost",
         cf_int, CA_GOD, &mudconf.linkcost, 0},
        {(char *) "list_access",
         cf_ntab_access, CA_GOD, (int *) list_names,
         (long) access_nametab},
        {(char *) "lock_recursion_limit",
         cf_int, CA_WIZARD, &mudconf.lock_nest_lim, 0},
        {(char *) "log",
         cf_modify_bits, CA_GOD, &mudconf.log_options,
         (long) logoptions_nametab},
        {(char *) "log_options",
         cf_modify_bits, CA_GOD, &mudconf.log_info,
         (long) logdata_nametab},
        {(char *) "logout_cmd_access",
         cf_ntab_access, CA_GOD, (int *) logout_cmdtable,
         (long) access_nametab},
        {(char *) "logout_cmd_alias",
         cf_alias, CA_GOD, (int *) &mudstate.logout_cmd_htab, 0},
        {(char *) "look_obey_terse",
         cf_bool, CA_GOD, &mudconf.terse_look, 0},
        {(char *) "machine_command_cost",
         cf_int, CA_GOD, &mudconf.machinecost, 0},
        {(char *) "mail_database",
         cf_string, CA_GOD, (void *) mudconf.mail_db, 128},
        {(char *) "mail_expiration",
         cf_int, CA_GOD, &mudconf.mail_expiration, 0},
        {(char *) "map_database",
         cf_string, CA_GOD, (void *) mudconf.map_db, 128},
        {(char *) "master_room",
         cf_int, CA_GOD, &mudconf.master_room, 0},
        {(char *) "match_own_commands",
         cf_bool, CA_GOD, &mudconf.match_mine, 0},
        {(char *) "max_players",
         cf_int, CA_GOD, &mudconf.max_players, 0},
        {(char *) "mech_database",
         cf_string, CA_GOD, (void *) mudconf.mech_db, 128},
        {(char *) "money_name_plural",
         cf_string, CA_GOD, (void *) mudconf.many_coins, 32},
        {(char *) "money_name_singular",
         cf_string, CA_GOD, (void *) mudconf.one_coin, 32},
        {(char *) "motd_file",
         cf_string, CA_DISABLED, (void *) mudconf.motd_file, 32},
        {(char *) "motd_message",
         cf_string, CA_GOD, (void *) mudconf.motd_msg, 4096},
        {(char *) "mud_name",
         cf_string, CA_GOD, (void *) mudconf.mud_name, 32},
        {(char *) "news_file",
         cf_string, CA_DISABLED, (void *) mudconf.news_file, 32},
        {(char *) "news_index",
         cf_string, CA_DISABLED, (void *) mudconf.news_indx, 32},
        {(char *) "newuser_file",
         cf_string, CA_DISABLED, (void *) mudconf.crea_file, 32},
        {(char *) "notify_recursion_limit",
         cf_int, CA_GOD, &mudconf.ntfy_nest_lim, 0},
        {(char *) "open_cost",
         cf_int, CA_GOD, &mudconf.opencost, 0},
        {(char *) "output_database",
         cf_string, CA_DISABLED, (void *) mudconf.outdb, 128},
        {(char *) "output_limit",
         cf_int, CA_GOD, &mudconf.output_limit, 0},
        {(char *) "page_cost",
         cf_int, CA_GOD, &mudconf.pagecost, 0},
        {(char *) "paranoid_allocate",
         cf_bool, CA_GOD, &mudconf.paranoid_alloc, 0},
        {(char *) "parent_recursion_limit",
         cf_int, CA_GOD, &mudconf.parent_nest_lim, 0},
        {(char *) "paycheck",
         cf_int, CA_GOD, &mudconf.paycheck, 0},
        {(char *) "pemit_far_players",
         cf_bool, CA_GOD, &mudconf.pemit_players, 0},
        {(char *) "pemit_any_object",
         cf_bool, CA_GOD, &mudconf.pemit_any, 0},
        {(char *) "permit_site",
         cf_site, CA_GOD, (int *) &mudstate.access_list, 0},
        {(char *) "player_flags",
         cf_set_flags, CA_GOD, (int *) &mudconf.player_flags, 0},
        {(char *) "player_listen",
         cf_bool, CA_GOD, &mudconf.player_listen, 0},
        {(char *) "player_match_own_commands",
         cf_bool, CA_GOD, &mudconf.match_mine_pl, 0},
        {(char *) "player_name_spaces",
         cf_bool, CA_GOD, &mudconf.name_spaces, 0},
        {(char *) "player_queue_limit",
         cf_int, CA_GOD, &mudconf.queuemax, 0},
        {(char *) "player_quota",
         cf_int, CA_GOD, &mudconf.player_quota, 0},
        {(char *) "player_starting_home",
         cf_int, CA_GOD, &mudconf.start_home, 0},
        {(char *) "player_starting_room",
         cf_int, CA_GOD, &mudconf.start_room, 0},
        {(char *) "plushelp_file",
         cf_string, CA_DISABLED, (void *) mudconf.plushelp_file, 32},
        {(char *) "plushelp_index",
         cf_string, CA_DISABLED, (void *) mudconf.plushelp_indx, 32},
        {(char *) "public_channel",
         cf_string, CA_DISABLED, (void *) mudconf.public_channel, 32},
        {(char *) "wiznews_file",
         cf_string, CA_DISABLED, (void *) mudconf.wiznews_file, 32},
        {(char *) "wiznews_index",
         cf_string, CA_DISABLED, (void *) mudconf.wiznews_indx, 32},
        {(char *) "port",
         cf_int, CA_DISABLED, &mudconf.port, 0},
        {(char *) "public_flags",
         cf_bool, CA_GOD, &mudconf.pub_flags, 0},
        {(char *) "queue_active_chunk",
         cf_int, CA_GOD, &mudconf.active_q_chunk, 0},
        {(char *) "queue_idle_chunk",
         cf_int, CA_GOD, &mudconf.queue_chunk, 0},
        {(char *) "quiet_look",
         cf_bool, CA_GOD, &mudconf.quiet_look, 0},
        {(char *) "quiet_whisper",
         cf_bool, CA_GOD, &mudconf.quiet_whisper, 0},
        {(char *) "quit_file",
         cf_string, CA_DISABLED, (void *) mudconf.quit_file, 32},
        {(char *) "quotas",
         cf_bool, CA_GOD, &mudconf.quotas, 0},
        {(char *) "read_remote_desc",
         cf_bool, CA_GOD, &mudconf.read_rem_desc, 0},
        {(char *) "read_remote_name",
         cf_bool, CA_GOD, &mudconf.read_rem_name, 0},
        {(char *) "register_create_file",
         cf_string, CA_DISABLED, (void *) mudconf.regf_file, 32},
        {(char *) "register_site",
         cf_site, CA_GOD, (int *) &mudstate.access_list,
         H_REGISTRATION},
        {(char *) "retry_limit",
         cf_int, CA_GOD, &mudconf.retry_limit, 0},
        {(char *) "robot_cost",
         cf_int, CA_GOD, &mudconf.robotcost, 0},
        {(char *) "robot_flags",
         cf_set_flags, CA_GOD, (int *) &mudconf.robot_flags, 0},
        {(char *) "robot_speech",
         cf_bool, CA_GOD, &mudconf.robot_speak, 0},
        {(char *) "room_flags",
         cf_set_flags, CA_GOD, (int *) &mudconf.room_flags, 0},
        {(char *) "room_quota",
         cf_int, CA_GOD, &mudconf.room_quota, 0},
        {(char *) "sacrifice_adjust",
         cf_int, CA_GOD, &mudconf.sacadjust, 0},
        {(char *) "sacrifice_factor",
         cf_int, CA_GOD, &mudconf.sacfactor, 0},
        {(char *) "search_cost",
         cf_int, CA_GOD, &mudconf.searchcost, 0},
        {(char *) "see_owned_dark",
         cf_bool, CA_GOD, &mudconf.see_own_dark, 0},
        {(char *) "show_unfindable_who",
         cf_bool, CA_GOD, &mudconf.show_unfindable_who, 1},
#if 0
        {(char *) "signal_action",
         cf_option, CA_DISABLED, &mudconf.sig_action,
         (long) sigactions_nametab},
#endif
        {(char *) "site_chars",
         cf_int, CA_GOD, &mudconf.site_chars, 0},
        {(char *) "space_compress",
         cf_bool, CA_GOD, &mudconf.space_compress, 0},
        {(char *) "stack_limit",
         cf_int, CA_GOD, &mudconf.stack_limit, 0},
        {(char *) "starting_money",
         cf_int, CA_GOD, &mudconf.paystart, 0},
        {(char *) "starting_quota",
         cf_int, CA_GOD, &mudconf.start_quota, 0},
        {(char *) "status_file",
         cf_string, CA_DISABLED, (void *) mudconf.status_file, 128},
        {(char *) "suspect_site",
         cf_site, CA_GOD, (int *) &mudstate.suspect_list,
         H_SUSPECT},
        {(char *) "sweep_dark",
         cf_bool, CA_GOD, &mudconf.sweep_dark, 0},
        {(char *) "switch_default_all",
         cf_bool, CA_GOD, &mudconf.switch_df_all, 0},
        {(char *) "terse_shows_contents",
         cf_bool, CA_GOD, &mudconf.terse_contents, 0},
        {(char *) "terse_shows_exits",
         cf_bool, CA_GOD, &mudconf.terse_exits, 0},
        {(char *) "terse_shows_move_messages",
         cf_bool, CA_GOD, &mudconf.terse_movemsg, 0},
        {(char *) "thing_flags",
         cf_set_flags, CA_GOD, (int *) &mudconf.thing_flags, 0},
        {(char *) "thing_quota",
         cf_int, CA_GOD, &mudconf.thing_quota, 0},
        {(char *) "timeslice",
         cf_int, CA_GOD, &mudconf.timeslice, 0},
        {(char *) "trace_output_limit",
         cf_int, CA_GOD, &mudconf.trace_limit, 0},
        {(char *) "trace_topdown",
         cf_bool, CA_GOD, &mudconf.trace_topdown, 0},
        {(char *) "trust_site",
         cf_site, CA_GOD, (int *) &mudstate.suspect_list, 0},
        {(char *) "uncompress_program",
         cf_string, CA_DISABLED, (void *) mudconf.uncompress, 128},
        {(char *) "unowned_safe",
         cf_bool, CA_GOD, &mudconf.safe_unowned, 0},
        {(char *) "user_attr_access",
         cf_modify_bits, CA_GOD, &mudconf.vattr_flags,
         (long) attraccess_nametab},
        {(char *) "wait_cost",
         cf_int, CA_GOD, &mudconf.waitcost, 0},
        {(char *) "wizard_help_file",
         cf_string, CA_DISABLED, (void *) mudconf.whelp_file, 32},
        {(char *) "wizard_help_index",
         cf_string, CA_DISABLED, (void *) mudconf.whelp_indx, 32},
        {(char *) "wizard_motd_file",
         cf_string, CA_DISABLED, (void *) mudconf.wizmotd_file, 32},
        {(char *) "wizard_motd_message",
         cf_string, CA_GOD, (void *) mudconf.wizmotd_msg, 4096},
        {(char *) "zone_recursion_limit",
         cf_int, CA_GOD, &mudconf.zone_nest_lim, 0},
#ifdef SQL_SUPPORT
        {(char *) "sqlDB_type_A",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_type_A, 128},
        {(char *) "sqlDB_hostname_A",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_hostname_A, 128},
        {(char *) "sqlDB_username_A",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_username_A, 128},
        {(char *) "sqlDB_password_A",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_password_A, 128},
        {(char *) "sqlDB_dbname_A",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_dbname_A, 128},
        {(char *) "sqlDB_type_B",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_type_B, 128},
        {(char *) "sqlDB_hostname_B",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_hostname_B, 128},
        {(char *) "sqlDB_username_B",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_username_B, 128},
        {(char *) "sqlDB_password_B",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_password_B, 128},
        {(char *) "sqlDB_dbname_B",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_dbname_B, 128},
        {(char *) "sqlDB_type_C",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_type_C, 128},
        {(char *) "sqlDB_hostname_C",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_hostname_C, 128},
        {(char *) "sqlDB_username_C",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_username_C, 128},
        {(char *) "sqlDB_password_C",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_password_C, 128},
        {(char *) "sqlDB_dbname_C",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_dbname_C, 128},
        {(char *) "sqlDB_type_D",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_type_D, 128},
        {(char *) "sqlDB_hostname_D",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_hostname_D, 128},
        {(char *) "sqlDB_username_D",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_username_D, 128},
        {(char *) "sqlDB_password_D",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_password_D, 128},
        {(char *) "sqlDB_dbname_D",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_dbname_D, 128},
        {(char *) "sqlDB_type_E",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_type_E, 128},
        {(char *) "sqlDB_hostname_E",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_hostname_E, 128},
        {(char *) "sqlDB_username_E",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_username_E, 128},
        {(char *) "sqlDB_password_E",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_password_E, 128},
        {(char *) "sqlDB_dbname_E",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_dbname_E, 128},
        {(char *) "sqlDB_mysql_socket",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_mysql_socket, 128},
        {(char *) "sqlDB_sqlite_dbdir",
         cf_string, CA_GOD, (void *) mudconf.sqlDB_sqlite_dbdir, 128},
        {(char *) "sqlDB_max_queries",
         cf_int, CA_GOD, &mudconf.sqlDB_max_queries, 0},
#endif
        {(char *) "exit_parent",
         cf_int, CA_GOD, &mudconf.exit_parent, 0},
        {(char *) "room_parent",
         cf_int, CA_GOD, &mudconf.room_parent, 0},
        {NULL, NULL, 0, NULL, 0}
};

/*
 * ---------------------------------------------------------------------------
 * * cf_set: Set config parameter.
 */
int cf_set(char *cp, char *ap, dbref player)
{
        CONF *tp;
        int i;
        char *buff = NULL;

        /*
         * 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.initializing && !check_access(player, tp->flags)) {
                                notify(player, "Permission denied.");
                                return (-1);
                        }
            buff = alloc_lbuf("cf_set");
            StringCopy(buff, ap);
                        i = tp->interpreter(tp->loc, ap, tp->extra, player, cp);
                        if(!mudstate.initializing) {
                log_error(LOG_CONFIGMODS, "CFG", "UPDAT", 
                "%s entered config directive: %s with args '%s'. Status: %s%s%s%s", 
                Name(player), cp, buff, (i==0?"Success":(i==1?"Partial success":(i==-1?"Failure":"Strange"))));

                        }
            free_lbuf(buff);
                        return i;
                }
        }

        /*
         * Config directive not found.  Complain about it.
         */

        cf_log_notfound(player, (char *) "Set", "Config directive", cp);
        return (-1);
}

/*
 * ---------------------------------------------------------------------------
 * * do_admin: Command handler to set config params at runtime
 */
void do_admin(dbref player, dbref cause, int extra, char *kw, char *value)
{
        int i;

        i = cf_set(kw, value, player);
        if((i >= 0) && !Quiet(player))
                notify(player, "Set.");
        return;
}

/*
 * ---------------------------------------------------------------------------
 * * cf_read: Read in config parameters from named file
 */
int cf_read(char *fn)
{
        int retval;

        StringCopy(mudconf.config_file, fn);
        mudstate.initializing = 1;
        retval = cf_include(NULL, fn, 0, 0, (char *) "init");
        mudstate.initializing = 0;

        /*
         * Fill in missing DB file names
         */

        if(!*mudconf.outdb) {
                StringCopy(mudconf.outdb, mudconf.indb);
                strcat(mudconf.outdb, ".out");
        }
        if(!*mudconf.crashdb) {
                StringCopy(mudconf.crashdb, mudconf.indb);
                strcat(mudconf.crashdb, ".CRASH");
        }
        if(!*mudconf.gdbm) {
                StringCopy(mudconf.gdbm, mudconf.indb);
                strcat(mudconf.gdbm, ".gdbm");
        }
        return retval;
}

/*
 * ---------------------------------------------------------------------------
 * * list_cf_access: List access to config directives.
 */
void list_cf_access(dbref player)
{
        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, 1);
                }
        }
        free_mbuf(buff);
}

/* ----------------------------------------------------------------------
 ** fun_config: returns the option set in mudconf
 */
void fun_config(char *buff, char **bufc, dbref player, dbref cause,
                                char *fargs[], int nfargs, char *cargs[], int ncargs)
{
        CONF *cp;

        for(cp = conftable; cp->pname; ++cp) {
                if(!strcmp(cp->pname, fargs[0])) {
                        /* ::FIX:: [cad] little hack. I don't think it's necessairy to need god privs
                         ** to read options so check_access doesn't work
                         */
                        if(cp->flags == CA_DISABLED) {
                                safe_str("#-1 PERMISSION DENIED", buff, bufc);
                                return;
                        }
                        if(cp->interpreter == cf_string) {
                                safe_str((char *) cp->loc, buff, bufc);
                                return;
                        }

                        /* [cad] bool can be returned as 0|1 or true|false softcoders should
                           decide how they want it */
                        if(cp->interpreter == cf_int || cp->interpreter == cf_bool) {
                                safe_tprintf_str(buff, bufc, "%d", *(int *) cp->loc);
                                return;
                        }

                        /* [cad] no other idea what to do with the hashtables and stuff */
                        safe_str("#-1 UNCONVERTABLE CONF TYPE", buff, bufc);
                        return;
                }
        }
        safe_str("#-1", buff, bufc);
}

---