root/1.8.3/tags/p6/src/conf.c

/**
 * \file conf.c
 *
 * \brief PennMUSH runtime configuration.
 *
 * configuration adjustment. Some of the ideas and bits and pieces of the
 * code here are based on TinyMUSH 2.0.
 *
 */

#include "copyrite.h"
#include "config.h"

#include <stdio.h>
#ifdef I_SYS_TIME
#include <sys/time.h>
#ifdef TIME_WITH_SYS_TIME
#include <time.h>
#endif
#else
#include <time.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

#include "conf.h"
#include "externs.h"
#include "ansi.h"
#include "pueblo.h"
#include "mushdb.h"
#include "parse.h"
#include "command.h"
#include "flags.h"
#include "log.h"
#include "dbdefs.h"
#include "game.h"
#include "attrib.h"
#include "help.h"
#include "function.h"
#include "confmagic.h"

time_t mudtime;                 /**< game time, in seconds */

static void show_compile_options(dbref player);
static char *config_list_helper(dbref player, PENNCONF *cp, int lc);
static char *config_list_helper2(dbref player, PENNCONF *cp, int lc);

OPTTAB options;         /**< The table of configuration options */
HASHTAB local_options;  /**< Hash table for local config options */

int config_set(const char *opt, char *val, int source, int restrictions);
void conf_default_set(void);

