/* dot.conf - configuration file parser library
 * Copyright (C) 1999,2000,2001,2002 Lukas Schroeder <lukas@azzit.de>,
 *   and others.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 *
 */

/* -- dotconf.c - this code is responsible for the input, parsing and dispatching of options  */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Added by Stephen W. Boyer <sboyer@caldera.com>
 * for wildcard support in Include file paths
 */
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/stat.h>

/* -- AIX 4.3 compile time fix
 * by Eduardo Marcel Macan <macan@colband.com.br>
 *
 * modified by Stephen W. Boyer <sboyer@caldera.com>
 * for Unixware and OpenServer
 */

#if defined (_AIX43) || defined(UNIXWARE) || defined(OSR5)
#include <strings.h>
#endif

#include <stdarg.h>
#include <time.h>
#include <sys/stat.h>

#ifndef WIN32

#include <dirent.h>
#include <unistd.h>

#else /* ndef WIN32 */

#include "readdir.h"		/* WIN32 fix by Robert J. Buck */

#define strncasecmp strnicmp
typedef unsigned long ulong;
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#endif /* !WIN32 */

#include <ctype.h>
#include "dotconf.h"
#include "dotconf_priv.h"

#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif

static char name[CFG_MAX_OPTION + 1];	/* option name */

/*
 * some 'magic' options that are predefined by dot.conf itself for
 * advanced functionality
 */
static DOTCONF_CB(dotconf_cb_include);	/* internal 'Include'     */
static DOTCONF_CB(dotconf_cb_includepath);	/* internal 'IncludePath' */

static configoption_t dotconf_options[] = {
	{"Include", ARG_STR, dotconf_cb_include, NULL, CTX_ALL},
	{"IncludePath", ARG_STR, dotconf_cb_includepath, NULL, CTX_ALL},
	LAST_CONTEXT_OPTION
};

static void skip_whitespace(signed char **cp, int n, char term)
{
	signed char *cp1 = *cp;
	while (isspace((int)*cp1) && *cp1 != term && n--)
		cp1++;
	*cp = cp1;
}

static void copy_word(signed char **dest, signed char **src, int max, char term)
{
	signed char *cp1 = *src;
	signed char *cp2 = *dest;
	while (max-- && !isspace((int)*cp1) && *cp1 != term)
		*cp2++ = *cp1++;
	*cp2 = 0;

	*src = cp1;
	*dest = cp2;
}

static const configoption_t *get_argname_fallback(const configoption_t *
						  options)
{
	int i;

	for (i = 0; (options[i].name && options[i].name[0]); i++) ;
	if (options[i].type == ARG_NAME && options[i].callback)
		return &options[i];
	return NULL;
}

char *dotconf_substitute_env(configfile_t * configfile, char *str)
{
	char *cp1, *cp2, *cp3, *eos, *eob;
	char *env_value;
	char env_name[CFG_MAX_VALUE + 1];
	char env_default[CFG_MAX_VALUE + 1];
	char tmp_value[CFG_MAX_VALUE + 1];

	memset(env_name, 0, CFG_MAX_VALUE + 1);
	memset(env_default, 0, CFG_MAX_VALUE + 1);
	memset(tmp_value, 0, CFG_MAX_VALUE + 1);

	cp1 = str;
	eob = cp1 + strlen(str) + 1;
	cp2 = tmp_value;
	eos = cp2 + CFG_MAX_VALUE + 1;

	while ((cp1 < eob) && (cp2 < eos) && (*cp1 != '\0')) {
		/* substitution needed ?? */
		if (*cp1 == '$' && *(cp1 + 1) == '{') {
			cp1 += 2;	/* skip ${ */
			cp3 = env_name;
			while ((cp1 < eob) && !(*cp1 == '}' || *cp1 == ':'))
				*cp3++ = *cp1++;
			*cp3 = '\0';	/* terminate */

			/* default substitution */
			if (*cp1 == ':' && *(cp1 + 1) == '-') {
				cp1 += 2;	/* skip :- */
				cp3 = env_default;
				while ((cp1 < eob) && (*cp1 != '}'))
					*cp3++ = *cp1++;
				*cp3 = '\0';	/* terminate */
			} else {
				while ((cp1 < eob) && (*cp1 != '}'))
					cp1++;
			}

			if (*cp1 != '}') {
				dotconf_warning(configfile, DCLOG_WARNING,
						ERR_PARSE_ERROR,
						"Unbalanced '{'");
			} else {
				cp1++;	/* skip } */
				if ((env_value = getenv(env_name)) != NULL) {
					strncat(cp2, env_value, eos - cp2);
					cp2 += strlen(env_value);
				} else {
					strncat(cp2, env_default, eos - cp2);
					cp2 += strlen(env_default);
				}
			}

		}

		*cp2++ = *cp1++;
	}
	*cp2 = '\0';		/* terminate buffer */

	free(str);
	return strdup(tmp_value);
}

int dotconf_warning(configfile_t * configfile, int type, unsigned long errnum,
		    const char *fmt, ...)
{
	va_list args;
	int retval = 0;

	va_start(args, fmt);
	if (configfile->errorhandler != 0) {	/* an errorhandler is registered */
		char msg[CFG_BUFSIZE];
		vsnprintf(msg, CFG_BUFSIZE, fmt, args);
		retval =
		    configfile->errorhandler(configfile, type, errnum, msg);
	} else {		/* no errorhandler, do-it-yourself */

		retval = 0;
		fprintf(stderr, "%s:%ld: ", configfile->filename,
			configfile->line);
		vfprintf(stderr, fmt, args);
		fprintf(stderr, "\n");
	}
	va_end(args);

	return retval;
}

