/*

 * $LynxId: LYReadCFG.c,v 1.193 2018/05/11 00:03:10 tom Exp $

 */

#ifndef NO_RULES

#include <HTRules.h>

#else

#include <HTUtils.h>

#endif

#include <HTTP.h>		/* 'reloading' flag */

#include <HTFile.h>

#include <HTInit.h>

#include <UCMap.h>

#include <LYUtils.h>

#include <GridText.h>

#include <LYStrings.h>

#include <LYStructs.h>

#include <LYGlobalDefs.h>

#include <LYCharSets.h>

#include <LYCharUtils.h>

#include <LYKeymap.h>

#include <LYJump.h>

#include <LYGetFile.h>

#include <LYCgi.h>

#include <LYCurses.h>

#include <LYBookmark.h>

#include <LYCookie.h>

#include <LYReadCFG.h>

#include <HTAlert.h>

#include <LYHistory.h>

#include <LYPrettySrc.h>

#include <LYrcFile.h>

#ifdef DIRED_SUPPORT

#include <LYLocal.h>

#endif /* DIRED_SUPPORT */

#include <LYexit.h>

#include <LYLeaks.h>

#ifndef DISABLE_NEWS

#include <HTNews.h>

#endif

BOOLEAN have_read_cfg = FALSE;

BOOLEAN LYUseNoviceLineTwo = TRUE;

/*

 * Translate a TRUE/FALSE field in a string buffer.

 */

static BOOL is_true(const char *string)

{

    if (!strcasecomp(string, "TRUE") || !strcasecomp(string, "ON"))

	return (TRUE);

    else

	return (FALSE);

}

/*

 * Find an unescaped colon in a string buffer.

 */

static const char *find_colon(const char *buffer)

{

    char ch;

    const char *buf = buffer;

    if (buf == NULL)

	return NULL;

    while ((ch = *buf) != 0) {

	if (ch == ':')

	    return buf;

	if (ch == '\\') {

	    buf++;

	    if (*buf == 0)

		break;

	}

	buf++;

    }

    return NULL;

}

static void free_item_list_item(lynx_list_item_type **list,

				lynx_list_item_type *ptr)

{

    lynx_list_item_type *prev;

    lynx_list_item_type *cur;

    for (cur = *list, prev = 0; cur != 0; prev = cur, cur = cur->next) {

	if (cur == ptr) {

	    if (prev != 0)

		prev->next = cur->next;

	    else

		*list = cur->next;

	    FREE(cur->name);

	    FREE(cur->menu_name);

	    FREE(cur->command);

	    FREE(cur);

	    break;

	}

    }

}

static void free_item_list(lynx_list_item_type **ptr)

{

    while (*ptr != 0) {

	free_item_list_item(ptr, *ptr);

    }

}

/*

 * Function for freeing the DOWNLOADER and UPLOADER menus list.  - FM

 */

static void free_all_item_lists(void)

{

    free_item_list(&printers);

    free_item_list(&downloaders);

#ifdef DIRED_SUPPORT

    free_item_list(&uploaders);

#endif /* DIRED_SUPPORT */

#ifdef USE_EXTERNALS

    free_item_list(&externals);

#endif /* USE_EXTERNALS */

    return;

}

static const char *parse_list_bool(BOOL *target, const char *source)

{

    const char *result;

    source = LYSkipCBlanks(source);

    result = find_colon(source);

    if (*source != '\0') {

	char temp[20];

	size_t len = ((result != 0)

		      ? (size_t) (result - source)

		      : strlen(source));

	if (len > sizeof(temp))

	    len = (sizeof(temp) - 1);

	LYStrNCpy(temp, source, len);

	*target = is_true(temp);

	CTRACE2(TRACE_CFG, (tfp, "parse_list_bool(%s) '%d'\n", source, *target));

    }

    return result;

}

static const char *parse_list_int(int *target, const char *source)

{

    const char *result;

    source = LYSkipCBlanks(source);

    result = find_colon(source);

    if (*source != '\0') {

	*target = atoi(source);

	CTRACE2(TRACE_CFG, (tfp, "parse_list_int(%s) '%d'\n", source, *target));

    }

    return result;

}

static const char *parse_list_string(char **target, const char *source)