/** Table of all runtime configuration options. */
PENNCONF conftable[] = {
  {"input_database", cf_str, options.input_db, sizeof options.input_db, 0,
   "files"}
  ,
  {"output_database", cf_str, options.output_db, sizeof options.output_db, 0,
   "files"}
  ,
  {"crash_database", cf_str, options.crash_db, sizeof options.crash_db, 0,
   "files"}
  ,
  {"mail_database", cf_str, options.mail_db, sizeof options.mail_db, 0, "files"}
  ,
  {"chat_database", cf_str, options.chatdb, sizeof options.chatdb, 0, "files"}
  ,
  {"compress_suffix", cf_str, options.compresssuff, sizeof options.compresssuff,
   0,
   "files"}
  ,
  {"compress_program", cf_str, options.compressprog,
   sizeof options.compressprog, 0,
   "files"}
  ,
  {"uncompress_program", cf_str, options.uncompressprog,
   sizeof options.uncompressprog, 0,
   "files"}
  ,
  {"access_file", cf_str, options.access_file, sizeof options.access_file, 0,
   "files"}
  ,
  {"names_file", cf_str, options.names_file, sizeof options.access_file, 0,
   "files"}
  ,
  {"connect_file", cf_str, options.connect_file[0],
   sizeof options.connect_file[0], 0, "messages"}
  ,
  {"motd_file", cf_str, options.motd_file[0], sizeof options.motd_file[0], 0,
   "messages"}
  ,
  {"wizmotd_file", cf_str, options.wizmotd_file[0],
   sizeof options.wizmotd_file[0], 0, "messages"}
  ,
  {"newuser_file", cf_str, options.newuser_file[0],
   sizeof options.newuser_file[0], 0, "messages"}
  ,

  {"register_create_file", cf_str, options.register_file[0],
   sizeof options.register_file[0],
   0, "messages"}
  ,
  {"quit_file", cf_str, options.quit_file[0], sizeof options.quit_file[0], 0,
   "messages"}
  ,
  {"down_file", cf_str, options.down_file[0], sizeof options.down_file[0], 0,
   "messages"}
  ,
  {"full_file", cf_str, options.full_file[0], sizeof options.full_file[0], 0,
   "messages"}
  ,
  {"guest_file", cf_str, options.guest_file[0], sizeof options.guest_file[0], 0,
   "messages"}
  ,

  {"connect_html_file", cf_str, options.connect_file[1],
   sizeof options.connect_file[1], 0,
   "messages"}
  ,
  {"motd_html_file", cf_str, options.motd_file[1],
   sizeof options.connect_file[1], 0,
   "messages"}
  ,
  {"wizmotd_html_file", cf_str, options.wizmotd_file[1],
   sizeof options.wizmotd_file[1], 0,
   "messages"}
  ,
  {"newuser_html_file", cf_str, options.newuser_file[1],
   sizeof options.newuser_file[1], 0,
   "messages"}
  ,
  {"register_create_html_file", cf_str, options.register_file[1],
   sizeof options.register_file[1], 0, "messages"}
  ,
  {"quit_html_file", cf_str, options.quit_file[1], sizeof options.quit_file[1],
   0,
   "messages"}
  ,
  {"down_html_file", cf_str, options.down_file[1], sizeof options.down_file[1],
   0,
   "messages"}
  ,
  {"full_html_file", cf_str, options.full_file[1], sizeof options.full_file[1],
   0,
   "messages"}
  ,
  {"guest_html_file", cf_str, options.guest_file[1],
   sizeof options.guest_file[1], 0,
   "messages"}
  ,

  {"player_start", cf_dbref, &options.player_start, 100000, 0, "db"}
  ,
  {"master_room", cf_dbref, &options.master_room, 100000, 0, "db"}
  ,
  {"base_room", cf_dbref, &options.base_room, 100000, 0, "db"}
  ,
  {"default_home", cf_dbref, &options.default_home, 100000, 0, "db"}
  ,
  {"exits_connect_rooms", cf_bool, &options.exits_connect_rooms, 2, 0, "db"}
  ,
  {"zone_control_zmp_only", cf_bool, &options.zone_control, 2, 0, "db"}
  ,
  {"ancestor_room", cf_dbref, &options.ancestor_room, 100000, 0, "db"}
  ,
  {"ancestor_exit", cf_dbref, &options.ancestor_exit, 100000, 0, "db"}
  ,
  {"ancestor_thing", cf_dbref, &options.ancestor_thing, 100000, 0, "db"}
  ,
  {"ancestor_player", cf_dbref, &options.ancestor_player, 100000, 0, "db"}
  ,
  {"mud_name", cf_str, options.mud_name, 128, 0, "net"}
  ,
  {"ip_addr", cf_str, options.ip_addr, 64, 0, "net"}
  ,
  {"ssl_ip_addr", cf_str, options.ssl_ip_addr, 64, 0, "net"}
  ,
  {"port", cf_int, &options.port, 65535, 0, "net"}
  ,
  {"ssl_port", cf_int, &options.ssl_port, 65535, 0, "net"}
  ,
  {"use_dns", cf_bool, &options.use_dns, 2, 0, "net"}
  ,
  {"use_ident", cf_bool, &options.use_ident, 2, 0, "net"}
  ,
  {"ident_timeout", cf_time, &options.ident_timeout, 60, 0, "net"}
  ,
  {"logins", cf_bool, &options.login_allow, 2, 0, "net"}
  ,
  {"player_creation", cf_bool, &options.create_allow, 2, 0, "net"}
  ,
  {"guests", cf_bool, &options.guest_allow, 2, 0, "net"}
  ,
  {"pueblo", cf_bool, &options.support_pueblo, 2, 0, "net"}
  ,
  {"sql_platform", cf_str, options.sql_platform, sizeof options.sql_platform, 0,
   "net"}
  ,
  {"sql_host", cf_str, options.sql_host, sizeof options.sql_host, 0, "net"}
  ,
  {"sql_username", cf_str, options.sql_username, sizeof options.sql_username, 0,
   NULL}
  ,
  {"sql_password", cf_str, options.sql_password, sizeof options.sql_password, 0,
   NULL}
  ,
  {"sql_database", cf_str, options.sql_database, sizeof options.sql_database, 0,
   NULL}
  ,
  {"forking_dump", cf_bool, &options.forking_dump, 2, 0, "dump"}
  ,
  {"dump_message", cf_str, options.dump_message, sizeof options.dump_message, 0,
   "dump"}
  ,
  {"dump_complete", cf_str, options.dump_complete, sizeof options.dump_complete,
   0, "dump"}
  ,
  {"dump_warning_1min", cf_str, options.dump_warning_1min,
   sizeof options.dump_warning_1min,
   0, "dump"}
  ,
  {"dump_warning_5min", cf_str, options.dump_warning_5min,
   sizeof options.dump_warning_5min, 0,
   "dump"}
  ,
  {"dump_interval", cf_time, &options.dump_interval, 100000, 0, "dump"}
  ,
  {"warn_interval", cf_time, &options.warn_interval, 32000, 0, "dump"}
  ,
  {"purge_interval", cf_time, &options.purge_interval, 10000, 0, "dump"}
  ,
  {"dbck_interval", cf_time, &options.dbck_interval, 10000, 0, "dump"}
  ,

  {"money_singular", cf_str, options.money_singular,
   sizeof options.money_singular, 0,
   "cosmetic"}
  ,
  {"money_plural", cf_str, options.money_plural, sizeof options.money_plural, 0,
   "cosmetic"}
  ,
  {"player_name_spaces", cf_bool, &options.player_name_spaces, 2, 0,
   "cosmetic"}
  ,
  {"max_aliases", cf_int, &options.max_aliases, -1, 0, "limits"}
  ,
  {"ansi_names", cf_bool, &options.ansi_names, 2, 0, "cosmetic"}
  ,
  {"only_ascii_in_names", cf_bool, &options.ascii_names, 2, 0, "cosmetic"}
  ,
  {"float_precision", cf_int, &options.float_precision, 10000, 0, "cosmetic"}
  ,
  {"comma_exit_list", cf_bool, &options.comma_exit_list, 2, 0, "cosmetic"}
  ,
  {"count_all", cf_bool, &options.count_all, 2, 0, "cosmetic"}
  ,
  {"blind_page", cf_bool, &options.blind_page, 2, 0, "cosmetic"}
  ,
  {"page_aliases", cf_bool, &options.page_aliases, 2, 0, "cosmetic"}
  ,
  {"flags_on_examine", cf_bool, &options.flags_on_examine, 2, 0, "cosmetic"}
  ,
  {"ex_public_attribs", cf_bool, &options.ex_public_attribs, 2, 0,
   "cosmetic"}
  ,
  {"wizwall_prefix", cf_str, options.wizwall_prefix,
   sizeof options.wizwall_prefix, 0,
   "cosmetic"}
  ,
  {"rwall_prefix", cf_str, options.rwall_prefix, sizeof options.rwall_prefix, 0,
   "cosmetic"}
  ,
  {"wall_prefix", cf_str, options.wall_prefix, sizeof options.wall_prefix, 0,
   "cosmetic"}
  ,
  {"announce_connects", cf_bool, &options.announce_connects, 2, 0, "cosmetic"}
  ,
  {"chat_strip_quote", cf_bool, &options.chat_strip_quote, 2, 0, "cosmetic"}
  ,
  {"newline_one_char", cf_bool, &options.newline_one_char, 2, 0, "cosmetic"}
  ,

  {"max_dbref", cf_dbref, &options.max_dbref, -1, 0, "limits"}
  ,
  {"max_attrs_per_obj", cf_int, &options.max_attrcount, 8192, 0, "limits"}
  ,
  {"max_logins", cf_int, &options.max_logins, 128, 0, "limits"}
  ,
  {"max_guests", cf_int, &options.max_guests, 128, 0, "limits"}
  ,
  {"idle_timeout", cf_time, &options.idle_timeout, 100000, 0, "limits"}
  ,
  {"unconnected_idle_timeout", cf_time, &options.unconnected_idle_timeout,
   100000, 0, "limits"}
  ,
  {"keepalive_timeout", cf_time, &options.keepalive_timeout, 10000, 0, "limits"}
  ,
  {"whisper_loudness", cf_int, &options.whisper_loudness, 100, 0, "limits"}
  ,
  {"starting_quota", cf_int, &options.starting_quota, 10000, 0, "limits"}
  ,
  {"starting_money", cf_int, &options.starting_money, 10000, 0, "limits"}
  ,
  {"paycheck", cf_int, &options.paycheck, 1000, 0, "limits"}
  ,
  {"guest_paycheck", cf_int, &options.guest_paycheck, 1000, 0, "limits"}
  ,
  {"max_pennies", cf_int, &options.max_pennies, 100000, 0, "limits"}
  ,
  {"max_guest_pennies", cf_int, &options.max_guest_pennies, 100000, 0,
   "limits"}
  ,
  {"max_parents", cf_int, &options.max_parents, 10000, 0, "limits"}
  ,
  {"mail_limit", cf_int, &options.mail_limit, 5000, 0, "limits"}
  ,
  {"max_depth", cf_int, &options.max_depth, 10000, 0, "limits"}
  ,
  {"player_queue_limit", cf_int, &options.player_queue_limit, 100000, 0,
   "limits"}
  ,
  {"queue_loss", cf_int, &options.queue_loss, 10000, 0, "limits"}
  ,
  {"queue_chunk", cf_int, &options.queue_chunk, 100000, 0, "limits"}
  ,
  {"active_queue_chunk", cf_int, &options.active_q_chunk, 100000, 0,
   "limits"}
  ,
  {"function_recursion_limit", cf_int, &options.func_nest_lim, 100000, 0,
   "limits"}
  ,
  {"function_invocation_limit", cf_int, &options.func_invk_lim, 100000, 0,
   "limits"}
  ,
  {"call_limit", cf_int, &options.call_lim, 1000000, 0,
   "limits"}
  ,
  {"player_name_len", cf_int, &options.player_name_len, BUFFER_LEN, 0,
   "limits"}
  ,
  {"queue_entry_cpu_time", cf_int, &options.queue_entry_cpu_time, 100000, 0,
   "limits"}
  ,
  {"max_global_fns", cf_int, &options.max_global_fns, 2000, 0, 0}
  ,
  {"use_quota", cf_bool, &options.use_quota, 2, 0, "limits"}
  ,
  {"max_channels", cf_int, &options.max_channels, 1000, 0, "chat"}
  ,
  {"max_player_chans", cf_int, &options.max_player_chans, 100, 0, "chat"}
  ,
  {"chan_cost", cf_int, &options.chan_cost, 10000, 0, "chat"}
  ,
  {"noisy_cemit", cf_bool, &options.noisy_cemit, 2, 0, "chat"}
  ,
  {"log_commands", cf_bool, &options.log_commands, 2, 0, "log"}
  ,
  {"log_forces", cf_bool, &options.log_forces, 2, 0, "log"}
  ,
  {"error_log", cf_str, options.error_log, sizeof options.error_log, 0,
   "log"}
  ,
  {"command_log", cf_str, options.command_log, sizeof options.command_log, 0,
   "log"}
  ,
  {"wizard_log", cf_str, options.wizard_log, sizeof options.wizard_log, 0,
   "log"}
  ,
  {"checkpt_log", cf_str, options.checkpt_log, sizeof options.checkpt_log, 0,
   "log"}
  ,
  {"trace_log", cf_str, options.trace_log, sizeof options.trace_log, 0,
   "log"}
  ,
  {"connect_log", cf_str, options.connect_log, sizeof options.connect_log, 0,
   "log"}
  ,

  {"player_flags", cf_flag, options.player_flags, sizeof options.player_flags,
   0, "flags"}
  ,
  {"room_flags", cf_flag, options.room_flags, sizeof options.room_flags, 0,
   "flags"}
  ,
  {"exit_flags", cf_flag, options.exit_flags, sizeof options.exit_flags, 0,
   "flags"}
  ,
  {"thing_flags", cf_flag, options.thing_flags, sizeof options.thing_flags, 0,
   "flags"}
  ,
  {"channel_flags", cf_flag, options.channel_flags,
   sizeof options.channel_flags, 0,
   "flags"}
  ,

  {"safer_ufun", cf_bool, &options.safer_ufun, 2, 0, "funcs"}
  ,
  {"function_side_effects", cf_bool, &options.function_side_effects, 2, 0,
   "funcs"}
  ,

  {"noisy_whisper", cf_bool, &options.noisy_whisper, 2, 0, "cmds"}
  ,
  {"possessive_get", cf_bool, &options.possessive_get, 2, 0, "cmds"}
  ,
  {"possessive_get_d", cf_bool, &options.possessive_get_d, 2, 0, "cmds"}
  ,
  {"link_to_object", cf_bool, &options.link_to_object, 2, 0, "cmds"}
  ,
  {"owner_queues", cf_bool, &options.owner_queues, 2, 0, "cmds"}
  ,
  {"full_invis", cf_bool, &options.full_invis, 2, 0, "cmds"}
  ,
  {"wiz_noaenter", cf_bool, &options.wiz_noaenter, 2, 0, "cmds"}
  ,
  {"really_safe", cf_bool, &options.really_safe, 2, 0, "cmds"}
  ,
  {"destroy_possessions", cf_bool, &options.destroy_possessions, 2, 0,
   "cmds"}
  ,

  {"null_eq_zero", cf_bool, &options.null_eq_zero, 2, 0, "tiny"}
  ,
  {"tiny_booleans", cf_bool, &options.tiny_booleans, 2, 0, "tiny"}
  ,
  {"tiny_trim_fun", cf_bool, &options.tiny_trim_fun, 2, 0, "tiny"}
  ,
  {"tiny_math", cf_bool, &options.tiny_math, 2, 0, "tiny"}
  ,
  {"silent_pemit", cf_bool, &options.silent_pemit, 2, 0, "tiny"}
  ,

  {"adestroy", cf_bool, &options.adestroy, 2, 0, "attribs"}
  ,
  {"amail", cf_bool, &options.amail, 2, 0, "attribs"}
  ,
  {"player_listen", cf_bool, &options.player_listen, 2, 0, "attribs"}
  ,
  {"player_ahear", cf_bool, &options.player_ahear, 2, 0, "attribs"}
  ,
  {"startups", cf_bool, &options.startups, 2, 0, "attribs"}
  ,
  {"read_remote_desc", cf_bool, &options.read_remote_desc, 2, 0, "attribs"}
  ,
  {"room_connects", cf_bool, &options.room_connects, 2, 0, "attribs"}
  ,
  {"reverse_shs", cf_bool, &options.reverse_shs, 2, 0, "attribs"}
  ,
  {"empty_attrs", cf_bool, &options.empty_attrs, 2, 0, "attribs"}
  ,
  {"object_cost", cf_int, &options.object_cost, 10000, 0, "costs"}
  ,
  {"exit_cost", cf_int, &options.exit_cost, 10000, 0, "costs"}
  ,
  {"link_cost", cf_int, &options.link_cost, 10000, 0, "costs"}
  ,
  {"room_cost", cf_int, &options.room_cost, 10000, 0, "costs"}
  ,
  {"queue_cost", cf_int, &options.queue_cost, 10000, 0, "costs"}
  ,
  {"quota_cost", cf_int, &options.quota_cost, 10000, 0, "costs"}
  ,
  {"find_cost", cf_int, &options.find_cost, 10000, 0, "costs"}
  ,
  {"page_cost", cf_int, &options.page_cost, 10000, 0, "costs"}
  ,
  {"kill_default_cost", cf_int, &options.kill_default_cost, 10000, 0,
   "costs"}
  ,
  {"kill_min_cost", cf_int, &options.kill_min_cost, 10000, 0, "costs"}
  ,
  {"kill_bonus", cf_int, &options.kill_bonus, 100, 0, "costs"}
  ,

  {"log_wipe_passwd", cf_str, options.log_wipe_passwd,
   sizeof options.log_wipe_passwd, 0,
   NULL}
  ,

  {"chunk_swap_file", cf_str, options.chunk_swap_file,
   sizeof options.chunk_swap_file, 0, "files"}
  ,
  {"chunk_cache_memory", cf_int, &options.chunk_cache_memory,
   1000000000, 65510 * 2, "files"}
  ,
  {"chunk_migrate", cf_int, &options.chunk_migrate_amount, 100000, 0,
   "limits"}
  ,
#ifdef HAS_OPENSSL
  {"ssl_private_key_file", cf_str, options.ssl_private_key_file,
   sizeof options.ssl_private_key_file, 0, "files"}
  ,
  {"ssl_ca_file", cf_str, options.ssl_ca_file,
   sizeof options.ssl_ca_file, 0, "files"}
  ,
  {"ssl_require_client_cert", cf_bool, &options.ssl_require_client_cert,
   2, 0, "net"}
  ,
#endif
  {"mem_check", cf_bool, &options.mem_check, 2, 0, "log"}
  ,

  {NULL, NULL, NULL, 0, 0, NULL}
};