int dotconf_register_options(configfile_t * configfile,
			     const configoption_t * options)
{
	int num = configfile->config_option_count;
	int ret = 0;
	configoption_t const **temp = configfile->config_options;

#define GROW_BY   10

	/* resize memoryblock for options blockwise */
	if (temp == NULL)
		temp = malloc(sizeof(configoption_t *) * (GROW_BY + 1));
	else {
		if (!(num % GROW_BY))
			temp = realloc(temp,
				       sizeof(configoption_t *) * (num +
								   GROW_BY +
								   1));
	}

#undef GROW_BY

	if (temp != NULL) {
		/* Allocation or reallocation was successful. */
		/* append new options */
		temp[configfile->config_option_count] = options;
		configfile->config_options = temp;
		configfile->config_options[++configfile->config_option_count] =
		    0;
		ret = 1;
	}

	return ret;
}

void dotconf_callback(configfile_t * configfile, callback_types type,
		      dotconf_callback_t callback)
{
	switch (type) {
	case ERROR_HANDLER:
		configfile->errorhandler = (dotconf_errorhandler_t) callback;
		break;
	case CONTEXT_CHECKER:
		configfile->contextchecker =
		    (dotconf_contextchecker_t) callback;
		break;
	default:
		break;
	}
}

int dotconf_continue_line(char *buffer, size_t length)
{
	/* ------ match [^\\]\\[\r]\n ------------------------------ */
	char *cp1 = buffer + length - 1;
	int backtrack = 0;

	if (length == 0)			/* empty line */
		return 0;

	if (*cp1-- != '\n')			/* terminates, no newline */
		return 0;

	backtrack++;

	if (cp1 < buffer)			/* just newline */
		return 0;

	if (*cp1 == '\r') {
		cp1--;
		backtrack++;
	}

	if (cp1 < buffer)			/* just carriage return + newline */
		return 0;

	if (*cp1-- != '\\')
		return 0;

	backtrack++;

	if (cp1 < buffer || *cp1 != '\\')	/* maybe empty line with just escape */
		return backtrack;

	return 0;
}

int dotconf_get_next_line(char *buffer, size_t bufsize,
			  configfile_t * configfile)
{
	char *cp1;
	int length, backtrack;

	if (configfile->eof)
		return 1;

	cp1 = fgets(buffer, bufsize, configfile->stream);

	if (!cp1) {
		configfile->eof = 1;
		return 1;
	}

	configfile->line++;
	length = strlen(cp1);
	while (length < (bufsize - 1) && (backtrack = dotconf_continue_line(buffer, length))) {
		length -= backtrack;
		cp1 = fgets(buffer + length, bufsize - length, configfile->stream);
		if (!cp1) {
			fprintf(stderr,
				"[dotconf] Parse error. Unexpected end of file at "
				"line %ld in file %s\n", configfile->line,
				configfile->filename);
			configfile->eof = 1;
			return 1;
		}
		configfile->line++;
		length += strlen(cp1);
	}

	return 0;
}

char *dotconf_get_here_document(configfile_t * configfile, const char *delimit)
{
	/* it's a here-document: yeah, what a cool feature ;) */
	unsigned int limit_len;
	char here_string;
	char buffer[CFG_BUFSIZE];
	char *here_doc = 0;
	char here_limit[9];	/* max length for here-document delimiter: 8 */
	struct stat finfo;
	int offset = 0;

	if (configfile->size <= 0) {
		if (stat(configfile->filename, &finfo)) {
			dotconf_warning(configfile, DCLOG_EMERG, ERR_NOACCESS,
					"[emerg] could not stat currently read file (%s)\n",
					configfile->filename);
			return NULL;
		}
		configfile->size = finfo.st_size;
	}

	/*
	 * allocate a buffer of filesize bytes; should be enough to
	 * prevent buffer overflows
	 */
	here_doc = malloc(configfile->size);	/* allocate buffer memory */
	memset(here_doc, 0, configfile->size);

	here_string = 1;
	limit_len = snprintf(here_limit, 9, "%s", delimit);
	while (!dotconf_get_next_line(buffer, CFG_BUFSIZE, configfile)) {
		if (!strncmp(here_limit, buffer, limit_len - 1)) {
			here_string = 0;
			break;
		}
		offset +=
		    snprintf((here_doc + offset), configfile->size - offset - 1,
			     "%s", buffer);
	}
	if (here_string)
		dotconf_warning(configfile, DCLOG_WARNING, ERR_PARSE_ERROR,
				"Unterminated here-document!");

	here_doc[offset - 1] = '\0';	/* strip newline */

	return (char *)realloc(here_doc, offset);
}

const char *dotconf_invoke_command(configfile_t * configfile, command_t * cmd)
{
	const char *error = 0;

	error = cmd->option->callback(cmd, configfile->context);
	return error;
}