{

    const char *result;

    source = LYSkipCBlanks(source);

    result = find_colon(source);

    if (*source != '\0') {

	const char *next = ((result == 0)

			    ? (source + strlen(source))

			    : result);

	*target = typecallocn(char, (size_t) (next - source + 1));

	if (*target == NULL)

	    outofmem(__FILE__, "read_cfg");

	LYStrNCpy(*target, source, (next - source));

	remove_backslashes(*target);

	CTRACE2(TRACE_CFG, (tfp, "parse_list_string(%s) '%s'\n", source, *target));

    }

    return result;

}

/*

 * Process string buffer fields for DOWNLOADER or UPLOADER

 *                               or PRINTERS   or EXTERNALS menus

 */

static void add_item_to_list(char *buffer,

			     lynx_list_item_type **list_ptr,

			     int special,

			     int menu_name)

{

    const char *colon, *last_colon;

    lynx_list_item_type *cur_item, *prev_item;

    /*

     * Check if the XWINDOWS or NON_XWINDOWS keyword is present in the last

     * field, and act properly when found depending if external environment

     * $DISPLAY variable is set.

     */

    if ((colon = find_colon(buffer)) == 0) {

	return;

    }

    for (last_colon = colon;

	 (colon = find_colon(last_colon + 1)) != 0;

	 last_colon = colon) {

	;

    }

    /*

     * If colon equals XWINDOWS then only continue

     * if there is a $DISPLAY variable

     */

    if (!strcasecomp(last_colon + 1, "XWINDOWS")) {

	if (LYgetXDisplay() == NULL)

	    return;

    }

    /*

     * If colon equals NON_XWINDOWS then only continue

     * if there is no $DISPLAY variable

     */

    else if (!strcasecomp(last_colon + 1, "NON_XWINDOWS")) {

	if (LYgetXDisplay() != NULL)

	    return;

    }

    /*

     * Make a linked list

     */

    if (*list_ptr == NULL) {

	/*

	 * First item.

	 */

	cur_item = typecalloc(lynx_list_item_type);

	if (cur_item == NULL)

	    outofmem(__FILE__, "read_cfg");

	*list_ptr = cur_item;

#ifdef LY_FIND_LEAKS

	atexit(free_all_item_lists);

#endif

    } else {

	/*

	 * Find the last item.

	 */

	for (prev_item = *list_ptr;

	     prev_item->next != NULL;

	     prev_item = prev_item->next) ;	/* null body */

	cur_item = typecalloc(lynx_list_item_type);

	if (cur_item == NULL)

	    outofmem(__FILE__, "read_cfg");

	else

	    prev_item->next = cur_item;

    }

    /* fill-in nonzero default values */

    cur_item->pagelen = 66;

    /*

     * Find first unescaped colon and process fields

     */

    if (find_colon(buffer) != NULL) {

	colon = parse_list_string(&(cur_item->name), buffer);

	if (colon && menu_name) {

	    colon = parse_list_string(&(cur_item->menu_name), colon + 1);

	}

	if (colon) {

	    colon = parse_list_string(&(cur_item->command), colon + 1);

	}

	if (colon) {

	    colon = parse_list_bool(&(cur_item->always_enabled), colon + 1);

	}

	if (colon) {

	    if (special) {

		(void) parse_list_int(&(cur_item->pagelen), colon + 1);

	    } else {

		(void) parse_list_bool(&(cur_item->override_action), colon + 1);

	    }

	}

    }

    /* ignore empty data */

    if (cur_item->name == NULL

	|| cur_item->command == NULL) {

	CTRACE2(TRACE_CFG, (tfp, "ignoring incomplete list_item '%s'\n", buffer));

	free_item_list_item(list_ptr, cur_item);

    } else if (cur_item->menu_name == NULL) {

	StrAllocCopy(cur_item->menu_name, cur_item->command);

    }

}

lynx_list_item_type *find_item_by_number(lynx_list_item_type *list_ptr,

					 char *number)

{

    int value = atoi(number);

    while (value-- >= 0 && list_ptr != 0) {

	list_ptr = list_ptr->next;

    }

    return list_ptr;

}

int match_item_by_name(lynx_list_item_type *ptr,

		       const char *name,

		       int only_overriders)

{

    return

	(ptr->command != 0

	 && !strncasecomp(ptr->name, name, (int) strlen(ptr->name))

	 && (only_overriders ? ptr->override_action : 1));

}

#if defined(USE_COLOR_STYLE) || defined(USE_COLOR_TABLE)

#ifndef COLOR_WHITE

#define COLOR_WHITE 7

#endif

#ifndef COLOR_BLACK

#define COLOR_BLACK 0

#endif

#ifdef USE_DEFAULT_COLORS

int default_fg = DEFAULT_COLOR;

