[irc/ircd-hybrid/bopm.git] / src / config.c

/*
Copyright (C) 2002  Erik Fears

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software

      Foundation, Inc.
      59 Temple Place - Suite 330
      Boston, MA  02111-1307, USA.

*/

#include "setup.h"

#ifdef STDC_HEADERS
#include <string.h>
#include <stdlib.h>
#endif

#include <stdio.h>
#include <time.h>

#include "config.h"
#include "log.h"
#include "misc.h"
#include "extern.h"
#include "match.h"

static void config_checkreq(void);
static void config_memfail(void);
static void add_to_list(string_list *oldlist, const char *item);
static void free_list(string_list *list);
static void add_to_config(const char *key, const char *val);

extern int remote_is_ipv6;
extern int bindto_ipv6;

/* Global Configuration Variables */

char *CONF_SERVER          = 0;
char *CONF_PASSWORD        = 0;
char *CONF_USER            = 0;
char *CONF_NICK            = 0;
char *CONF_REALNAME        = 0;
char *CONF_OPER            = 0;
char *CONF_OPER_MODES      = 0;
char *CONF_SCANIP          = 0;
char *CONF_BINDIRC         = 0;
char *CONF_BINDSCAN        = 0;
char *CONF_CHANNELS        = 0;
char *CONF_KEYS            = 0;
char *CONF_NICKSERV_IDENT  = 0;
char *CONF_CHANSERV_INVITE = 0;
char *CONF_KLINE_COMMAND   = 0;
char *CONF_DNSBL_ZONE      = 0;
char *CONF_DNSBL_FROM      = 0;
char *CONF_DNSBL_TO        = 0;
char *CONF_SENDMAIL        = 0;
char *CONF_HELP_EMAIL      = 0;
char *CONF_AWAY            = 0;
char *CONF_TARGET_STRING   = 0;
char *CONF_PIDFILE         = 0;
string_list *CONF_EXCLUDE  = 0;

unsigned int  CONF_SCANPORT         = 0;
unsigned int  CONF_PORT             = 0;
unsigned int  CONF_FDLIMIT          = 0;
unsigned int  CONF_TIMEOUT          = 0;

/* Configuration Hash , Hashes Config Params to their Function Handlers*/
/*      NAME                  , TYPE   , REQ, REQMET, PTR TO VAR        */
config_hash hash[] = {
       {"SERVER",              TYPE_STRING, 0,0,    &CONF_SERVER             },
       {"SERVER6",	       TYPE_AF, 0,0,	    &CONF_SERVER	     },
       {"PORT",                TYPE_INT   , 1,0,    &CONF_PORT               },
       {"PASSWORD",            TYPE_STRING, 0,0,    &CONF_PASSWORD           },
       {"USER",                TYPE_STRING, 1,0,    &CONF_USER               },
       {"NICK",                TYPE_STRING, 1,0,    &CONF_NICK               },
       {"REALNAME",            TYPE_STRING, 1,0,    &CONF_REALNAME           },
       {"OPER",                TYPE_STRING, 1,0,    &CONF_OPER               },
       {"OPER_MODES",          TYPE_STRING, 1,0,    &CONF_OPER_MODES         },
       {"SCANIP",              TYPE_STRING, 1,0,    &CONF_SCANIP             },
       {"SCANPORT",            TYPE_INT   , 1,0,    &CONF_SCANPORT           },
       {"BINDIRC",             TYPE_STRING, 0,0,    &CONF_BINDIRC            },
       {"BINDSCAN",            TYPE_STRING, 0,0,    &CONF_BINDSCAN           },
       {"BINDIRC6",            TYPE_AF, 0,0,        &CONF_BINDIRC            },
       {"BINDSCAN6",           TYPE_AF, 0,0,        &CONF_BINDSCAN           },
       {"FDLIMIT",             TYPE_INT   , 1,0,    &CONF_FDLIMIT            },
       {"CHANNELS",            TYPE_STRING, 1,0,    &CONF_CHANNELS           },
       {"KEYS",                TYPE_STRING, 0,0,    &CONF_KEYS               },
       {"NICKSERV_IDENT",      TYPE_STRING, 0,0,    &CONF_NICKSERV_IDENT     },
       {"CHANSERV_INVITE",     TYPE_STRING, 0,0,    &CONF_CHANSERV_INVITE    },
       {"KLINE_COMMAND",       TYPE_STRING, 1,0,    &CONF_KLINE_COMMAND      },
       {"DNSBL_ZONE",          TYPE_STRING, 0,0,    &CONF_DNSBL_ZONE         },
       {"DNSBL_FROM",          TYPE_STRING, 0,0,    &CONF_DNSBL_FROM         },
       {"DNSBL_TO",            TYPE_STRING, 0,0,    &CONF_DNSBL_TO           },
       {"SENDMAIL",            TYPE_STRING, 0,0,    &CONF_SENDMAIL           },
       {"HELP_EMAIL",          TYPE_STRING, 1,0,    &CONF_HELP_EMAIL         },
       {"AWAY",                TYPE_STRING, 1,0,    &CONF_AWAY               },
       {"TARGET_STRING",       TYPE_STRING, 1,0,    &CONF_TARGET_STRING      },
       {"EXCLUDE",             TYPE_LIST,   0,0,    &CONF_EXCLUDE            },
       {"TIMEOUT",             TYPE_INT,    1,0,    &CONF_TIMEOUT            },
       {"PIDFILE",             TYPE_STRING, 1,0,    &CONF_PIDFILE            },
       {0,                     0,           0,0,    0                        },
};