char *dotconf_read_arg(configfile_t * configfile, signed char **line)
{
	int sq = 0, dq = 0;	/* single quote, double quote */
	int done;
	signed char *cp1 = *line;
	char *cp2, *eos;
	char buf[CFG_MAX_VALUE];

	memset(buf, 0, CFG_MAX_VALUE);
	done = 0;
	cp2 = buf;
	eos = cp2 + CFG_MAX_VALUE - 1;

	if (*cp1 == '#' || !*cp1)
		return NULL;

	skip_whitespace(&cp1, CFG_MAX_VALUE, 0);

	while ((*cp1 != '\0') && (cp2 != eos) && !done) {
		switch (*cp1) {
		case '\'':	/* single quote */
			if (dq)
				break;	/* already double quoting, break out */
			if (sq)
				sq--;	/* already single quoting, clear state */
			else if (!sq)
				sq++;	/* set state for single quoting */
			break;
		case '"':	/* double quote */
			if (sq)
				break;	/* already single quoting, break out */
			if (dq)
				dq--;	/* already double quoting, clear state */
			else if (!dq)
				dq++;	/* set state for double quoting */
			break;
		case '\\':	/* protected chars */
			if (!cp1[1])	/* dont protect NUL */
				break;
			*cp2++ = *(++cp1);
			cp1++;	/* skip the protected one */
			continue;
			break;
		default:
			break;
		}

		/* unquoted space: start a new option argument */
		if (isspace((int)*cp1) && !dq && !sq) {
			*cp2 = '\0';
			break;
		}
		/* unquoted, unescaped comment-hash ; break out, unless NO_INLINE_COMMENTS is set */
		else if (*cp1 == '#' && !dq && !sq
			 && !(configfile->flags & NO_INLINE_COMMENTS)) {
			/* 
			 * NOTE: 1.0.8a got the NO_INLINE_COMMENTS feature wrong: it
			 * skipped every argument starting with a #, instead of simply eating it!
			 */

			*cp2 = 0;
			*cp1 = 0;
			*line = cp1;
			return NULL;
		}
		/* not space or quoted: eat it; dont take quote if quoting */
		else if ((!isspace((int)*cp1) && !dq && !sq && *cp1 != '"'
			  && *cp1 != '\'')
			 || (dq && (*cp1 != '"')) || (sq && *cp1 != '\'')) {
			*cp2++ = *cp1;
		}

		cp1++;
	}

	*line = cp1;

	/* FIXME: escaping substitutes does not work
	   Subst ${HOME} \$\{HOME\}
	   BOTH! will be substituted, which is somewhat wrong, ain't it ?? :-(
	 */
	if ((configfile->flags & DONT_SUBSTITUTE) == DONT_SUBSTITUTE)
		return buf[0] ? strdup(buf) : NULL;
	return buf[0] ? dotconf_substitute_env(configfile, strdup(buf)) : NULL;
}

/* dotconf_find_command remains here for backwards compatability. it's
 * internally unused since dot.conf 1.0.9 because it cannot handle the
 * DUPLICATE_OPTION_NAMES flag
 */
configoption_t *dotconf_find_command(configfile_t * configfile,
				     const char *command)
{
	configoption_t *option;
	int i = 0, mod = 0, done = 0;

	for (option = 0, mod = 0; configfile->config_options[mod] && !done;
	     mod++)
		for (i = 0; configfile->config_options[mod][i].name[0]; i++) {
			if (!configfile->cmp_func(name,
						  configfile->
						  config_options[mod][i].name,
						  CFG_MAX_OPTION)) {
				option =
				    (configoption_t *) & configfile->
				    config_options[mod][i];
				/* TODO: this could be flagged: option overwriting by modules */
				done = 1;
				break;	/* found it; break out */
			}
		}

	/* handle ARG_NAME fallback */
	if ((option && option->name[0] == 0)
	    || configfile->config_options[mod - 1][i].type == ARG_NAME) {
		option =
		    (configoption_t *) & configfile->config_options[mod - 1][i];
	}

	return option;
}

