options.c

/*
 * Copyright (c) 2002, 2003, 2004, Scott Nicol <esniper@users.sf.net>
 * All rights reserved
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice,
 *   this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * This program will "snipe" an auction on eBay, automatically placing
 * your bid a few seconds before the auction ends.
 *
 * For updates, bug reports, etc, please go to http://esniper.sf.net/.
 */

#include "options.h"
#include "buffer.h"
#include "esniper.h"
#include "util.h"
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>

static int parseConfigValue(const char *name, const char *value,
			    optionTable_t *table, const char *filename,
			    const char *line);
static int parseBoolValue(const char *name, const char *value,
			  optionTable_t *tableptr, const char *filename,
			  const char *line, int neg);
static int parseStringValue(const char *name, const char *value,
			    optionTable_t *tableptr, const char *filename,
			    const char *line);
static int parseIntValue(const char *name, const char *value,
			 optionTable_t *tableptr, const char *filename,
			 const char *line);
static int parseSpecialValue(const char *name, const char *value,
			     optionTable_t *tableptr,
			     const char *filename, const char *line);

/*
 * readConfigFile(): read configuration from file, skipping auctions
 *
 * returns:
 *	0 file successfully read, even if no configuration options found
 *	1 file not found
 *	2 other error
 */
int
readConfigFile(const char *filename, optionTable_t *table)
{
	char *buf = NULL;
	size_t bufsize = 0, count = 0;
	int c, ret = 0;
	FILE *fp = fopen(filename, "r");

	if (fp == NULL) {
		/* file not found is OK */
		if (errno == ENOENT)
			return 1;
		printLog(stderr, "Cannot open %s: %s\n", filename,
			 strerror(errno));
		return 2;
	}

	while ((c = getc(fp)) != EOF) {
		if (isspace(c))
			continue;
		/* skip comments and anything starting with a number,
		 * assuming this is an auction entry */
		if ((c == '#') || isdigit(c))
			c = skipline(fp);
		else if (isalpha(c)) {
			char *name = NULL, *value = NULL;

			count = 0;
			do {
				addchar(buf, bufsize, count, (char)c);
				c = getc(fp);
			} while (c != EOF && !isspace(c) && c != '=');
			addchar(buf, bufsize, count, '\0');
			name = buf;

			if (c != EOF && c != '\n' && c != '\r') {
				do {
					c = getc(fp);
				} while (c == ' ' || c == '\t');
				if (c == '=') {
					do {
						c = getc(fp);
					} while (c == ' ' || c == '\t');
				}

				if (c != EOF && c != '\n' && c != '\r') {
					value = &buf[count];
					do {
						addchar(buf, bufsize, count, (char)c);
						c = getc(fp);
					} while (c != EOF && c != '\n' && c != '\r');
					/* strip trailing whitespace */
					while (isspace((int)(buf[count - 1])))
						--count;
					term(buf, bufsize, count);
				}
			}
			if (parseConfigValue(name, value, table, filename, buf))
				ret = 2;
		}

		/* don't read EOF twice! */
		if (c == EOF)
			break;
	}

	if (ferror(fp)) {
		printLog(stderr, "Cannot read %s: %s\n", filename,
			 strerror(errno));
		ret = 2;
	}
	fclose(fp);
	free(buf);
	return ret;
} /* readConfigFile() */

/*
 * parseGetoptValue(): parse option character and value
 *
 * returns: 0 = OK, else error
 */
int
parseGetoptValue(int option, const char *optval, optionTable_t *table)
{
	char optstr[] = { '\0', '\0' };

	optstr[0] = (char)option;
	/* optval "" should be handled the same as empty configuration option */
	if (optval && !*optval)
		optval = NULL;
	/* filename NULL means command line option */
	return parseConfigValue(optstr, optval, table, NULL, optstr);
}

/*
 * parseConfigValue(): lookup command line or configuration option in option
 *		table and call appropriate function according to table entry.
 *
 * returns: 0 = OK, else error
 */
static int
parseConfigValue(const char *name, const char *value,
	optionTable_t *table, const char *filename, const char *line)
{
	optionTable_t *tableptr;
	const char *tablename;
	int ret = 0;

	if (strcmp(name, "password")) {
		log(("parsing name %s value %s\n", name, nullStr(value)));
	}

	/* lookup name in table */
	for (tableptr=table; tableptr->value; tableptr++) {
		tablename = filename ?
				tableptr->configname : tableptr->optionname;
		if (tablename && !strcmp(name, tablename))
			break;
	}
	if (tableptr->value) {	/* found */
		switch (tableptr->type) {
		case OPTION_BOOL:
		case OPTION_BOOL_NEG:
			ret = parseBoolValue(name, value, tableptr, filename,
				line, (tableptr->type == OPTION_BOOL_NEG));
			break;
		case OPTION_STRING:
			ret = parseStringValue(name, value, tableptr, filename,
				line);
			break;
		case OPTION_SPECINT:
		case OPTION_SPECSTR:
			ret = parseSpecialValue(name, value, tableptr, filename,
				line);
			break;
		case OPTION_INT:
			ret = parseIntValue(name, value, tableptr, filename,
				line);
			break;
		default:
			printLog(stderr, "Internal error: invalid type in option table (%s)", tableptr->configname ? tableptr->configname : tableptr->optionname);
			ret = 1;
		}
	} else {
		if (filename)
			printLog(stderr, "Unknown configuration entry \"%s\" in file %s\n", line, filename);
		else
			printLog(stderr, "Unknown command line option -%s\n",
				 line);
		ret = 1;
	}
	return ret;
}