/* Parse File */

void config_load(char *filename)
{
	/* 1k buffer for reading the file. */
	char line[1024];
	size_t i;
	char *key, *args;
	FILE *in;

	if (!(in = fopen(filename, "r"))) {
		log("CONFIG -> No config file found, aborting.");
		exit(1);
	}
    
	/* Clear anything we have already. */
	for (i = 0; i < (sizeof(hash) / sizeof(config_hash) - 1); i++) {
		switch(hash[i].type) { 
		case TYPE_STRING:
		case TYPE_AF:
			if (( *(char**) hash[i].var))
				free(*(char**)hash[i].var);
			*(char**)hash[i].var = 0;
			break;
		case TYPE_INT:
			*(int *) hash[i].var = 0;
			break;
		case TYPE_LIST:
			free_list(* (string_list **) hash[i].var);
			break;
		}
		hash[i].reqmet = 0;
	}

	while (fgets(line, 1023, in))  {
		if(line[0] == '#')
			continue;
		    
		key = strtok(line, " ");
		args = strtok(NULL, "\n");

		if (!args)
			continue;

		/* Strip leading and trailing spaces. */
		args = clean(args);
		add_to_config(key, args);
	}

	fclose(in);
	/* Check required parameters. */
	config_checkreq();
}

static void config_checkreq()
{
	size_t i;
	int errfnd;
	string_list *list;

	errfnd = 0;

	for (i = 0; i < (sizeof(hash) / sizeof(config_hash) - 1); i++) {
		if (hash[i].req && !hash[i].reqmet) {               
			log("CONFIG -> Parameter [%s] required but not "
			    "defined in config.", hash[i].key);
			errfnd++;
		} else if (OPT_DEBUG >= 3 && hash[i].reqmet) {
			switch (hash[i].type) {
			case TYPE_AF:
			case TYPE_STRING:
				log("CONFIG -> Set [%s]: %s", hash[i].key,
				    *(char**) hash[i].var);
				break;
			case TYPE_INT:
				log("CONFIG -> Set [%s]: %d", hash[i].key,
				    *(int *) hash[i].var);
				break;
			case TYPE_LIST:
				for (list = *(string_list**) (hash[i].var);
				    list; list = list->next) {
					log("CONFIG -> Set [%s]: %s",
					    hash[i].key, list->text);
				}
				break;
			}
		}
	}

	if (errfnd) {
		log("CONFIG -> %d parameters missing from config file, "
		    "aborting.", errfnd);
		exit(1);
	}
}