void dotconf_set_command(configfile_t * configfile,
			 const configoption_t * option, signed char *args,
			 command_t * cmd)
{
	signed char *eob = args + strlen(args);

	/* fill in the command_t structure with values we already know */
	cmd->name = option->type == ARG_NAME ? name : option->name;
	cmd->option = (configoption_t *) option;
	cmd->context = configfile->context;
	cmd->configfile = configfile;
	cmd->data.list = (char **)calloc(CFG_VALUES, sizeof(char *));
	cmd->data.str = 0;

	if (option->type == ARG_RAW) {
		/* if it is an ARG_RAW type, save some time and call the
		   callback now */
		cmd->data.str = strdup(args);
	} else if (option->type == ARG_STR) {
		signed char *cp = args;

		/* check if it's a here-document and act accordingly */
		skip_whitespace(&cp, eob - cp, 0);

		if (!strncmp("<<", cp, 2)) {
			cmd->data.str =
			    dotconf_get_here_document(configfile, cp + 2);
			cmd->arg_count = 1;
		}
	}

	if (!(option->type == ARG_STR && cmd->data.str != 0)) {
		/* we only get here for non-heredocument lines */

		skip_whitespace(&args, eob - args, 0);

		cmd->arg_count = 0;
		while (cmd->arg_count < (CFG_VALUES - 1)
		       && (cmd->data.list[cmd->arg_count] =
			   dotconf_read_arg(configfile, &args))) {
			cmd->arg_count++;
		}

		skip_whitespace(&args, eob - args, 0);

		if (cmd->arg_count && cmd->data.list[cmd->arg_count - 1]
		    && *args)
			cmd->data.list[cmd->arg_count++] = strdup(args);

		/* has an option entry been found before or do we have to use a fallback? */
		if ((option->name && option->name[0] > 32)
		    || option->type == ARG_NAME) {
			/* found it, now check the type of args it wants */
			switch (option->type) {
			case ARG_TOGGLE:
				/* the value is true if the argument is Yes, On or 1 */
				if (cmd->arg_count < 1) {
					dotconf_warning(configfile,
							DCLOG_WARNING,
							ERR_WRONG_ARG_COUNT,
							"Missing argument to option '%s'",
							name);
					return;
				}

				cmd->data.value =
				    CFG_TOGGLED(cmd->data.list[0]);
				break;
			case ARG_INT:
				if (cmd->arg_count < 1) {
					dotconf_warning(configfile,
							DCLOG_WARNING,
							ERR_WRONG_ARG_COUNT,
							"Missing argument to option '%s'",
							name);
					return;
				}

				sscanf(cmd->data.list[0], "%li",
				       &cmd->data.value);
				break;

			case ARG_DOUBLE:
				if (cmd->arg_count < 1) {
					dotconf_warning(configfile,
							DCLOG_WARNING,
							ERR_WRONG_ARG_COUNT,
							"Missing argument to option '%s'",
							name);
					return;
				}

				cmd->data.dvalue = strtod(cmd->data.list[0], 0);
				break;

			case ARG_STR:
				if (cmd->arg_count < 1) {
					dotconf_warning(configfile,
							DCLOG_WARNING,
							ERR_WRONG_ARG_COUNT,
							"Missing argument to option '%s'",
							name);
					return;
				}

				cmd->data.str = strdup(cmd->data.list[0]);
				break;
			case ARG_NAME:	/* fall through */
			case ARG_LIST:
			case ARG_NONE:
			case ARG_RAW:	/* this has been handled before */
			default:
				break;
			}
		}
	}
}

void dotconf_free_command(command_t * command)
{
	int i;

	if (command->data.str)
		free(command->data.str);

	for (i = 0; i < command->arg_count; i++)
		free(command->data.list[i]);
	free(command->data.list);
}

const char *dotconf_handle_command(configfile_t * configfile, char *buffer)
{
	signed char *cp1;
	signed char *cp2;
	/* generic char pointer      */
	signed char *eob;	/* end of buffer; end of string  */
	const char *error;	/* error message we'll return */
	const char *context_error;	/* error message returned by contextchecker */
	command_t command;	/* command structure */
	int mod = 0;
	int next_opt_idx = 0;

	memset(&command, 0, sizeof(command_t));
	name[0] = 0;
	error = 0;
	context_error = 0;

	cp1 = buffer;
	eob = cp1 + strlen(cp1);

	skip_whitespace(&cp1, eob - cp1, 0);

	/* ignore comments and empty lines */
	if (!cp1 || !*cp1 || *cp1 == '#' || *cp1 == '\n' || *cp1 == EOF)
		return NULL;

	/* skip line if it only contains whitespace */
	if (cp1 == eob)
		return NULL;

	/* get first token: read the name of a possible option */
	cp2 = name;
	copy_word(&cp2, &cp1, MIN(eob - cp1, CFG_MAX_OPTION), 0);

	while (1) {
		const configoption_t *option;
		int done = 0;
		int opt_idx = 0;

		for (option = 0; configfile->config_options[mod] && !done;
		     mod++) {
			for (opt_idx = next_opt_idx;
			     configfile->config_options[mod][opt_idx].name[0];
			     opt_idx++) {
				if (!configfile->
				    cmp_func(name,
					     configfile->
					     config_options[mod][opt_idx].name,
					     CFG_MAX_OPTION)) {
					/* TODO: this could be flagged: option overwriting by modules */
					option =
					    (configoption_t *) & configfile->
					    config_options[mod][opt_idx];
					done = 1;
					break;	/* found one; break out */
				}
			}
		}

		if (!option)
			option =
			    get_argname_fallback(configfile->config_options[1]);

		if (!option || !option->callback) {
			if (error)
				return error;
			dotconf_warning(configfile, DCLOG_INFO,
					ERR_UNKNOWN_OPTION,
					"Unknown Config-Option: '%s'", name);
			return NULL;
		}

		/* set up the command structure (contextchecker wants this) */
		dotconf_set_command(configfile, option, cp1, &command);

		if (configfile->contextchecker)
			context_error =
			    configfile->contextchecker(&command,
						       command.option->context);

		if (!context_error)
			error = dotconf_invoke_command(configfile, &command);
		else {
			if (!error) {
				/* avoid returning another error then the first. This makes it easier to
				   reproduce problems. */
				error = context_error;
			}
		}

		dotconf_free_command(&command);

		if (!context_error
		    || !(configfile->flags & DUPLICATE_OPTION_NAMES)) {
			/* don't try more, just quit now. */
			break;
		}
	}

	return error;
}

const char *dotconf_command_loop_until_error(configfile_t * configfile)
{
	char buffer[CFG_BUFSIZE];

	while (!(dotconf_get_next_line(buffer, CFG_BUFSIZE, configfile))) {
		const char *error = dotconf_handle_command(configfile, buffer);
		if (error)
			return error;
	}
	return NULL;
}