int default_bg = DEFAULT_COLOR;

#else

int default_fg = COLOR_WHITE;

int default_bg = COLOR_BLACK;

#endif

static const char *Color_Strings[16] =

{

    "black",

    "red",

    "green",

    "brown",

    "blue",

    "magenta",

    "cyan",

    "lightgray",

    "gray",

    "brightred",

    "brightgreen",

    "yellow",

    "brightblue",

    "brightmagenta",

    "brightcyan",

    "white"

};

#if defined(PDCURSES) && !defined(XCURSES)

/*

 * PDCurses (and possibly some other implementations) use a non-ANSI set of

 * codes for colors.

 */

static int ColorCode(int color)

{

    /* *INDENT-OFF* */

    static int map[] =

    {

	0,  4,  2,  6,  1,  5,  3,  7,

	8, 12, 10, 14,  9, 13, 11, 15

    };

    /* *INDENT-ON* */

    return map[color];

}

#else

#define ColorCode(color) (color)

#endif

BOOL default_color_reset = FALSE;

/*

 * Validator for COLOR fields.

 */

int check_color(const char *color,

		int the_default)

{

    int i;

    CTRACE2(TRACE_STYLE, (tfp, "check_color(%s,%d)\n", color, the_default));

    if (!strcasecomp(color, "default")) {

#ifdef USE_DEFAULT_COLORS

	if (LYuse_default_colors && !default_color_reset)

	    the_default = DEFAULT_COLOR;

#endif /* USE_DEFAULT_COLORS */

	CTRACE2(TRACE_STYLE, (tfp, "=> default %d\n", the_default));

	return the_default;

    }

    if (!strcasecomp(color, "nocolor"))

	return NO_COLOR;

    for (i = 0; i < 16; i++) {

	if (!strcasecomp(color, Color_Strings[i])) {

	    int c = ColorCode(i);

	    CTRACE2(TRACE_STYLE, (tfp, "=> %d\n", c));

	    return c;

	}

    }

    CTRACE2(TRACE_STYLE, (tfp, "=> ERR_COLOR\n"));

    return ERR_COLOR;

}

const char *lookup_color(int code)

{

    unsigned n;

    for (n = 0; n < 16; n++) {

	if ((int) ColorCode(n) == code)

	    return Color_Strings[n];

    }

    return "default";

}

#endif /* USE_COLOR_STYLE || USE_COLOR_TABLE */

#if defined(USE_COLOR_TABLE) || defined(EXP_ASSUMED_COLOR)

/*

 * Exit routine for failed COLOR parsing.

 */

static void exit_with_color_syntax(char *error_line)