/*
 * Called when memory allocation somewhere returns an error.
 */

static void config_memfail(void)
{
	log("CONFIG -> Error allocating memory.");
	exit(1);
}

static void add_to_list(string_list *oldlist, const char *item)
{
	string_list *list;

	list = malloc(sizeof(*list));
	
	if (!list)
		config_memfail();
	
	list->next = NULL;
	list->text = strdup(item);
	
	if (!list->text)
		config_memfail();
	
	collapse(list->text);

	if (!oldlist) {
		oldlist = list;
		return;
	}

	while (oldlist) {
		if (strcasecmp(list->text, oldlist->text)) {
			if (oldlist->next) {
				oldlist = oldlist->next;
			} else {
				oldlist->next = list;
				oldlist = NULL;
			}
		} else {
			free(list);
			oldlist = NULL;
		}
	}
}

static void free_list(string_list *list)
{
	string_list *t, *nextlist;
	
	for (t = list; t; ) {
		nextlist = t->next;
		free(t->text);
		free(t);
		t = nextlist;
	}
	t = 0;
	list = 0;
} 

static void add_to_config(const char *key, const char *val)
{
	size_t i;
	
	for (i = 0; i < (sizeof(hash) / sizeof(config_hash)) - 1; i++) {
		if (strcasecmp(key, hash[i].key) == 0) {
			switch (hash[i].type) {
			case TYPE_STRING: 
				*(char**) hash[i].var = strdup(val);
				break;
			case TYPE_AF:
                                *(char**) hash[i].var = strdup(val);
				
			/* Ugly hack here. The letter E means, it is the word SERVER */
			/* BINDIRC and BINDSCAN do not have an E in them. */
			/* -TimeMr14C - 28.06.2002 */
				if (strchr(key, 'E'))
					remote_is_ipv6 = 1;
				else
					bindto_ipv6 = 1;
			/* This was required when setting ipv6 savvy values */

                                break;
			case TYPE_INT:
				*(int *) hash[i].var = atoi(val);
				break;
			case TYPE_LIST:
				add_to_list(* (string_list **) (hash[i].var),
				    val);
				break;
			}
			hash[i].reqmet = 1;
		}
	}
}
Commit	Line	Data
dcf198ea	1	/*
	2	Copyright (C) 2002 Erik Fears
	3
	4	This program is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU General Public License
	6	as published by the Free Software Foundation; either version 2
	7	of the License, or (at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16
	17	Foundation, Inc.
	18	59 Temple Place - Suite 330
	19	Boston, MA 02111-1307, USA.
	20
	21	*/
	22
5b8249aa	23	#include "setup.h"
dcf198ea	24
5b8249aa	25	#ifdef STDC_HEADERS
dcf198ea	26	#include <string.h>
dcf198ea	27	#include <stdlib.h>
21ccdcf9	28	#endif
5b8249aa	29
5b8249aa	30	#include <stdio.h>
2bbfbe9b	31	#include <time.h>
dcf198ea	32
dcf198ea	33	#include "config.h"
12326396	34	#include "log.h"
27f391e7	35	#include "misc.h"
0a3810c2	36	#include "extern.h"
714c9cea	37	#include "match.h"
dcf198ea	38
6970fdab	39	static void config_checkreq(void);
	40	static void config_memfail(void);
	41	static void add_to_list(string_list oldlist, const char item);
	42	static void free_list(string_list *list);
	43	static void add_to_config(const char key, const char val);
	44
c185a5dd	45	extern int remote_is_ipv6;
	46	extern int bindto_ipv6;
	47