/** A runtime configuration group.
 * This struction represents the name and information about a group
 * of runtime configuration directives. Groups are used to organize
 * the display of configuration options.
 */
typedef struct confgroupparm {
  const char *name;             /**< name of group */
  const char *desc;             /**< description of group */
  int viewperms;                /**< who can view this group */
} PENNCONFGROUP;

/** The table of all configuration groups. */
PENNCONFGROUP confgroups[] = {
  {"attribs", "Options affecting attributes", 0},
  {"chat", "Chat system options", 0},
  {"cmds", "Options affecting command behavior", 0},
  {"compile", "Compile-time options", 0},
  {"cosmetic", "Cosmetic options", 0},
  {"costs", "Costs", 0},
  {"db", "Database options", 0},
  {"dump", "Options affecting dumps and other periodic processes", 0},
  {"files", "Files used by the MUSH", CGP_GOD},
  {"flags", "Default flags for new objects", 0},
  {"funcs", "Options affecting function behavior", 0},
  {"limits", "Limits and other constants", 0},
  {"log", "Logging options", 0},
  {"messages", "Message files sent by the MUSH", CGP_GOD},
  {"net", "Networking and connection-related options", 0},
  {"tiny", "TinyMUSH compatibility options", 0},
  {NULL, NULL, 0}
};