int dotconf_command_loop(configfile_t * configfile)
{
	/* ------ returns: 0 for failure -- !0 for success ------------------------------------------ */
	char buffer[CFG_BUFSIZE];

	while (!(dotconf_get_next_line(buffer, CFG_BUFSIZE, configfile))) {
		const char *error = dotconf_handle_command(configfile, buffer);
		if (error != NULL) {
			if (dotconf_warning(configfile, DCLOG_ERR, 0, error))
				return 0;
		}
	}
	return 1;
}

void dotconf_cleanup(configfile_t * configfile)
{
	if (configfile->stream)
		fclose(configfile->stream);

	if (configfile->filename)
		free(configfile->filename);

	if (configfile->config_options)
		free(configfile->config_options);

	if (configfile->includepath)
		free(configfile->includepath);

	free(configfile);
}

configfile_t *dotconf_create(char *fname, const configoption_t * options,
			     context_t * context, unsigned long flags)
{
	char *dc_env = NULL;
	int registered = 0;
	configfile_t *new_cfg = calloc(1, sizeof(configfile_t));
	char *path = NULL;
	char *cwd = NULL;

	if (!new_cfg)
		return NULL;

	/*
	 * From here on, we can use dotconf_cleanup to free resources
	 * when errors occur.  All of our pointers are NULL, because
	 * we allocated with calloc.  When an error occurs, dotconf_cleanup
	 * will free all of the resources that were allocated prior to the
	 * error.
	 */

	new_cfg->context = context;
	new_cfg->flags = flags;
	if (new_cfg->flags & CASE_INSENSITIVE)
		new_cfg->cmp_func = strncasecmp;
	else
		new_cfg->cmp_func = strncmp;

	new_cfg->stream = fopen(fname, "r");
	if (new_cfg->stream == NULL) {
		fprintf(stderr, "Error opening configuration file '%s'\n",
			fname);
		dotconf_cleanup(new_cfg);
		return NULL;
	}

	registered = dotconf_register_options(new_cfg, dotconf_options);
	if (!registered) {
		dotconf_cleanup(new_cfg);
		return NULL;
	}

	registered = dotconf_register_options(new_cfg, options);
	if (!registered) {
		dotconf_cleanup(new_cfg);
		return NULL;
	}

	new_cfg->filename = strdup(fname);
	if (!new_cfg->filename) {
		dotconf_cleanup(new_cfg);
		return NULL;
	}

	new_cfg->includepath = malloc(CFG_MAX_FILENAME);
	if (!new_cfg->includepath) {
		dotconf_cleanup(new_cfg);
		return NULL;
	}

	new_cfg->includepath[0] = 0x00;

	/*
	 * take default includepath from environment if present
	 * Otherwise, resolve the path of the configuration file and use that
	 * as default includepath.
	 */
	dc_env = getenv(CFG_INCLUDEPATH_ENV);
	if (dc_env != NULL) {
		snprintf(new_cfg->includepath, CFG_MAX_FILENAME, "%s", dc_env);
	} else {
		path = get_path(fname);
		if (path != NULL) {
			if (path[0] == '/') {
				snprintf(new_cfg->includepath, CFG_MAX_FILENAME, "%s", path);
			} else {
				cwd = get_cwd();
				if (cwd != NULL) {
					snprintf(new_cfg->includepath, CFG_MAX_FILENAME,
						"%s/%s", cwd, path);
					free(cwd);
				}
			}
			free(path);
		}
	}
	return new_cfg;
}

/* ------ internal utility function that verifies if a character is in the WILDCARDS list -- */
int dotconf_is_wild_card(char value)
{
	int retval = 0;
	int i;
	int wildcards_len = strlen(WILDCARDS);

	for (i = 0; i < wildcards_len; i++) {
		if (value == WILDCARDS[i]) {
			retval = 1;
			break;
		}
	}

	return retval;
}

/* ------ internal utility function that calls the appropriate routine for the wildcard passed in -- */
int dotconf_handle_wild_card(command_t * cmd, char wild_card, char *path,
			     char *pre, char *ext)
{
	int retval = 0;

	switch (wild_card) {
	case '*':

		retval = dotconf_handle_star(cmd, path, pre, ext);

		break;

	case '?':

		retval = dotconf_handle_question_mark(cmd, path, pre, ext);

		break;

	default:
		retval = -1;
	}

	return retval;
}

/* ------ internal utility function that frees allocated memory from dotcont_find_wild_card -- */
void dotconf_wild_card_cleanup(char *path, char *pre)
{

	if (path != NULL) {
		free(path);
	}

	if (pre != NULL) {
		free(pre);
	}

}