dcf198ea	48	/* Global Configuration Variables */
dcf198ea	49
12326396	50	char *CONF_SERVER = 0;
160e54e5	51	char *CONF_PASSWORD = 0;
12326396	52	char *CONF_USER = 0;
12326396	53	char *CONF_NICK = 0;
95b76d38	54	char *CONF_REALNAME = 0;
39bbe079	55	char *CONF_OPER = 0;
f6cd298a	56	char *CONF_OPER_MODES = 0;
f3f135f3	57	char *CONF_SCANIP = 0;
1f7133ae	58	char *CONF_BINDIRC = 0;
1f7133ae	59	char *CONF_BINDSCAN = 0;
db4efd6a	60	char *CONF_CHANNELS = 0;
356950ca	61	char *CONF_KEYS = 0;
ad429564	62	char *CONF_NICKSERV_IDENT = 0;
f585b8ee	63	char *CONF_CHANSERV_INVITE = 0;
ad429564	64	char *CONF_KLINE_COMMAND = 0;
6ff0d219	65	char *CONF_DNSBL_ZONE = 0;
	66	char *CONF_DNSBL_FROM = 0;
	67	char *CONF_DNSBL_TO = 0;
23dbe610	68	char *CONF_SENDMAIL = 0;
5416e96d	69	char *CONF_HELP_EMAIL = 0;
5416e96d	70	char *CONF_AWAY = 0;
cb36c747	71	char *CONF_TARGET_STRING = 0;
c6b668dd	72	char *CONF_PIDFILE = 0;
714c9cea	73	string_list *CONF_EXCLUDE = 0;
f3f135f3	74
4b8adcde	75	unsigned int CONF_SCANPORT = 0;
	76	unsigned int CONF_PORT = 0;
	77	unsigned int CONF_FDLIMIT = 0;