#if 0
/* Just to mark these strings for translation */
PENNCONFGROUP dummy[] = {
  {"attribs", T("Options affecting attributes"), 0},
  {"chat", T("Chat system options"), 0},
  {"cmds", T("Options affecting command behavior"), 0},
  {"compile", T("Compile-time options"), 0},
  {"cosmetic", T("Cosmetic options"), 0},
  {"costs", T("Costs"), 0},
  {"db", T("Database options"), 0},
  {"dump", T("Options affecting dumps and other periodic processes"), 0},
  {"files", T("Files used by the MUSH"), CGP_GOD},
  {"flags", T("Default flags for new objects"), 0},
  {"funcs", T("Options affecting function behavior"), 0},
  {"limits", T("Limits and other constants"), 0},
  {"log", T("Logging options"), 0},
  {"messages", T("Message files sent by the MUSH"), CGP_GOD},
  {"net", T("Networking and connection-related options"), 0},
  {"tiny", T("TinyMUSH compatibility options"), 0},
  {NULL, NULL, 0}
};
#endif

/** Returns a pointer to a newly allocated PENNCONF object.
 * \return pointer to newly allocated PENNCONF object.
 */
PENNCONF *
new_config(void)
{
  return ((PENNCONF *) mush_malloc(sizeof(PENNCONF), "config"));
}