/* ------ internal utility function to check for wild cards in file path -- */
/* ------ path and pre must be freed by the developer ( dotconf_wild_card_cleanup) -- */
int dotconf_find_wild_card(char *filename, char *wildcard, char **path,
			   char **pre, char **ext)
{
	int retval = -1;
	int prefix_len = 0;
	int tmp_count = 0;
	char *tmp = 0;
	int found_path = 0;

	int len = strlen(filename);

	if (wildcard != NULL && len > 0 && path != NULL && pre != NULL
	    && ext != NULL) {
		prefix_len = strcspn(filename, WILDCARDS);	/* find any wildcard in WILDCARDS */

		if (prefix_len < len) {	/* Wild card found */
			tmp = filename + prefix_len;
			tmp_count = prefix_len + 1;

			while (tmp != filename && *(tmp) != '/') {
				tmp--;
				tmp_count--;
			}

			if (*(tmp) == '/') {
				*path = (char *)malloc(tmp_count + 1);
				found_path = 1;

			} else

				*path = (char *)malloc(1);

			*pre =
			    (char *)
			    malloc((prefix_len -
				    (tmp_count - (found_path ? 0 : 1))) + 1);

			if (*path && *pre) {
				if (found_path)
					strncpy(*path, filename, tmp_count);
				(*path)[tmp_count] = '\0';

				strncpy(*pre, (tmp + (found_path ? 1 : 0)),
					(prefix_len -
					 (tmp_count - (found_path ? 0 : 1))));
				(*pre)[(prefix_len -
					(tmp_count - (found_path ? 0 : 1)))] =
				    '\0';

				*ext = filename + prefix_len;
				*wildcard = (**ext);
				(*ext)++;

				retval = prefix_len;

			}

		}

	}

	return retval;
}

/* ------ internal utility function that compares two stings from back to front -- */
int dotconf_strcmp_from_back(const char *s1, const char *s2)
{
	int retval = 0;
	int i, j;
	int len_1 = strlen(s1);
	int len_2 = strlen(s2);

	for (i = len_1, j = len_2; (i >= 0 && j >= 0); i--, j--) {
		if (s1[i] != s2[j]) {
			retval = -1;
			break;
		}
	}

	return retval;
}

/* ------ internal utility function that determins if a string matches the '?' criteria -- */
int dotconf_question_mark_match(char *dir_name, char *pre, char *ext)
{
	int retval = -1;
	int dir_name_len = strlen(dir_name);
	int pre_len = strlen(pre);
	int ext_len = strlen(ext);
	int w_card_check = strcspn(ext, WILDCARDS);

	if ((w_card_check < ext_len) && (strncmp(dir_name, pre, pre_len) == 0)
	    && (strcmp(dir_name, ".") != 0) && (strcmp(dir_name, "..") != 0)) {
		retval = 1;	/* Another wildcard found */

	} else {

		if ((dir_name_len >= pre_len) &&
		    (strncmp(dir_name, pre, pre_len) == 0) &&
		    (strcmp(dir_name, ".") != 0) &&
		    (strcmp(dir_name, "..") != 0)) {
			retval = 0;	/* Matches no other wildcards */
		}

	}

	return retval;
}

/* ------ internal utility function that determins if a string matches the '*' criteria -- */
int dotconf_star_match(char *dir_name, char *pre, char *ext)
{
	int retval = -1;
	int dir_name_len = strlen(dir_name);
	int pre_len = strlen(pre);
	int ext_len = strlen(ext);
	int w_card_check = strcspn(ext, WILDCARDS);

	if ((w_card_check < ext_len) && (strncmp(dir_name, pre, pre_len) == 0)
	    && (strcmp(dir_name, ".") != 0) && (strcmp(dir_name, "..") != 0)) {
		retval = 1;	/* Another wildcard found */

	} else {

		if ((dir_name_len >= (ext_len + pre_len)) &&
		    (dotconf_strcmp_from_back(dir_name, ext) == 0) &&
		    (strncmp(dir_name, pre, pre_len) == 0) &&
		    (strcmp(dir_name, ".") != 0) &&
		    (strcmp(dir_name, "..") != 0)) {
			retval = 0;	/* Matches no other wildcards */
		}

	}

	return retval;
}