87f352be	78	unsigned int CONF_TIMEOUT = 0;
dcf198ea	79
dcf198ea	80	/* Configuration Hash , Hashes Config Params to their Function Handlers*/
4d35687a	81	/* NAME , TYPE , REQ, REQMET, PTR TO VAR */
dcf198ea	82	config_hash hash[] = {
c185a5dd	83	{"SERVER", TYPE_STRING, 0,0, &CONF_SERVER },
c185a5dd	84	{"SERVER6", TYPE_AF, 0,0, &CONF_SERVER },
4d35687a	85	{"PORT", TYPE_INT , 1,0, &CONF_PORT },
160e54e5	86	{"PASSWORD", TYPE_STRING, 0,0, &CONF_PASSWORD },
4d35687a	87	{"USER", TYPE_STRING, 1,0, &CONF_USER },
4d35687a	88	{"NICK", TYPE_STRING, 1,0, &CONF_NICK },
95b76d38	89	{"REALNAME", TYPE_STRING, 1,0, &CONF_REALNAME },
4d35687a	90	{"OPER", TYPE_STRING, 1,0, &CONF_OPER },
	91	{"OPER_MODES", TYPE_STRING, 1,0, &CONF_OPER_MODES },
	92	{"SCANIP", TYPE_STRING, 1,0, &CONF_SCANIP },
	93	{"SCANPORT", TYPE_INT , 1,0, &CONF_SCANPORT },
	94	{"BINDIRC", TYPE_STRING, 0,0, &CONF_BINDIRC },
	95	{"BINDSCAN", TYPE_STRING, 0,0, &CONF_BINDSCAN },
c185a5dd	96	{"BINDIRC6", TYPE_AF, 0,0, &CONF_BINDIRC },
c185a5dd	97	{"BINDSCAN6", TYPE_AF, 0,0, &CONF_BINDSCAN },
0a3810c2	98	{"FDLIMIT", TYPE_INT , 1,0, &CONF_FDLIMIT },
4d35687a	99	{"CHANNELS", TYPE_STRING, 1,0, &CONF_CHANNELS },
874fe20f	100	{"KEYS", TYPE_STRING, 0,0, &CONF_KEYS },
4d35687a	101	{"NICKSERV_IDENT", TYPE_STRING, 0,0, &CONF_NICKSERV_IDENT },
	102	{"CHANSERV_INVITE", TYPE_STRING, 0,0, &CONF_CHANSERV_INVITE },
	103	{"KLINE_COMMAND", TYPE_STRING, 1,0, &CONF_KLINE_COMMAND },
	104	{"DNSBL_ZONE", TYPE_STRING, 0,0, &CONF_DNSBL_ZONE },
	105	{"DNSBL_FROM", TYPE_STRING, 0,0, &CONF_DNSBL_FROM },
	106	{"DNSBL_TO", TYPE_STRING, 0,0, &CONF_DNSBL_TO },
	107	{"SENDMAIL", TYPE_STRING, 0,0, &CONF_SENDMAIL },
	108	{"HELP_EMAIL", TYPE_STRING, 1,0, &CONF_HELP_EMAIL },
dbad9c7f	109	{"AWAY", TYPE_STRING, 1,0, &CONF_AWAY },
cb36c747	110	{"TARGET_STRING", TYPE_STRING, 1,0, &CONF_TARGET_STRING },
714c9cea	111	{"EXCLUDE", TYPE_LIST, 0,0, &CONF_EXCLUDE },
87f352be	112	{"TIMEOUT", TYPE_INT, 1,0, &CONF_TIMEOUT },
c6b668dd	113	{"PIDFILE", TYPE_STRING, 1,0, &CONF_PIDFILE },
dbad9c7f	114	{0, 0, 0,0, 0 },
dcf198ea	115	};
	116
	117
	118
	119	/* Parse File */
	120
	121	void config_load(char *filename)
	122	{
6970fdab	123	/* 1k buffer for reading the file. */
	124	char line[1024];
	125	size_t i;
	126	char key, args;
	127	FILE *in;
	128
	129	if (!(in = fopen(filename, "r"))) {
	130	log("CONFIG -> No config file found, aborting.");
	131	exit(1);
	132	}
dcf198ea	133
6970fdab	134	/* Clear anything we have already. */
	135	for (i = 0; i < (sizeof(hash) / sizeof(config_hash) - 1); i++) {
	136	switch(hash[i].type) {
	137	case TYPE_STRING:
c185a5dd	138	case TYPE_AF:
6970fdab	139	if (( (char*) hash[i].var))
	140	free((char*)hash[i].var);
	141	(char*)hash[i].var = 0;
	142	break;
	143	case TYPE_INT:
	144	(int ) hash[i].var = 0;
	145	break;
	146	case TYPE_LIST:
	147	free_list(* (string_list **) hash[i].var);
	148	break;
	149	}
	150	hash[i].reqmet = 0;
	151	}
	152
	153	while (fgets(line, 1023, in)) {
	154	if(line[0] == '#')
	155	continue;
dcf198ea	156
6970fdab	157	key = strtok(line, " ");
	158	args = strtok(NULL, "\n");
	159
	160	if (!args)
	161	continue;
ad429564	162
6970fdab	163	/* Strip leading and trailing spaces. */
	164	args = clean(args);
	165	add_to_config(key, args);
	166	}
	167
	168	fclose(in);
	169	/* Check required parameters. */
	170	config_checkreq();
4d35687a	171	}
4d35687a	172
6970fdab	173	static void config_checkreq()
4d35687a	174	{
6970fdab	175	size_t i;
	176	int errfnd;
	177	string_list *list;
	178
	179	errfnd = 0;
	180
	181	for (i = 0; i < (sizeof(hash) / sizeof(config_hash) - 1); i++) {
	182	if (hash[i].req && !hash[i].reqmet) {
	183	log("CONFIG -> Parameter [%s] required but not "
	184	"defined in config.", hash[i].key);
	185	errfnd++;
	186	} else if (OPT_DEBUG >= 3 && hash[i].reqmet) {
	187	switch (hash[i].type) {
c185a5dd	188	case TYPE_AF:
6970fdab	189	case TYPE_STRING:
	190	log("CONFIG -> Set [%s]: %s", hash[i].key,
	191	(char*) hash[i].var);
	192	break;
	193	case TYPE_INT:
	194	log("CONFIG -> Set [%s]: %d", hash[i].key,
	195	(int ) hash[i].var);
	196	break;
	197	case TYPE_LIST:
	198	for (list = (string_list*) (hash[i].var);
	199	list; list = list->next) {
	200	log("CONFIG -> Set [%s]: %s",
	201	hash[i].key, list->text);
	202	}
	203	break;
	204	}
	205	}
	206	}
	207
	208	if (errfnd) {
	209	log("CONFIG -> %d parameters missing from config file, "
	210	"aborting.", errfnd);
	211	exit(1);
	212	}
dcf198ea	213	}
dcf198ea	214
6970fdab	215	/*
6970fdab	216	* Called when memory allocation somewhere returns an error.
12326396	217	*/
12326396	218
6970fdab	219	static void config_memfail(void)
	220	{
	221	log("CONFIG -> Error allocating memory.");
	222	exit(1);
	223	}
	224
	225	static void add_to_list(string_list oldlist, const char item)