{

    unsigned int i;

    fprintf(stderr, gettext("\

Syntax Error parsing COLOR in configuration file:\n\

The line must be of the form:\n\

COLOR:INTEGER:FOREGROUND:BACKGROUND\n\

\n\

Here FOREGROUND and BACKGROUND must be one of:\n\

The special strings 'nocolor' or 'default', or\n")

	);

    for (i = 0; i < 16; i += 4) {

	fprintf(stderr, "%16s %16s %16s %16s\n",

		Color_Strings[i], Color_Strings[i + 1],

		Color_Strings[i + 2], Color_Strings[i + 3]);

    }

    fprintf(stderr, "%s\nCOLOR:%s\n", gettext("Offending line:"), error_line);

    exit_immediately(EXIT_FAILURE);

}

#endif /* defined(USE_COLOR_TABLE) || defined(EXP_ASSUMED_COLOR) */

#if defined(USE_COLOR_TABLE)

/*

 * Process string buffer fields for COLOR setting.

 */

static void parse_color(char *buffer)

{

    int color;

    const char *fg, *bg;

    char *temp_fg = 0;

    /*

     * We are expecting a line of the form:

     *    INTEGER:FOREGROUND:BACKGROUND

     */

    color = atoi(buffer);

    if (NULL == (fg = find_colon(buffer)))

	exit_with_color_syntax(buffer);

    if (NULL == (bg = find_colon(++fg)))

	exit_with_color_syntax(buffer);

    StrAllocCopy(temp_fg, fg);

    temp_fg[bg++ - fg] = '\0';

#if defined(USE_SLANG)

    if ((check_color(temp_fg, default_fg) == ERR_COLOR) ||

	(check_color(bg, default_bg) == ERR_COLOR))

	exit_with_color_syntax(buffer);

    SLtt_set_color(color, NULL, temp_fg, bg);

#else

    if (lynx_chg_color(color,

		       check_color(temp_fg, default_fg),

		       check_color(bg, default_bg)) < 0)

	exit_with_color_syntax(buffer);

#endif

    FREE(temp_fg);

}

#endif /* USE_COLOR_TABLE */

/* *INDENT-OFF* */

#ifdef USE_SOURCE_CACHE

static Config_Enum tbl_source_cache[] = {

    { "FILE",	SOURCE_CACHE_FILE },

    { "MEMORY",	SOURCE_CACHE_MEMORY },

    { "NONE",	SOURCE_CACHE_NONE },

    { NULL,		-1 },

};

static Config_Enum tbl_abort_source_cache[] = {

    { "KEEP",	SOURCE_CACHE_FOR_ABORTED_KEEP },

    { "DROP",	SOURCE_CACHE_FOR_ABORTED_DROP },

    { NULL,		-1 },

};

#endif

/* *INDENT-ON* */

#define PARSE_ADD(n,v)   {n, CONF_ADD_ITEM,    UNION_ADD(v), 0}

#define PARSE_SET(n,v)   {n, CONF_BOOL,        UNION_SET(v), 0}

#define PARSE_ENU(n,v,t) {n, CONF_ENUM,        UNION_INT(v), t}

#define PARSE_INT(n,v)   {n, CONF_INT,         UNION_INT(v), 0}

#define PARSE_TIM(n,v)   {n, CONF_TIME,        UNION_INT(v), 0}

#define PARSE_STR(n,v)   {n, CONF_STR,         UNION_STR(v), 0}

#define PARSE_PRG(n,v)   {n, CONF_PRG,         UNION_DEF(v), 0}

#define PARSE_Env(n,v)   {n, CONF_ENV,         UNION_ENV(v), 0}

#define PARSE_ENV(n,v)   {n, CONF_ENV2,        UNION_ENV(v), 0}

#define PARSE_FUN(n,v)   {n, CONF_FUN,         UNION_FUN(v), 0}

#define PARSE_REQ(n,v)   {n, CONF_INCLUDE,     UNION_FUN(v), 0}

#define PARSE_LST(n,v)   {n, CONF_ADD_STRING,  UNION_LST(v), 0}

#define PARSE_DEF(n,v)   {n, CONF_ADD_TRUSTED, UNION_DEF(v), 0}

#define PARSE_NIL        {NULL, CONF_NIL,      UNION_DEF(0), 0}

typedef enum {

    CONF_NIL = 0

    ,CONF_BOOL			/* BOOLEAN type */

    ,CONF_FUN

    ,CONF_TIME

    ,CONF_ENUM

    ,CONF_INT

    ,CONF_STR

    ,CONF_PRG

    ,CONF_ENV			/* from environment variable */

    ,CONF_ENV2			/* from environment VARIABLE */

    ,CONF_INCLUDE		/* include file-- handle special */

    ,CONF_ADD_ITEM

    ,CONF_ADD_STRING

    ,CONF_ADD_TRUSTED

} Conf_Types;

typedef struct {

    const char *name;

    Conf_Types type;

      ParseData;

    Config_Enum *table;

} Config_Type;

static int assume_charset_fun(char *value)

{

    assumed_charset = TRUE;

    UCLYhndl_for_unspec = safeUCGetLYhndl_byMIME(value);

    StrAllocCopy(UCAssume_MIMEcharset,

		 LYCharSet_UC[UCLYhndl_for_unspec].MIMEname);

    CTRACE((tfp, "assume_charset_fun %s ->%d ->%s\n",

	    NonNull(value),

	    UCLYhndl_for_unspec,

	    UCAssume_MIMEcharset));

    return 0;

}

static int assume_local_charset_fun(char *value)

{

    UCLYhndl_HTFile_for_unspec = safeUCGetLYhndl_byMIME(value);

    return 0;

}

static int assume_unrec_charset_fun(char *value)

{

    UCLYhndl_for_unrec = safeUCGetLYhndl_byMIME(value);

    return 0;

}

static int character_set_fun(char *value)

{

    int i = UCGetLYhndl_byAnyName(value);	/* by MIME or full name */

    if (i < 0) {

#ifdef CAN_AUTODETECT_DISPLAY_CHARSET

	if (auto_display_charset >= 0

	    && (!strncasecomp(value, "AutoDetect ", 11)

		|| !strncasecomp(value, "AutoDetect-2 ", 13)))

	    current_char_set = auto_display_charset;

#endif

	/* do nothing here: so fallback to userdefs.h */

    } else {

	current_char_set = i;

    }

    return 0;

}

static int outgoing_mail_charset_fun(char *value)

{

    outgoing_mail_charset = UCGetLYhndl_byMIME(value);

    /* -1 if NULL or not recognized value: no translation (compatibility) */

    return 0;

}

#ifdef EXP_ASSUMED_COLOR

/*

 * Process string buffer fields for ASSUMED_COLOR setting.

 */

static int assumed_color_fun(char *buffer)

{

    const char *fg = buffer, *bg;

    char *temp_fg = 0;

    if (LYuse_default_colors) {

	/*

	 * We are expecting a line of the form:

	 *    FOREGROUND:BACKGROUND

	 */

	if (NULL == (bg = find_colon(fg)))

	    exit_with_color_syntax(buffer);

	StrAllocCopy(temp_fg, fg);

	temp_fg[bg++ - fg] = '\0';

	default_fg = check_color(temp_fg, default_fg);

	default_bg = check_color(bg, default_bg);

	if (default_fg == ERR_COLOR

	    || default_bg == ERR_COLOR)

	    exit_with_color_syntax(buffer);

	FREE(temp_fg);

    } else {

	CTRACE((tfp, "...ignored since DEFAULT_COLORS:off\n"));

    }

    return 0;

}

#endif /* EXP_ASSUMED_COLOR */

#ifdef USE_COLOR_TABLE

static int color_fun(char *value)

{

    parse_color(value);

    return 0;

}

#endif

#ifdef USE_COLOR_STYLE

static int lynx_lss_file_fun(char *value)

{

    CTRACE((tfp, "lynx_lss_file_fun '%s'\n", NonNull(value)));

    if (isEmpty(value)) {

	clear_lss_list();

    } else {

	add_to_lss_list(value, NULL);

    }

    return 0;

}

#endif

#ifdef USE_DEFAULT_COLORS

void update_default_colors(void)

{

    int old_fg = default_fg;

    int old_bg = default_bg;

    default_color_reset = !LYuse_default_colors;

    if (LYuse_default_colors) {

	default_color_reset = FALSE;

	default_fg = DEFAULT_COLOR;

	default_bg = DEFAULT_COLOR;

    } else {

	default_color_reset = TRUE;

	default_fg = COLOR_WHITE;

	default_bg = COLOR_BLACK;

    }

    if (old_fg != default_fg || old_bg != default_bg) {

	lynx_setup_colors();

#ifdef USE_COLOR_STYLE

	update_color_style();

#endif

    }

}

static int default_colors_fun(char *value)

{

    LYuse_default_colors = is_true(value);

    update_default_colors();

    return 0;

}

#endif

static int default_bookmark_file_fun(char *value)

{

    set_default_bookmark_page(value);

    return 0;

}

static int default_cache_size_fun(char *value)

{

    HTCacheSize = atoi(value);

    if (HTCacheSize < 2)

	HTCacheSize = 2;

    return 0;

}

static int default_editor_fun(char *value)

{

    if (!system_editor)

	StrAllocCopy(editor, value);

    return 0;

}

static int numbers_as_arrows_fun(char *value)

{

    if (is_true(value))

	keypad_mode = NUMBERS_AS_ARROWS;

    else

	keypad_mode = LINKS_ARE_NUMBERED;

    return 0;

}

#ifdef DIRED_SUPPORT

static int dired_menu_fun(char *value)

{

    add_menu_item(value);

    return 0;

}

#endif

static int jumpfile_fun(char *value)

{

    char *buffer = NULL;

    HTSprintf0(&buffer, "JUMPFILE:%s", value);

    if (!LYJumpInit(buffer))

	CTRACE((tfp, "Failed to register %s\n", buffer));

    FREE(buffer);

    return 0;

}

#ifdef EXP_KEYBOARD_LAYOUT

static int keyboard_layout_fun(char *key)

{

    if (!LYSetKbLayout(key))

	CTRACE((tfp, "Failed to set keyboard layout %s\n", key));

    return 0;

}

#endif /* EXP_KEYBOARD_LAYOUT */

static int keymap_fun(char *key)

{

    char *func, *efunc;

    if ((func = StrChr(key, ':')) != NULL) {

	*func++ = '\0';

	efunc = StrChr(func, ':');

	/* Allow comments on the ends of key remapping lines. - DT */

	/* Allow third field for line-editor action. - kw */

	if (efunc == func) {	/* have 3rd field, but 2nd field empty */

	    func = NULL;

	} else if (efunc && strncasecomp(efunc + 1, "DIRED", 5) == 0) {

	    if (!remap(key, strtok(func, " \t\n:#"), TRUE)) {

		fprintf(stderr,

			gettext("key remapping of %s to %s for %s failed\n"),

			key, func, efunc + 1);

	    } else if (!strcmp("TOGGLE_HELP", func)) {

		LYUseNoviceLineTwo = FALSE;

	    }

	    return 0;

	} else if (!remap(key, strtok(func, " \t\n:#"), FALSE)) {

	    fprintf(stderr, gettext("key remapping of %s to %s failed\n"),

		    key, func);

	} else {

	    if (!strcmp("TOGGLE_HELP", func))

		LYUseNoviceLineTwo = FALSE;

	}

	if (efunc) {

	    efunc++;

	    if (efunc == strtok((func ? NULL : efunc), " \t\n:#") && *efunc) {

		BOOLEAN success = FALSE;

		int lkc = lkcstring_to_lkc(key);

		int lec = -1;

		int select_edi = 0;

		char *sselect_edi = strtok(NULL, " \t\n:#");

		char **endp = &sselect_edi;

		if (sselect_edi) {

		    if (*sselect_edi)

			select_edi = (int) strtol(sselect_edi, endp, 10);

		    if (**endp != '\0') {

			fprintf(stderr,

				gettext("invalid line-editor selection %s for key %s, selecting all\n"),

				sselect_edi, key);

			select_edi = 0;

		    }

		}

		/*

		 * PASS!  tries to enter the key into the LYLineEditors

		 * bindings in a different way from PASS, namely as binding

		 * that maps to the specific lynx actioncode (rather than to

		 * LYE_FORM_PASS).  That only works for lynx keycodes with

		 * modifier bit set, and we have no documented/official way to

		 * specify this in the KEYMAP directive, although it can be

		 * made to work e.g. by specifying a hex value that has the

		 * modifier bit set.  But knowledge about the bit pattern of

		 * modifiers should remain in internal matter subject to

		 * change...  At any rate, if PASS!  fails try it the same way

		 * as for PASS.  - kw

		 */

		if (!success && strcasecomp(efunc, "PASS!") == 0) {

		    if (func) {

			lec = LYE_FORM_LAC | lacname_to_lac(func);

			success = (BOOL) LYRemapEditBinding(lkc, lec, select_edi);

		    }

		    if (!success)

			fprintf(stderr,

				gettext("setting of line-editor binding for key %s (0x%x) to 0x%x for %s failed\n"),

				key, lkc, lec, efunc);

		    else

			return 0;

		}

		if (!success) {

		    lec = lecname_to_lec(efunc);

		    success = (BOOL) LYRemapEditBinding(lkc, lec, select_edi);

		}

		if (!success) {

		    if (lec != -1) {

			fprintf(stderr,

				gettext("setting of line-editor binding for key %s (0x%x) to 0x%x for %s failed\n"),

				key, lkc, lec, efunc);

		    } else {

			fprintf(stderr,

				gettext("setting of line-editor binding for key %s (0x%x) for %s failed\n"),

				key, lkc, efunc);

		    }

		}

	    }

	}

    }

    return 0;

}

static int localhost_alias_fun(char *value)

{

    LYAddLocalhostAlias(value);

    return 0;

}

#ifdef LYNXCGI_LINKS

static int lynxcgi_environment_fun(char *value)

{

    add_lynxcgi_environment(value);

    return 0;

}

#endif

static int lynx_sig_file_fun(char *value)

{

    char temp[LY_MAXPATH];

    LYStrNCpy(temp, value, sizeof(temp) - 1);

    if (LYPathOffHomeOK(temp, sizeof(temp))) {

	StrAllocCopy(LynxSigFile, temp);

	LYAddPathToHome(temp, sizeof(temp), LynxSigFile);

	StrAllocCopy(LynxSigFile, temp);

	CTRACE((tfp, "LYNX_SIG_FILE set to '%s'\n", LynxSigFile));

    } else {

	CTRACE((tfp, "LYNX_SIG_FILE '%s' is bad. Ignoring.\n", LYNX_SIG_FILE));

    }

    return 0;

}

#ifndef DISABLE_NEWS

static int news_chunk_size_fun(char *value)

{

    HTNewsChunkSize = atoi(value);

    /*

     * If the new HTNewsChunkSize exceeds the maximum,

     * increase HTNewsMaxChunk to this size. - FM

     */