/*
 * parseBoolValue(): parse a boolean value
 *
 * returns: 0 = OK, else error
 */
static int
parseBoolValue(const char *name, const char *value,
	optionTable_t *tableptr, const char *filename, const char *line,
	int neg)
{
	int intval = boolValue(value);

	if (intval == -1) {
		if (filename)
			printLog(stderr, "Invalid boolean value in file %s, line \"%s\"\n", filename, line);
		else
			printLog(stderr, "Invalid boolean value \"%s\" at command line option -%s\n", value, line);
		return 1;
	}
	if (neg)
		intval = !intval;
	if (tableptr->checkfunc) { /* check value with check function */
		if ((*tableptr->checkfunc)(&intval, tableptr, filename, line))
			return 1;
	} else
		*(int*)(tableptr->value) = intval;
	tableptr->isSet++;
	log(("bool value for %s is %d\n", name, *(int*)(tableptr->value)));
	return 0;
}

/*
 * parseStringValue(): parse a string value, call checking func if specified
 *
 * returns: 0 = OK, else error
 */
static int
parseStringValue(const char *name, const char *value,
	optionTable_t *tableptr, const char *filename, const char *line)
{
	if (tableptr->checkfunc) {
		/* Check value with specific check function.
		 * Check function is responsible for allocating/freeing values
		 */
		if ((*tableptr->checkfunc)(value, tableptr, filename, line))
			return 1;
	} else {
		free(*(char**)(tableptr->value));
		*(char**)(tableptr->value) = myStrdup(value);
	}
	tableptr->isSet++;
	log(("string value for %s is \"%s\"\n",
	     name, nullStr(*(char**)(tableptr->value))));
	return 0;
}

/*
 * parseSpecialValue(): parse a special value, which is is not interpreted here
 *			A checking func is required to convert/check value.
 *
 * returns: 0 = OK, else error
 */
static int
parseSpecialValue(const char *name, const char *value,
	optionTable_t *tableptr, const char *filename, const char *line)
{
	if (tableptr->checkfunc) { /* check value with check function */
		if ((*tableptr->checkfunc)(value, tableptr, filename, line))
			return 1;
	} else {
		printLog(stderr, "Internal error: special type needs check function in option table (%s)", tableptr->configname ? tableptr->configname : tableptr->optionname);
		return 1;
	}
	tableptr->isSet++;
	return 0;
}

/*
 * parseIntValue(): parse an integer value, call checking func if specified
 *
 * returns: 0 = OK, else error
 */
static int
parseIntValue(const char *name, const char *value,
	optionTable_t *tableptr, const char *filename, const char *line)
{
	long longval;
	int intval;
	char *endptr;

	if (!value) {
		if (filename)
			printLog(stderr, "Configuration option \"%s\" in file %s needs an integer value\n", line, filename);
		else
			printLog(stderr, "Option -%s needs an integer value\n",
				 line);
		return 1;
	}
	longval = strtol(value, &endptr, 10);
	if (*endptr != '\0' || longval > INT_MAX || longval < INT_MIN) {
		if (filename)
			printLog(stderr, "Invalid integer value at configuration option \"%s\" in file %s\n", line, filename);
		else
			printLog(stderr, "Invalid integer value \"%s\" at command line option -%s\n", value, line);
		return 1;
	}
	intval = (int)longval;

	if (tableptr->checkfunc) {
		/* check value with specific check function */
		if ((*tableptr->checkfunc)(&intval, tableptr, filename, line))
			return 1;
	} else
		*(int*)(tableptr->value) = intval;
	tableptr->isSet++;
	log(("integer value for %s is %d\n", name, *(int*)(tableptr->value)));
	return 0;
}

/**
 * Write all user-specified option values to a buffer.
 * The buffer is dynamically allocated and must be freed by the caller.
 *
 * @param table pointer to the option table
 * @return pointer to text buffer
 */
char * logOptionValues(const optionTable_t *table)
{
	char *res = myStrdup("\tspecified options or config values:\n");
	char *tmp;
	char buf[1024];
	const optionTable_t *tableptr;
	for(tableptr = table; NULL != tableptr->value; ++tableptr)
	{
		if(tableptr->isSet)
		{
			if(tableptr->logging == LOG_NORMAL)
			{
				switch(tableptr->type)
				{
				case OPTION_STRING:
				case OPTION_SPECSTR:
					sprintf(buf, "\t %2d x %.15s(%.15s) = \"%.900s\"\n",
						tableptr->isSet,
						nullEmptyStr(tableptr->configname),
						nullEmptyStr(tableptr->optionname),
						nullStr(*(char**)(tableptr->value))
						);
					break;
				case OPTION_INT:
				case OPTION_SPECINT:
				case OPTION_BOOL:
				case OPTION_BOOL_NEG:
					sprintf(buf, "\t %2d x %.15s(%.15s) = %d\n",
						tableptr->isSet,
						nullEmptyStr(tableptr->configname),
						nullEmptyStr(tableptr->optionname),
						*(int*)(tableptr->value)
						);
					break;
				default:
					sprintf(buf, "\t %2d x %.15s(%.15s) = (unknown type)\n",
						tableptr->isSet,
						nullEmptyStr(tableptr->configname),
						nullEmptyStr(tableptr->optionname)
						);
					break;
				}
			} else {
				sprintf(buf, "\t %2d x %.15s(%.15s) = ***\n",
					tableptr->isSet,
					nullEmptyStr(tableptr->configname),
					nullEmptyStr(tableptr->optionname)
					);
			}
			tmp = myStrdup2(res, buf);
			free(res);
			res = tmp;
		}
	}
	return res;
}