12326396	226	{
6970fdab	227	string_list *list;
	228
	229	list = malloc(sizeof(*list));
	230
	231	if (!list)
	232	config_memfail();
	233
	234	list->next = NULL;
	235	list->text = strdup(item);
	236
	237	if (!list->text)
	238	config_memfail();
	239
	240	collapse(list->text);
	241
	242	if (!oldlist) {
	243	oldlist = list;
	244	return;
	245	}
	246
	247	while (oldlist) {
	248	if (strcasecmp(list->text, oldlist->text)) {
	249	if (oldlist->next) {
	250	oldlist = oldlist->next;
	251	} else {
	252	oldlist->next = list;
	253	oldlist = NULL;
	254	}
	255	} else {
	256	free(list);
	257	oldlist = NULL;
	258	}
	259	}
12326396	260	}
12326396	261
6970fdab	262	static void free_list(string_list *list)
	263	{
	264	string_list t, nextlist;
	265
	266	for (t = list; t; ) {
	267	nextlist = t->next;
	268	free(t->text);
	269	free(t);
	270	t = nextlist;
	271	}
	272	t = 0;
	273	list = 0;
	274	}
	275
	276	static void add_to_config(const char key, const char val)
	277	{
	278	size_t i;
	279
	280	for (i = 0; i < (sizeof(hash) / sizeof(config_hash)) - 1; i++) {
	281	if (strcasecmp(key, hash[i].key) == 0) {
	282	switch (hash[i].type) {
	283	case TYPE_STRING:
	284	(char*) hash[i].var = strdup(val);
	285	break;
c185a5dd	286	case TYPE_AF:
	287	(char*) hash[i].var = strdup(val);
	288
	289	/* Ugly hack here. The letter E means, it is the word SERVER */
	290	/* BINDIRC and BINDSCAN do not have an E in them. */
	291	/* -TimeMr14C - 28.06.2002 */
	292	if (strchr(key, 'E'))
	293	remote_is_ipv6 = 1;
	294	else
	295	bindto_ipv6 = 1;
	296	/* This was required when setting ipv6 savvy values */
	297
	298	break;
6970fdab	299	case TYPE_INT:
	300	(int ) hash[i].var = atoi(val);
	301	break;
	302	case TYPE_LIST:
	303	add_to_list(* (string_list **) (hash[i].var),
	304	val);
	305	break;
	306	}
	307	hash[i].reqmet = 1;
	308	}
	309	}
	310	}