/* ------ internal utility function that determins matches for filenames with   -- */
/* ------ a '?' in name and calls the Internal Include function on that filename -- */
int dotconf_handle_question_mark(command_t * cmd, char *path, char *pre,
				 char *ext)
{
	configfile_t *included;
	DIR *dh = 0;
	struct dirent *dirptr = 0;
	int i;

	char new_pre[CFG_MAX_FILENAME];
	char already_matched[CFG_MAX_FILENAME];

	char wc = '\0';

	char *new_path = 0;
	char *wc_path = 0;
	char *wc_pre = 0;
	char *wc_ext = 0;
	char *temp = NULL;

	int pre_len;
	int new_path_len;
	int name_len = 0;
	int alloced = 0;
	int match_state = 0;

	pre_len = strlen(pre);

	if ((dh = opendir(path)) != NULL) {
		while ((dirptr = readdir(dh)) != NULL) {
			match_state =
			    dotconf_question_mark_match(dirptr->d_name, pre,
							ext);

			if (match_state >= 0) {
				name_len = strlen(dirptr->d_name);
				new_path_len =
				    strlen(path) + name_len + strlen(ext) + 1;

				if (!alloced) {
					if ((new_path =
					     (char *)malloc(new_path_len)) ==
					    NULL) {
						return -1;
					}

					alloced = new_path_len;

				} else {

					if (new_path_len > alloced) {
						temp =
						    realloc(new_path,
							    new_path_len);
						if (temp == NULL) {
							free(new_path);
							return -1;
						}
						new_path = temp;
						alloced = new_path_len;

					}

				}

				if (match_state == 1) {

					strncpy(new_pre, dirptr->d_name,
						(name_len >
						 pre_len) ? (pre_len +
							     1) : pre_len);
					new_pre[(name_len >
						 pre_len) ? (pre_len +
							     1) : pre_len] =
					    '\0';

					sprintf(new_path, "%s%s%s", path,
						new_pre, ext);

					if (strcmp(new_path, already_matched) ==
					    0) {
						continue;	/* Already searched this expression */

					} else {

						strcpy(already_matched,
						       new_path);

					}

					if (dotconf_find_wild_card
					    (new_path, &wc, &wc_path, &wc_pre,
					     &wc_ext) >= 0) {
						if (dotconf_handle_wild_card
						    (cmd, wc, wc_path, wc_pre,
						     wc_ext) < 0) {
							dotconf_warning(cmd->
									configfile,
									DCLOG_WARNING,
									ERR_INCLUDE_ERROR,
									"Error occured while processing wildcard %c\n"
									"Filename is '%s'\n",
									wc,
									new_path);

							free(new_path);
							dotconf_wild_card_cleanup
							    (wc_path, wc_pre);
							return -1;
						}

						dotconf_wild_card_cleanup
						    (wc_path, wc_pre);
						continue;
					}

				}

				sprintf(new_path, "%s%s", path, dirptr->d_name);

				if (access(new_path, R_OK)) {
					dotconf_warning(cmd->configfile,
							DCLOG_WARNING,
							ERR_INCLUDE_ERROR,
							"Cannot open %s for inclusion.\n"
							"IncludePath is '%s'\n",
							new_path,
							cmd->configfile->
							includepath);
					return -1;
				}

				included =
				    dotconf_create(new_path,
						   cmd->configfile->
						   config_options[1],
						   cmd->configfile->context,
						   cmd->configfile->flags);
				if (included) {
					for (i = 2;
					     cmd->configfile->config_options[i];
					     i++)
						dotconf_register_options
						    (included,
						     cmd->configfile->
						     config_options[i]);
					included->errorhandler =
					    cmd->configfile->errorhandler;
					included->contextchecker =
					    cmd->configfile->contextchecker;
					dotconf_command_loop(included);
					dotconf_cleanup(included);
				}

			}

		}

		closedir(dh);
		free(new_path);

	}

	return 0;
}

/* ------ internal utility function that determins matches for filenames with   --- */
/* ------ a '*' in name and calls the Internal Include function on that filename -- */
int dotconf_handle_star(command_t * cmd, char *path, char *pre, char *ext)
{
	configfile_t *included;
	DIR *dh = 0;
	struct dirent *dirptr = 0;

	char new_pre[CFG_MAX_FILENAME];
	char new_ext[CFG_MAX_FILENAME];
	char already_matched[CFG_MAX_FILENAME];

	char wc = '\0';

	char *new_path = 0;
	char *s_ext = 0;
	char *t_ext = 0;
	char *sub = 0;
	char *wc_path = 0;
	char *wc_pre = 0;
	char *wc_ext = 0;
	char *temp = NULL;

	int pre_len;
	int new_path_len;
	int name_len = 0;
	int alloced = 0;
	int match_state = 0;
	int t_ext_count = 0;
	int sub_count = 0;

	pre_len = strlen(pre);
	memset(already_matched, 0, CFG_MAX_FILENAME);
	s_ext = ext;

	while (dotconf_is_wild_card(*s_ext)) {	/* remove trailing wild-cards proceeded by * */
		s_ext++;
	}

	t_ext = s_ext;

	while (t_ext != NULL && !(dotconf_is_wild_card(*t_ext))
	       && *t_ext != '\0') {
		t_ext++;	/* find non-wild-card string */
		t_ext_count++;
	}

	strncpy(new_ext, s_ext, t_ext_count);
	new_ext[t_ext_count] = '\0';

	if ((dh = opendir(path)) != NULL) {
		while ((dirptr = readdir(dh)) != NULL) {
			sub_count = 0;
			t_ext_count = 0;

			match_state =
			    dotconf_star_match(dirptr->d_name, pre, s_ext);

			if (match_state >= 0) {
				name_len = strlen(dirptr->d_name);
				new_path_len =
				    strlen(path) + name_len + strlen(s_ext) + 1;

				if (!alloced) {
					if ((new_path =
					     (char *)malloc(new_path_len)) ==
					    NULL) {
						return -1;
					}

					alloced = new_path_len;

				} else {

					if (new_path_len > alloced) {
						temp =
						    realloc(new_path,
							    new_path_len);
						if (temp == NULL) {
							free(new_path);
							return -1;
						}
						new_path = temp;
						alloced = new_path_len;

					}

				}

				if (match_state == 1) {

					if ((sub =
					     strstr((dirptr->d_name + pre_len),
						    new_ext)) == NULL) {
						continue;
					}

					while (sub != dirptr->d_name) {
						sub--;
						sub_count++;
					}

					if (sub_count + t_ext_count > name_len) {
						continue;
					}

					strncpy(new_pre, dirptr->d_name,
						(sub_count + t_ext_count));
					new_pre[sub_count + t_ext_count] = '\0';
					strcat(new_pre, new_ext);

					sprintf(new_path, "%s%s%s", path,
						new_pre, t_ext);

					if (strcmp(new_path, already_matched) ==
					    0) {
						continue;	/* Already searched this expression */

					} else {

						strcpy(already_matched,
						       new_path);

					}

					if (dotconf_find_wild_card
					    (new_path, &wc, &wc_path, &wc_pre,
					     &wc_ext) >= 0) {
						if (dotconf_handle_wild_card
						    (cmd, wc, wc_path, wc_pre,
						     wc_ext) < 0) {
							dotconf_warning(cmd->
									configfile,
									DCLOG_WARNING,
									ERR_INCLUDE_ERROR,
									"Error occured while processing wildcard %c\n"
									"Filename is '%s'\n",
									wc,
									new_path);

							free(new_path);
							dotconf_wild_card_cleanup
							    (wc_path, wc_pre);
							return -1;
						}

						dotconf_wild_card_cleanup
						    (wc_path, wc_pre);
						continue;
					}

				}

				sprintf(new_path, "%s%s", path, dirptr->d_name);

				if (access(new_path, R_OK)) {
					dotconf_warning(cmd->configfile,
							DCLOG_WARNING,
							ERR_INCLUDE_ERROR,
							"Cannot open %s for inclusion.\n"
							"IncludePath is '%s'\n",
							new_path,
							cmd->configfile->
							includepath);
					return -1;
				}

				included =
				    dotconf_create(new_path,
						   cmd->configfile->
						   config_options[1],
						   cmd->configfile->context,
						   cmd->configfile->flags);
				if (included) {
					included->errorhandler =
					    cmd->configfile->errorhandler;
					included->contextchecker =
					    cmd->configfile->contextchecker;
					dotconf_command_loop(included);
					dotconf_cleanup(included);
				}

			}

		}

		closedir(dh);
		free(new_path);

	}

	return 0;
}