/** Add a new local runtime configuration parameter to local_options.
 * This function will not override an existing local configuration
 * option.
 * \param name name of the configuration option.
 * \param handler cf_* function to handle the option.
 * \param loc address to store the value of the option.
 * \param max maximum value allowed for the option.
 * \param group name of the option group the option should display with.
 * \return pointer to configuration structure or NULL for failure.
 */
PENNCONF *
add_config(const char *name, config_func handler, void *loc, int max,
           const char *group)
{
  PENNCONF *cnf;
  if ((cnf = get_config(name)))
    return cnf;
  if ((cnf = new_config()) == NULL)
    return NULL;
  cnf->name = mush_strdup(strupper(name), "config name");
  cnf->handler = handler;
  cnf->loc = loc;
  cnf->max = max;
  cnf->overridden = 0;
  cnf->group = group;
  hashadd(name, (void *) cnf, &local_options);
  return cnf;
}

/** Return a local runtime configuration parameter by name.
 * This function returns a point to a configuration structure (PENNCONF *)
 * if one exists in the local runtime options that matches the given
 * name. Only local_options is searched.
 * \param name name of the configuration option.
 * \return pointer to configuration structure or NULL for failure.
 */
PENNCONF *
get_config(const char *name)
{
  return ((PENNCONF *) hashfind(name, &local_options));
}

/** Parse a boolean configuration option.
 * \param opt name of the configuration option.
 * \param val value of the option.
 * \param loc address to store the value.
 * \param maxval (unused).
 * \param from_cmd 0 if read from config file; 1 if from command.
 * \retval 0 failure (unable to parse val).
 * \retval 1 success.
 */
int
cf_bool(const char