char *get_cwd(void)
{
	char *buf = calloc(1, CFG_MAX_FILENAME);

	if (buf == NULL)
		return NULL;
	getcwd(buf, CFG_MAX_FILENAME);
	return buf;
}

char *get_path(char *name)
{
	char *tmp;
	char *buf = NULL;
	int len = 0;

	tmp = strrchr(name, '/');
	if (tmp == NULL)
		return NULL;
	buf = calloc(1, CFG_MAX_FILENAME);
	if (buf == NULL)
		return NULL;
	if (tmp == name) {
		sprintf(buf, "/");
	} else {
		len = tmp - name + 1;
		if (len > CFG_MAX_FILENAME)
			len = CFG_MAX_FILENAME;
	}
		snprintf(buf, len, "%s", name);
	return buf;
}

/* ------ callbacks of the internal option (Include, IncludePath) ------------------------------- */
DOTCONF_CB(dotconf_cb_include)
{
	char *filename = 0;
	configfile_t *included;

	char wild_card;
	char *path = 0;
	char *pre = 0;
	char *ext = 0;

	if (cmd->configfile->includepath
	    && cmd->data.str[0] != '/'
	    && cmd->configfile->includepath[0] != '\0') {
		/* relative file AND include path is used */
		int len, inclen;
		char *sl;

		inclen = strlen(cmd->configfile->includepath);
		if ((len =
		     (strlen(cmd->data.str) + inclen + 1)) ==
		    CFG_MAX_FILENAME) {
			dotconf_warning(cmd->configfile, DCLOG_WARNING,
					ERR_INCLUDE_ERROR,
					"Absolute filename too long (>%d)",
					CFG_MAX_FILENAME);
			return NULL;
		}

		if (cmd->configfile->includepath[inclen - 1] == '/')
			sl = "";
		else {
			sl = "/";
			len++;
		}

		filename = malloc(len);
		snprintf(filename, len, "%s%s%s",
			 cmd->configfile->includepath, sl, cmd->data.str);
	} else			/* fully qualified, or no includepath */
		filename = strdup(cmd->data.str);

	/* Added wild card support here */
	if (dotconf_find_wild_card(filename, &wild_card, &path, &pre, &ext) >=
	    0) {
		if (dotconf_handle_wild_card(cmd, wild_card, path, pre, ext) <
		    0) {
			dotconf_warning(cmd->configfile, DCLOG_WARNING,
					ERR_INCLUDE_ERROR,
					"Error occured while attempting to process %s for inclusion.\n"
					"IncludePath is '%s'\n", filename,
					cmd->configfile->includepath);
		}

		dotconf_wild_card_cleanup(path, pre);
		free(filename);
		return NULL;
	}

	if (access(filename, R_OK)) {
		dotconf_warning(cmd->configfile, DCLOG_WARNING,
				ERR_INCLUDE_ERROR,
				"Cannot open %s for inclusion.\n"
				"IncludePath is '%s'\n", filename,
				cmd->configfile->includepath);
		free(filename);
		return NULL;
	}

	included = dotconf_create(filename, cmd->configfile->config_options[1],
				  cmd->configfile->context,
				  cmd->configfile->flags);
	if (included) {
		included->contextchecker =
		    (dotconf_contextchecker_t) cmd->configfile->contextchecker;
		included->errorhandler =
		    (dotconf_errorhandler_t) cmd->configfile->errorhandler;

		dotconf_command_loop(included);
		dotconf_cleanup(included);
	}

	free(filename);
	return NULL;
}

DOTCONF_CB(dotconf_cb_includepath)
{
	char *env = getenv(CFG_INCLUDEPATH_ENV);
	/* environment overrides configuration file setting */
	if (!env)
		snprintf(cmd->configfile->includepath, CFG_MAX_FILENAME, "%s",
			 cmd->data.str);
	return NULL;
}
