X-Git-Url: https://jfr.im/git/irc/rqf/shadowircd.git/blobdiff_plain/212380e3f42f585dc1ea927402252eb943f91f7b..46f0c5186306d7780b956b0f6bae1d9dfc8cbb1c:/src/newconf.c

diff --git a/src/newconf.c b/src/newconf.c
index 7e2a376..b849033 100644
--- a/src/newconf.c
+++ b/src/newconf.c
@@ -1,5 +1,5 @@
 /* This code is in the public domain.
- * $Id: newconf.c 3131 2007-01-21 15:36:31Z jilles $
+ * $Id: newconf.c 3550 2007-08-09 06:47:26Z nenolod $
  */
 
 #include "stdinc.h"
@@ -9,13 +9,10 @@
 #include <openssl/rsa.h>
 #endif
 
-#include "memory.h"
 #include "newconf.h"
-#include "tools.h"
 #include "ircd_defs.h"
-#include "sprintf_irc.h"
 #include "common.h"
-#include "s_log.h"
+#include "logger.h"
 #include "s_conf.h"
 #include "s_user.h"
 #include "s_newconf.h"
@@ -25,19 +22,20 @@
 #include "listener.h"
 #include "hostmask.h"
 #include "s_serv.h"
-#include "event.h"
 #include "hash.h"
 #include "cache.h"
 #include "ircd.h"
 #include "snomask.h"
 #include "blacklist.h"
+#include "sslproc.h"
+#include "privilege.h"
 
 #define CF_TYPE(x) ((x) & CF_MTYPE)
 
 struct TopConf *conf_cur_block;
 static char *conf_cur_block_name;
 
-static dlink_list conf_items;
+static rb_dlink_list conf_items;
 
 static struct ConfItem *yy_aconf = NULL;
 
@@ -46,16 +44,17 @@ static struct Class *yy_class = NULL;
 static struct remote_conf *yy_shared = NULL;
 static struct server_conf *yy_server = NULL;
 
-static dlink_list yy_aconf_list;
-static dlink_list yy_oper_list;
-static dlink_list yy_shared_list;
-static dlink_list yy_cluster_list;
+static rb_dlink_list yy_aconf_list;
+static rb_dlink_list yy_oper_list;
+static rb_dlink_list yy_shared_list;
+static rb_dlink_list yy_cluster_list;
 static struct oper_conf *yy_oper = NULL;
 
 static struct alias_entry *yy_alias = NULL;
 
 static char *yy_blacklist_host = NULL;
 static char *yy_blacklist_reason = NULL;
+static char *yy_privset_extends = NULL;
 
 static const char *
 conf_strtype(int type)
@@ -83,24 +82,24 @@ add_top_conf(const char *name, int (*sfunc) (struct TopConf *),
 {
 	struct TopConf *tc;
 
-	tc = MyMalloc(sizeof(struct TopConf));
+	tc = rb_malloc(sizeof(struct TopConf));
 
-	DupString(tc->tc_name, name);
+	tc->tc_name = name;
 	tc->tc_sfunc = sfunc;
 	tc->tc_efunc = efunc;
 	tc->tc_entries = items;
 
-	dlinkAddAlloc(tc, &conf_items);
+	rb_dlinkAddAlloc(tc, &conf_items);
 	return 0;
 }
 
 struct TopConf *
 find_top_conf(const char *name)
 {
-	dlink_node *d;
+	rb_dlink_node *d;
 	struct TopConf *tc;
 
-	DLINK_FOREACH(d, conf_items.head)
+	RB_DLINK_FOREACH(d, conf_items.head)
 	{
 		tc = d->data;
 		if(strcasecmp(tc->tc_name, name) == 0)
@@ -115,7 +114,7 @@ struct ConfEntry *
 find_conf_item(const struct TopConf *top, const char *name)
 {
 	struct ConfEntry *cf;
-	dlink_node *d;
+	rb_dlink_node *d;
 
 	if(top->tc_entries)
 	{
@@ -130,7 +129,7 @@ find_conf_item(const struct TopConf *top, const char *name)
 		}
 	}
 
-	DLINK_FOREACH(d, top->tc_items.head)
+	RB_DLINK_FOREACH(d, top->tc_items.head)
 	{
 		cf = d->data;
 		if(strcasecmp(cf->cf_name, name) == 0)
@@ -144,17 +143,16 @@ int
 remove_top_conf(char *name)
 {
 	struct TopConf *tc;
-	dlink_node *ptr;
+	rb_dlink_node *ptr;
 
 	if((tc = find_top_conf(name)) == NULL)
 		return -1;
 
-	if((ptr = dlinkFind(tc, &conf_items)) == NULL)
+	if((ptr = rb_dlinkFind(tc, &conf_items)) == NULL)
 		return -1;
 
-	dlinkDestroy(ptr, &conf_items);
-	MyFree(tc->tc_name);
-	MyFree(tc);
+	rb_dlinkDestroy(ptr, &conf_items);
+	rb_free(tc);
 
 	return 0;
 }
@@ -195,7 +193,7 @@ conf_set_serverinfo_name(void *data)
 
 		/* the ircd will exit() in main() if we dont set one */
 		if(strlen(s) <= HOSTLEN)
-			DupString(ServerInfo.name, (char *) data);
+			ServerInfo.name = rb_strdup((char *) data);
 	}
 }
 
@@ -226,14 +224,14 @@ conf_set_serverinfo_network_name(void *data)
 	if((p = strchr((char *) data, ' ')))
 		*p = '\0';
 
-	MyFree(ServerInfo.network_name);
-	DupString(ServerInfo.network_name, (char *) data);
+	rb_free(ServerInfo.network_name);
+	ServerInfo.network_name = rb_strdup((char *) data);
 }
 
 static void
 conf_set_serverinfo_vhost(void *data)
 {
-	if(inetpton(AF_INET, (char *) data, &ServerInfo.ip.sin_addr) <= 0)
+	if(rb_inet_pton(AF_INET, (char *) data, &ServerInfo.ip.sin_addr) <= 0)
 	{
 		conf_report_error("Invalid netmask for server IPv4 vhost (%s)", (char *) data);
 		return;
@@ -245,8 +243,8 @@ conf_set_serverinfo_vhost(void *data)
 static void
 conf_set_serverinfo_vhost6(void *data)
 {
-#ifdef IPV6
-	if(inetpton(AF_INET6, (char *) data, &ServerInfo.ip6.sin6_addr) <= 0)
+#ifdef RB_IPV6
+	if(rb_inet_pton(AF_INET6, (char *) data, &ServerInfo.ip6.sin6_addr) <= 0)
 	{
 		conf_report_error("Invalid netmask for server IPv6 vhost (%s)", (char *) data);
 		return;
@@ -265,14 +263,14 @@ conf_set_modules_module(void *data)
 #ifndef STATIC_MODULES
 	char *m_bn;
 
-	m_bn = irc_basename((char *) data);
+	m_bn = rb_basename((char *) data);
 
 	if(findmodule_byname(m_bn) != -1)
 		return;
 
 	load_one_module((char *) data, 0);
 
-	MyFree(m_bn);
+	rb_free(m_bn);
 #else
 	conf_report_error("Ignoring modules::module -- loadable module support not present.");
 #endif
@@ -297,6 +295,7 @@ struct mode_table
 /* *INDENT-OFF* */
 static struct mode_table umode_table[] = {
 	{"callerid",	UMODE_CALLERID	},
+	{"softcallerid", UMODE_SCALLERID	},
 	{"deaf",	UMODE_DEAF	},
 	{"invisible",	UMODE_INVISIBLE	},
 	{"locops",	UMODE_LOCOPS	},
@@ -305,27 +304,16 @@ static struct mode_table umode_table[] = {
 	{"servnotice",	UMODE_SERVNOTICE},
 	{"wallop",	UMODE_WALLOP	},
 	{"operwall",	UMODE_OPERWALL	},
+	{"noctcp",	UMODE_NOCTCP	},
+	{"noinvite",	UMODE_NOINVITE	},
+	{"bot",		UMODE_BOT	},
+	{"override",	UMODE_OVERRIDE	},
 	{NULL, 0}
 };
 
-static struct mode_table flag_table[] = {
+static struct mode_table oper_table[] = {
 	{"encrypted",		OPER_ENCRYPTED		},
-	{"local_kill",		OPER_LOCKILL		},
-	{"global_kill",		OPER_GLOBKILL|OPER_LOCKILL	},
-	{"remote",		OPER_REMOTE		},
-	{"kline",		OPER_KLINE		},
-	{"unkline",		OPER_UNKLINE		},
-	{"gline",		OPER_GLINE		},
-	{"nick_changes",	OPER_NICKS		},
-	{"rehash",		OPER_REHASH		},
-	{"die",			OPER_DIE		},
-	{"admin",		OPER_ADMIN		},
-	{"hidden_admin",	OPER_HADMIN		},
-	{"xline",		OPER_XLINE		},
-	{"operwall",		OPER_OPERWALL		},
-	{"oper_spy",		OPER_SPY		},
-	{"hidden_oper",		OPER_INVIS		},
-	{"remoteban",		OPER_REMOTEBAN		},
+	{"need_ssl",		OPER_NEEDSSL		},
 	{NULL, 0}
 };
 
@@ -335,7 +323,6 @@ static struct mode_table auth_table[] = {
 	{"exceed_limit",	CONF_FLAGS_NOLIMIT	},
 	{"dnsbl_exempt",	CONF_FLAGS_EXEMPTDNSBL	},
 	{"kline_exempt",	CONF_FLAGS_EXEMPTKLINE	},
-	{"gline_exempt",	CONF_FLAGS_EXEMPTGLINE	},
 	{"flood_exempt",	CONF_FLAGS_EXEMPTFLOOD	},
 	{"spambot_exempt",	CONF_FLAGS_EXEMPTSPAMBOT },
 	{"shide_exempt",	CONF_FLAGS_EXEMPTSHIDE	},
@@ -344,6 +331,7 @@ static struct mode_table auth_table[] = {
 	{"no_tilde",		CONF_FLAGS_NO_TILDE	},
 	{"need_ident",		CONF_FLAGS_NEED_IDENTD	},
 	{"have_ident",		CONF_FLAGS_NEED_IDENTD	},
+	{"need_ssl", 		CONF_FLAGS_NEED_SSL	},
 	{"need_sasl",		CONF_FLAGS_NEED_SASL	},
 	{NULL, 0}
 };
@@ -353,6 +341,7 @@ static struct mode_table connect_table[] = {
 	{ "compressed",	SERVER_COMPRESSED	},
 	{ "encrypted",	SERVER_ENCRYPTED	},
 	{ "topicburst",	SERVER_TB		},
+	{ "ssl",	SERVER_SSL		},
 	{ NULL,		0			},
 };
 
@@ -376,6 +365,10 @@ static struct mode_table shared_table[] =
 	{ "kline",	SHARED_PKLINE|SHARED_TKLINE	},
 	{ "xline",	SHARED_PXLINE|SHARED_TXLINE	},
 	{ "resv",	SHARED_PRESV|SHARED_TRESV	},
+	{ "dline",  SHARED_PDLINE|SHARED_TDLINE },
+	{ "tdline", SHARED_TDLINE	},
+	{ "pdline", SHARED_PDLINE   },
+	{ "undline",    SHARED_UNDLINE  },
 	{ "tkline",	SHARED_TKLINE	},
 	{ "unkline",	SHARED_UNKLINE	},
 	{ "txline",	SHARED_TXLINE	},
@@ -447,11 +440,65 @@ set_modes_from_table(int *modes, const char *whatis, struct mode_table *tab, con
 	}
 }
 
+static void
+conf_set_privset_extends(void *data)
+{
+	yy_privset_extends = rb_strdup((char *) data);
+}
+
+static void
+conf_set_privset_privs(void *data)
+{
+	char *privs = NULL;
+	conf_parm_t *args = data;
+
+	for (; args; args = args->next)
+	{
+		if (privs == NULL)
+			privs = rb_strdup(args->v.string);
+		else
+		{
+			char *privs_old = privs;
+
+			privs = rb_malloc(strlen(privs_old) + 1 + strlen(args->v.string) + 1);
+			strcpy(privs, privs_old);
+			strcat(privs, " ");
+			strcat(privs, args->v.string);
+
+			rb_free(privs_old);
+		}
+	}
+
+	if (privs)
+	{
+		if (yy_privset_extends)
+		{
+			struct PrivilegeSet *set = privilegeset_get(yy_privset_extends);
+
+			if (!set)
+			{
+				conf_report_error("Warning -- unknown parent privilege set %s for %s; assuming defaults", yy_privset_extends, conf_cur_block_name);
+
+				set = privilegeset_get("default");
+			}
+
+			privilegeset_extend(set, conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
+
+			rb_free(yy_privset_extends);
+			yy_privset_extends = NULL;
+		}
+		else
+			privilegeset_set_new(conf_cur_block_name != NULL ? conf_cur_block_name : "<unknown>", privs, 0);
+
+		rb_free(privs);
+	}
+}
+
 static int
 conf_begin_oper(struct TopConf *tc)
 {
-	dlink_node *ptr;
-	dlink_node *next_ptr;
+	rb_dlink_node *ptr;
+	rb_dlink_node *next_ptr;
 
 	if(yy_oper != NULL)
 	{
@@ -459,14 +506,14 @@ conf_begin_oper(struct TopConf *tc)
 		yy_oper = NULL;
 	}
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
 	{
 		free_oper_conf(ptr->data);
-		dlinkDestroy(ptr, &yy_oper_list);
+		rb_dlinkDestroy(ptr, &yy_oper_list);
 	}
 
 	yy_oper = make_oper_conf();
-	yy_oper->flags |= OPER_ENCRYPTED|OPER_OPERWALL|OPER_REMOTEBAN;
+	yy_oper->flags |= OPER_ENCRYPTED;
 
 	return 0;
 }
@@ -475,15 +522,15 @@ static int
 conf_end_oper(struct TopConf *tc)
 {
 	struct oper_conf *yy_tmpoper;
-	dlink_node *ptr;
-	dlink_node *next_ptr;
+	rb_dlink_node *ptr;
+	rb_dlink_node *next_ptr;
 
 	if(conf_cur_block_name != NULL)
 	{
 		if(strlen(conf_cur_block_name) > OPERNICKLEN)
 			conf_cur_block_name[OPERNICKLEN] = '\0';
 
-		DupString(yy_oper->name, conf_cur_block_name);
+		yy_oper->name = rb_strdup(conf_cur_block_name);
 	}
 
 	if(EmptyString(yy_oper->name))
@@ -503,23 +550,28 @@ conf_end_oper(struct TopConf *tc)
 		return 0;
 	}
 
+
+	if (!yy_oper->privset)
+		yy_oper->privset = privilegeset_get("default");
+
 	/* now, yy_oper_list contains a stack of oper_conf's with just user
 	 * and host in, yy_oper contains the rest of the information which
 	 * we need to copy into each element in yy_oper_list
 	 */
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_oper_list.head)
 	{
 		yy_tmpoper = ptr->data;
 
-		DupString(yy_tmpoper->name, yy_oper->name);
+		yy_tmpoper->name = rb_strdup(yy_oper->name);
 
 		/* could be an rsa key instead.. */
 		if(!EmptyString(yy_oper->passwd))
-			DupString(yy_tmpoper->passwd, yy_oper->passwd);
+			yy_tmpoper->passwd = rb_strdup(yy_oper->passwd);
 
 		yy_tmpoper->flags = yy_oper->flags;
 		yy_tmpoper->umodes = yy_oper->umodes;
 		yy_tmpoper->snomask = yy_oper->snomask;
+		yy_tmpoper->privset = yy_oper->privset;
 
 #ifdef HAVE_LIBCRYPTO
 		if(yy_oper->rsa_pubkey_file)
@@ -537,7 +589,7 @@ conf_end_oper(struct TopConf *tc)
 			yy_tmpoper->rsa_pubkey =
 				(RSA *) PEM_read_bio_RSA_PUBKEY(file, NULL, 0, NULL);
 
-			BIO_set_close(file, BIO_CLOSE);
+			(void)BIO_set_close(file, BIO_CLOSE);
 			BIO_free(file);
 
 			if(yy_tmpoper->rsa_pubkey == NULL)
@@ -551,7 +603,7 @@ conf_end_oper(struct TopConf *tc)
 #endif
 
 		/* all is ok, put it on oper_conf_list */
-		dlinkMoveNode(ptr, &yy_oper_list, &oper_conf_list);
+		rb_dlinkMoveNode(ptr, &yy_oper_list, &oper_conf_list);
 	}
 
 	free_oper_conf(yy_oper);
@@ -565,7 +617,19 @@ conf_set_oper_flags(void *data)
 {
 	conf_parm_t *args = data;
 
-	set_modes_from_table(&yy_oper->flags, "flag", flag_table, args);
+	set_modes_from_table(&yy_oper->flags, "flag", oper_table, args);
+}
+
+static void
+conf_set_oper_fingerprint(void *data)
+{
+	yy_oper->certfp = rb_strdup((char *) data);
+}
+
+static void
+conf_set_oper_privset(void *data)
+{
+	yy_oper->privset = privilegeset_get((char *) data);
 }
 
 static void
@@ -581,14 +645,14 @@ conf_set_oper_user(void *data)
 	{
 		*p++ = '\0';
 
-		DupString(yy_tmpoper->username, host);
-		DupString(yy_tmpoper->host, p);
+		yy_tmpoper->username = rb_strdup(host);
+		yy_tmpoper->host = rb_strdup(p);
 	}
 	else
 	{
 
-		DupString(yy_tmpoper->username, "*");
-		DupString(yy_tmpoper->host, host);
+		yy_tmpoper->username = rb_strdup("*");
+		yy_tmpoper->host = rb_strdup(host);
 	}
 
 	if(EmptyString(yy_tmpoper->username) || EmptyString(yy_tmpoper->host))
@@ -598,7 +662,7 @@ conf_set_oper_user(void *data)
 		return;
 	}
 
-	dlinkAddAlloc(yy_tmpoper, &yy_oper_list);
+	rb_dlinkAddAlloc(yy_tmpoper, &yy_oper_list);
 }
 
 static void
@@ -607,18 +671,18 @@ conf_set_oper_password(void *data)
 	if(yy_oper->passwd)
 	{
 		memset(yy_oper->passwd, 0, strlen(yy_oper->passwd));
-		MyFree(yy_oper->passwd);
+		rb_free(yy_oper->passwd);
 	}
 
-	DupString(yy_oper->passwd, (char *) data);
+	yy_oper->passwd = rb_strdup((char *) data);
 }
 
 static void
 conf_set_oper_rsa_public_key_file(void *data)
 {
 #ifdef HAVE_LIBCRYPTO
-	MyFree(yy_oper->rsa_pubkey_file);
-	DupString(yy_oper->rsa_pubkey_file, (char *) data);
+	rb_free(yy_oper->rsa_pubkey_file);
+	yy_oper->rsa_pubkey_file = rb_strdup((char *) data);
 #else
 	conf_report_error("Warning -- ignoring rsa_public_key_file (OpenSSL support not available");
 #endif
@@ -650,7 +714,7 @@ static int
 conf_end_class(struct TopConf *tc)
 {
 	if(conf_cur_block_name != NULL)
-		DupString(yy_class->class_name, conf_cur_block_name);
+		yy_class->class_name = rb_strdup(conf_cur_block_name);
 
 	if(EmptyString(yy_class->class_name))
 	{
@@ -670,21 +734,33 @@ conf_set_class_ping_time(void *data)
 }
 
 static void
-conf_set_class_cidr_bitlen(void *data)
+conf_set_class_cidr_ipv4_bitlen(void *data)
 {
-#ifdef IPV6
-	unsigned int maxsize = 128;
-#else
 	unsigned int maxsize = 32;
-#endif
 	if(*(unsigned int *) data > maxsize)
 		conf_report_error
-			("class::cidr_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
+			("class::cidr_ipv4_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
 			 *(unsigned int *) data, maxsize);
 	else
-		yy_class->cidr_bitlen = *(unsigned int *) data;
+		yy_class->cidr_ipv4_bitlen = *(unsigned int *) data;
 
 }
+
+#ifdef RB_IPV6
+static void
+conf_set_class_cidr_ipv6_bitlen(void *data)
+{
+	unsigned int maxsize = 128;
+	if(*(unsigned int *) data > maxsize)
+		conf_report_error
+			("class::cidr_ipv6_bitlen argument exceeds maxsize (%d > %d) - ignoring.",
+			 *(unsigned int *) data, maxsize);
+	else
+		yy_class->cidr_ipv6_bitlen = *(unsigned int *) data;
+
+}
+#endif
+
 static void
 conf_set_class_number_per_cidr(void *data)
 {
@@ -733,7 +809,7 @@ static char *listener_address;
 static int
 conf_begin_listen(struct TopConf *tc)
 {
-	MyFree(listener_address);
+	rb_free(listener_address);
 	listener_address = NULL;
 	return 0;
 }
@@ -741,13 +817,15 @@ conf_begin_listen(struct TopConf *tc)
 static int
 conf_end_listen(struct TopConf *tc)
 {
-	MyFree(listener_address);
+	rb_free(listener_address);
 	listener_address = NULL;
 	return 0;
 }
 
+
+
 static void
-conf_set_listen_port(void *data)
+conf_set_listen_port_both(void *data, int ssl)
 {
 	conf_parm_t *args = data;
 	for (; args; args = args->next)
@@ -760,48 +838,60 @@ conf_set_listen_port(void *data)
 		}
                 if(listener_address == NULL)
                 {
-			add_listener(args->v.number, listener_address, AF_INET);
-#ifdef IPV6
-			add_listener(args->v.number, listener_address, AF_INET6);
+			add_listener(args->v.number, listener_address, AF_INET, ssl);
+#ifdef RB_IPV6
+			add_listener(args->v.number, listener_address, AF_INET6, ssl);
 #endif
                 }
 		else
                 {
 			int family;
-#ifdef IPV6
+#ifdef RB_IPV6
 			if(strchr(listener_address, ':') != NULL)
 				family = AF_INET6;
 			else 
 #endif
 				family = AF_INET;
 		
-			add_listener(args->v.number, listener_address, family);
+			add_listener(args->v.number, listener_address, family, ssl);
                 
                 }
 
 	}
 }
 
+static void
+conf_set_listen_port(void *data)
+{
+	conf_set_listen_port_both(data, 0);
+}
+
+static void
+conf_set_listen_sslport(void *data)
+{
+	conf_set_listen_port_both(data, 1);
+}
+
 static void
 conf_set_listen_address(void *data)
 {
-	MyFree(listener_address);
-	DupString(listener_address, data);
+	rb_free(listener_address);
+	listener_address = rb_strdup(data);
 }
 
 static int
 conf_begin_auth(struct TopConf *tc)
 {
-	dlink_node *ptr;
-	dlink_node *next_ptr;
+	rb_dlink_node *ptr;
+	rb_dlink_node *next_ptr;
 
 	if(yy_aconf)
 		free_conf(yy_aconf);
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
 	{
 		free_conf(ptr->data);
-		dlinkDestroy(ptr, &yy_aconf_list);
+		rb_dlinkDestroy(ptr, &yy_aconf_list);
 	}
 
 	yy_aconf = make_conf();
@@ -813,12 +903,12 @@ conf_begin_auth(struct TopConf *tc)
 static int
 conf_end_auth(struct TopConf *tc)
 {
-	struct ConfItem *yy_tmp;
-	dlink_node *ptr;
-	dlink_node *next_ptr;
+	struct ConfItem *yy_tmp, *found_conf;
+	rb_dlink_node *ptr;
+	rb_dlink_node *next_ptr;
 
 	if(EmptyString(yy_aconf->name))
-		DupString(yy_aconf->name, "NOMATCH");
+		yy_aconf->name = rb_strdup("NOMATCH");
 
 	/* didnt even get one ->host? */
 	if(EmptyString(yy_aconf->host))
@@ -831,20 +921,31 @@ conf_end_auth(struct TopConf *tc)
 	collapse(yy_aconf->user);
 	collapse(yy_aconf->host);
 	conf_add_class_to_conf(yy_aconf);
-	add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf);
+	if ((found_conf = find_exact_conf_by_address("*", CONF_CLIENT, "*")) && found_conf->spasswd == NULL)
+		conf_report_error("Ignoring redundant auth block (after *@*)");
+	else if ((found_conf = find_exact_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user)) &&
+			(!found_conf->spasswd || (yy_aconf->spasswd &&
+			    0 == irccmp(found_conf->spasswd, yy_aconf->spasswd))))
+		conf_report_error("Ignoring duplicate auth block for %s@%s",
+				yy_aconf->user, yy_aconf->host);
+	else
+		add_conf_by_address(yy_aconf->host, CONF_CLIENT, yy_aconf->user, yy_aconf->spasswd, yy_aconf);
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_aconf_list.head)
 	{
 		yy_tmp = ptr->data;
 
 		if(yy_aconf->passwd)
-			DupString(yy_tmp->passwd, yy_aconf->passwd);
+			yy_tmp->passwd = rb_strdup(yy_aconf->passwd);
 
+		if(yy_aconf->spasswd)
+			yy_tmp->spasswd = rb_strdup(yy_aconf->spasswd);
+		
 		/* this will always exist.. */
-		DupString(yy_tmp->name, yy_aconf->name);
+		yy_tmp->name = rb_strdup(yy_aconf->name);
 
 		if(yy_aconf->className)
-			DupString(yy_tmp->className, yy_aconf->className);
+			yy_tmp->className = rb_strdup(yy_aconf->className);
 
 		yy_tmp->flags = yy_aconf->flags;
 		yy_tmp->port = yy_aconf->port;
@@ -854,8 +955,14 @@ conf_end_auth(struct TopConf *tc)
 
 		conf_add_class_to_conf(yy_tmp);
 
-		add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp);
-		dlinkDestroy(ptr, &yy_aconf_list);
+		if (find_exact_conf_by_address("*", CONF_CLIENT, "*"))
+			conf_report_error("Ignoring redundant auth block (after *@*)");
+		else if (find_exact_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user))
+			conf_report_error("Ignoring duplicate auth block for %s@%s",
+					yy_tmp->user, yy_tmp->host);
+		else
+			add_conf_by_address(yy_tmp->host, CONF_CLIENT, yy_tmp->user, yy_tmp->spasswd, yy_tmp);
+		rb_dlinkDestroy(ptr, &yy_aconf_list);
 	}
 
 	yy_aconf = NULL;
@@ -881,17 +988,26 @@ conf_set_auth_user(void *data)
 	{
 		*p++ = '\0';
 
-		DupString(yy_tmp->user, data);
-		DupString(yy_tmp->host, p);
+		yy_tmp->user = rb_strdup(data);
+		yy_tmp->host = rb_strdup(p);
 	}
 	else
 	{
-		DupString(yy_tmp->user, "*");
-		DupString(yy_tmp->host, data);
+		yy_tmp->user = rb_strdup("*");
+		yy_tmp->host = rb_strdup(data);
 	}
 
 	if(yy_aconf != yy_tmp)
-		dlinkAddAlloc(yy_tmp, &yy_aconf_list);
+		rb_dlinkAddAlloc(yy_tmp, &yy_aconf_list);
+}
+
+static void
+conf_set_auth_auth_user(void *data)
+{
+	if(yy_aconf->spasswd)
+		memset(yy_aconf->spasswd, 0, strlen(yy_aconf->spasswd));
+	rb_free(yy_aconf->spasswd);
+	yy_aconf->spasswd = rb_strdup(data);
 }
 
 static void
@@ -899,8 +1015,26 @@ conf_set_auth_passwd(void *data)
 {
 	if(yy_aconf->passwd)
 		memset(yy_aconf->passwd, 0, strlen(yy_aconf->passwd));
-	MyFree(yy_aconf->passwd);
-	DupString(yy_aconf->passwd, data);
+	rb_free(yy_aconf->passwd);
+	yy_aconf->passwd = rb_strdup(data);
+}
+
+static void
+conf_set_auth_autojoin(void *data)
+{
+	if(yy_aconf->autojoin)
+		memset(yy_aconf->autojoin, 0, strlen(yy_aconf->autojoin));
+	rb_free(yy_aconf->autojoin);
+	yy_aconf->autojoin = rb_strdup(data);
+}
+
+static void
+conf_set_auth_autojoin_opers(void *data)
+{
+	if(yy_aconf->autojoin_opers)
+		memset(yy_aconf->autojoin_opers, 0, strlen(yy_aconf->autojoin));
+	rb_free(yy_aconf->autojoin_opers);
+	yy_aconf->autojoin_opers = rb_strdup(data);
 }
 
 static void
@@ -959,8 +1093,8 @@ conf_set_auth_spoof(void *data)
 		return;
 	}
 
-	MyFree(yy_aconf->name);
-	DupString(yy_aconf->name, data);
+	rb_free(yy_aconf->name);
+	yy_aconf->name = rb_strdup(data);
 	yy_aconf->flags |= CONF_FLAGS_SPOOF_IP;
 }
 
@@ -976,8 +1110,8 @@ static void
 conf_set_auth_redir_serv(void *data)
 {
 	yy_aconf->flags |= CONF_FLAGS_REDIR;
-	MyFree(yy_aconf->name);
-	DupString(yy_aconf->name, data);
+	rb_free(yy_aconf->name);
+	yy_aconf->name = rb_strdup(data);
 }
 
 static void
@@ -992,8 +1126,8 @@ conf_set_auth_redir_port(void *data)
 static void
 conf_set_auth_class(void *data)
 {
-	MyFree(yy_aconf->className);
-	DupString(yy_aconf->className, data);
+	rb_free(yy_aconf->className);
+	yy_aconf->className = rb_strdup(data);
 }
 
 /* ok, shared_oper handles the stacking, shared_flags handles adding
@@ -1003,12 +1137,12 @@ conf_set_auth_class(void *data)
 static int
 conf_cleanup_shared(struct TopConf *tc)
 {
-	dlink_node *ptr, *next_ptr;
+	rb_dlink_node *ptr, *next_ptr;
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
 	{
 		free_remote_conf(ptr->data);
-		dlinkDestroy(ptr, &yy_shared_list);
+		rb_dlinkDestroy(ptr, &yy_shared_list);
 	}
 
 	if(yy_shared != NULL)
@@ -1040,11 +1174,11 @@ conf_set_shared_oper(void *data)
 			return;
 		}
 
-		DupString(yy_shared->server, args->v.string);
+		yy_shared->server = rb_strdup(args->v.string);
 		args = args->next;
 	}
 	else
-		DupString(yy_shared->server, "*");
+		yy_shared->server = rb_strdup("*");
 
 	if((args->type & CF_MTYPE) != CF_QSTRING)
 	{
@@ -1062,16 +1196,16 @@ conf_set_shared_oper(void *data)
 	*p++ = '\0';
 
 	if(EmptyString(p))
-		DupString(yy_shared->host, "*");
+		yy_shared->host = rb_strdup("*");
 	else
-		DupString(yy_shared->host, p);
+		yy_shared->host = rb_strdup(p);
 
 	if(EmptyString(username))
-		DupString(yy_shared->username, "*");
+		yy_shared->username = rb_strdup("*");
 	else
-		DupString(yy_shared->username, username);
+		yy_shared->username = rb_strdup(username);
 
-	dlinkAddAlloc(yy_shared, &yy_shared_list);
+	rb_dlinkAddAlloc(yy_shared, &yy_shared_list);
 	yy_shared = NULL;
 }
 
@@ -1080,20 +1214,20 @@ conf_set_shared_flags(void *data)
 {
 	conf_parm_t *args = data;
 	int flags = 0;
-	dlink_node *ptr, *next_ptr;
+	rb_dlink_node *ptr, *next_ptr;
 
 	if(yy_shared != NULL)
 		free_remote_conf(yy_shared);
 
 	set_modes_from_table(&flags, "flag", shared_table, args);
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_shared_list.head)
 	{
 		yy_shared = ptr->data;
 
 		yy_shared->flags = flags;
-		dlinkDestroy(ptr, &yy_shared_list);
-		dlinkAddTail(yy_shared, &yy_shared->node, &shared_conf_list);
+		rb_dlinkDestroy(ptr, &yy_shared_list);
+		rb_dlinkAddTail(yy_shared, &yy_shared->node, &shared_conf_list);
 	}
 
 	yy_shared = NULL;
@@ -1107,9 +1241,10 @@ conf_begin_connect(struct TopConf *tc)
 
 	yy_server = make_server_conf();
 	yy_server->port = PORTNUM;
+	yy_server->flags |= SERVER_TB;
 
 	if(conf_cur_block_name != NULL)
-		DupString(yy_server->name, conf_cur_block_name);
+		yy_server->name = rb_strdup(conf_cur_block_name);
 
 	return 0;
 }
@@ -1153,7 +1288,7 @@ conf_end_connect(struct TopConf *tc)
 #endif
 
 	add_server_conf(yy_server);
-	dlinkAdd(yy_server, &yy_server->node, &server_conf_list);
+	rb_dlinkAdd(yy_server, &yy_server->node, &server_conf_list);
 
 	yy_server = NULL;
 	return 0;
@@ -1162,8 +1297,8 @@ conf_end_connect(struct TopConf *tc)
 static void
 conf_set_connect_host(void *data)
 {
-	MyFree(yy_server->host);
-	DupString(yy_server->host, data);
+	rb_free(yy_server->host);
+	yy_server->host = rb_strdup(data);
 	if (strchr(yy_server->host, ':'))
 		yy_server->aftype = AF_INET6;
 }
@@ -1171,7 +1306,7 @@ conf_set_connect_host(void *data)
 static void
 conf_set_connect_vhost(void *data)
 {
-	if(inetpton_sock(data, (struct sockaddr *)&yy_server->my_ipnum) <= 0)
+	if(rb_inet_pton_sock(data, (struct sockaddr *)&yy_server->my_ipnum) <= 0)
 	{
 		conf_report_error("Invalid netmask for server vhost (%s)",
 		    		  (char *) data);
@@ -1187,10 +1322,10 @@ conf_set_connect_send_password(void *data)
 	if(yy_server->spasswd)
 	{
 		memset(yy_server->spasswd, 0, strlen(yy_server->spasswd));
-		MyFree(yy_server->spasswd);
+		rb_free(yy_server->spasswd);
 	}
 
-	DupString(yy_server->spasswd, data);
+	yy_server->spasswd = rb_strdup(data);
 }
 
 static void
@@ -1199,9 +1334,9 @@ conf_set_connect_accept_password(void *data)
 	if(yy_server->passwd)
 	{
 		memset(yy_server->passwd, 0, strlen(yy_server->passwd));
-		MyFree(yy_server->passwd);
+		rb_free(yy_server->passwd);
 	}
-	DupString(yy_server->passwd, data);
+	yy_server->passwd = rb_strdup(data);
 }
 
 static void
@@ -1222,7 +1357,7 @@ conf_set_connect_aftype(void *data)
 
 	if(strcasecmp(aft, "ipv4") == 0)
 		yy_server->aftype = AF_INET;
-#ifdef IPV6
+#ifdef RB_IPV6
 	else if(strcasecmp(aft, "ipv6") == 0)
 		yy_server->aftype = AF_INET6;
 #endif
@@ -1252,9 +1387,9 @@ conf_set_connect_hub_mask(void *data)
 	yy_hub = make_remote_conf();
 	yy_hub->flags = CONF_HUB;
 
-	DupString(yy_hub->host, data);
-	DupString(yy_hub->server, yy_server->name);
-	dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
+	yy_hub->host = rb_strdup(data);
+	yy_hub->server = rb_strdup(yy_server->name);
+	rb_dlinkAdd(yy_hub, &yy_hub->node, &hubleaf_conf_list);
 }
 
 static void
@@ -1268,16 +1403,16 @@ conf_set_connect_leaf_mask(void *data)
 	yy_leaf = make_remote_conf();
 	yy_leaf->flags = CONF_LEAF;
 
-	DupString(yy_leaf->host, data);
-	DupString(yy_leaf->server, yy_server->name);
-	dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
+	yy_leaf->host = rb_strdup(data);
+	yy_leaf->server = rb_strdup(yy_server->name);
+	rb_dlinkAdd(yy_leaf, &yy_leaf->node, &hubleaf_conf_list);
 }
 
 static void
 conf_set_connect_class(void *data)
 {
-	MyFree(yy_server->class_name);
-	DupString(yy_server->class_name, data);
+	rb_free(yy_server->class_name);
+	yy_server->class_name = rb_strdup(data);
 }
 
 static void
@@ -1292,21 +1427,21 @@ conf_set_exempt_ip(void *data)
 	}
 
 	yy_tmp = make_conf();
-	DupString(yy_tmp->passwd, "*");
-	DupString(yy_tmp->host, data);
+	yy_tmp->passwd = rb_strdup("*");
+	yy_tmp->host = rb_strdup(data);
 	yy_tmp->status = CONF_EXEMPTDLINE;
-	add_conf_by_address(yy_tmp->host, CONF_EXEMPTDLINE, NULL, yy_tmp);
+	add_conf_by_address(yy_tmp->host, CONF_EXEMPTDLINE, NULL, NULL, yy_tmp);
 }
 
 static int
 conf_cleanup_cluster(struct TopConf *tc)
 {
-	dlink_node *ptr, *next_ptr;
+	rb_dlink_node *ptr, *next_ptr;
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
 	{
 		free_remote_conf(ptr->data);
-		dlinkDestroy(ptr, &yy_cluster_list);
+		rb_dlinkDestroy(ptr, &yy_cluster_list);
 	}
 
 	if(yy_shared != NULL)
@@ -1325,8 +1460,8 @@ conf_set_cluster_name(void *data)
 		free_remote_conf(yy_shared);
 
 	yy_shared = make_remote_conf();
-	DupString(yy_shared->server, data);
-	dlinkAddAlloc(yy_shared, &yy_cluster_list);
+	yy_shared->server = rb_strdup(data);
+	rb_dlinkAddAlloc(yy_shared, &yy_cluster_list);
 
 	yy_shared = NULL;
 }
@@ -1336,19 +1471,19 @@ conf_set_cluster_flags(void *data)
 {
 	conf_parm_t *args = data;
 	int flags = 0;
-	dlink_node *ptr, *next_ptr;
+	rb_dlink_node *ptr, *next_ptr;
 
 	if(yy_shared != NULL)
 		free_remote_conf(yy_shared);
 
 	set_modes_from_table(&flags, "flag", cluster_table, args);
 
-	DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
+	RB_DLINK_FOREACH_SAFE(ptr, next_ptr, yy_cluster_list.head)
 	{
 		yy_shared = ptr->data;
 		yy_shared->flags = flags;
-		dlinkAddTail(yy_shared, &yy_shared->node, &cluster_conf_list);
-		dlinkDestroy(ptr, &yy_cluster_list);
+		rb_dlinkAddTail(yy_shared, &yy_shared->node, &cluster_conf_list);
+		rb_dlinkDestroy(ptr, &yy_cluster_list);
 	}
 
 	yy_shared = NULL;
@@ -1528,14 +1663,6 @@ conf_set_serverhide_links_delay(void *data)
 {
 	int val = *(unsigned int *) data;
 
-	if((val > 0) && ConfigServerHide.links_disabled == 1)
-	{
-		eventAddIsh("cache_links", cache_links, NULL, val);
-		ConfigServerHide.links_disabled = 0;
-	}
-	else if(val != ConfigServerHide.links_delay)
-		eventUpdate("cache_links", val);
-
 	ConfigServerHide.links_delay = val;
 }
 
@@ -1543,9 +1670,9 @@ static int
 conf_begin_service(struct TopConf *tc)
 {
 	struct Client *target_p;
-	dlink_node *ptr;
+	rb_dlink_node *ptr;
 
-	DLINK_FOREACH(ptr, global_serv_list.head)
+	RB_DLINK_FOREACH(ptr, global_serv_list.head)
 	{
 		target_p = ptr->data;
 
@@ -1581,34 +1708,20 @@ conf_set_service_name(void *data)
 		return;
 	}
 
-	DupString(tmp, data);
-	dlinkAddAlloc(tmp, &service_list);
+	tmp = rb_strdup(data);
+	rb_dlinkAddAlloc(tmp, &service_list);
 
 	if((target_p = find_server(NULL, tmp)))
 		target_p->flags |= FLAGS_SERVICE;
 }
 
-static int
-alias_hash(const char *p)
-{
-	int hash_val = 0;
-
-	while (*p)
-	{
-		hash_val += ((int) (*p) & 0xDF);
-		p++;
-	}
-
-	return (hash_val % MAX_MSG_HASH);
-}
-
 static int
 conf_begin_alias(struct TopConf *tc)
 {
-	yy_alias = MyMalloc(sizeof(struct alias_entry));
+	yy_alias = rb_malloc(sizeof(struct alias_entry));
 
 	if (conf_cur_block_name != NULL)
-		DupString(yy_alias->name, conf_cur_block_name);
+		yy_alias->name = rb_strdup(conf_cur_block_name);
 
 	yy_alias->flags = 0;
 	yy_alias->hits = 0;
@@ -1619,8 +1732,6 @@ conf_begin_alias(struct TopConf *tc)
 static int
 conf_end_alias(struct TopConf *tc)
 {
-	int hashval;
-
 	if (yy_alias == NULL)
 		return -1;
 
@@ -1628,7 +1739,7 @@ conf_end_alias(struct TopConf *tc)
 	{
 		conf_report_error("Ignoring alias -- must have a name.");
 
-		MyFree(yy_alias);
+		rb_free(yy_alias);
 
 		return -1;
 	}
@@ -1637,14 +1748,12 @@ conf_end_alias(struct TopConf *tc)
 	{
 		conf_report_error("Ignoring alias -- must have a target.");
 
-		MyFree(yy_alias);
+		rb_free(yy_alias);
 
 		return -1;
 	}
 
-	hashval = alias_hash(yy_alias->name);
-
-	dlinkAddAlloc(yy_alias, &alias_hash_table[hashval]);
+	irc_dictionary_add(alias_dict, yy_alias->name, yy_alias);
 
 	return 0;
 }
@@ -1655,7 +1764,7 @@ conf_set_alias_name(void *data)
 	if (data == NULL || yy_alias == NULL)	/* this shouldn't ever happen */
 		return;
 
-	DupString(yy_alias->name, data);
+	yy_alias->name = rb_strdup(data);
 }
 
 static void
@@ -1664,25 +1773,25 @@ conf_set_alias_target(void *data)
 	if (data == NULL || yy_alias == NULL)	/* this shouldn't ever happen */
 		return;
 
-	DupString(yy_alias->target, data);
+	yy_alias->target = rb_strdup(data);
 }
 
 static void
 conf_set_blacklist_host(void *data)
 {
-	DupString(yy_blacklist_host, data);
+	yy_blacklist_host = rb_strdup(data);
 }
 
 static void
 conf_set_blacklist_reason(void *data)
 {
-	DupString(yy_blacklist_reason, data);
+	yy_blacklist_reason = rb_strdup(data);
 
 	if (yy_blacklist_host && yy_blacklist_reason)
 	{
 		new_blacklist(yy_blacklist_host, yy_blacklist_reason);
-		MyFree(yy_blacklist_host);
-		MyFree(yy_blacklist_reason);
+		rb_free(yy_blacklist_host);
+		rb_free(yy_blacklist_reason);
 		yy_blacklist_host = NULL;
 		yy_blacklist_reason = NULL;
 	}
@@ -1698,7 +1807,7 @@ conf_report_error(const char *fmt, ...)
 	char msg[IRCD_BUFSIZE + 1] = { 0 };
 
 	va_start(ap, fmt);
-	ircvsnprintf(msg, IRCD_BUFSIZE, fmt, ap);
+	rb_vsnprintf(msg, IRCD_BUFSIZE, fmt, ap);
 	va_end(ap);
 
 	if (testing_conf)
@@ -1721,7 +1830,7 @@ conf_start_block(char *block, char *name)
 	}
 
 	if(name)
-		DupString(conf_cur_block_name, name);
+		conf_cur_block_name = rb_strdup(name);
 	else
 		conf_cur_block_name = NULL;
 
@@ -1738,7 +1847,7 @@ conf_end_block(struct TopConf *tc)
 	if(tc->tc_efunc)
 		return tc->tc_efunc(tc);
 
-	MyFree(conf_cur_block_name);
+	rb_free(conf_cur_block_name);
 	return 0;
 }
 
@@ -1754,11 +1863,11 @@ conf_set_generic_string(void *data, int len, void *location)
 	char **loc = location;
 	char *input = data;
 
-	if(len && strlen(input) > len)
+	if(len && strlen(input) > (unsigned int)len)
 		input[len] = '\0';
 
-	MyFree(*loc);
-	DupString(*loc, input);
+	rb_free(*loc);
+	*loc = rb_strdup(input);
 }
 
 int
@@ -1800,9 +1909,9 @@ conf_call_set(struct TopConf *tc, char *item, conf_parm_t * value, int type)
 			value->v.list->type = CF_STRING;
 
 			if(cp->v.number == 1)
-				DupString(cp->v.string, "yes");
+				cp->v.string = rb_strdup("yes");
 			else
-				DupString(cp->v.string, "no");
+				cp->v.string = rb_strdup("no");
 		}
 
 		/* maybe it's a CF_TIME and they passed CF_INT --
@@ -1870,14 +1979,14 @@ add_conf_item(const char *topconf, const char *name, int type, void (*func) (voi
 	if((cf = find_conf_item(tc, name)) != NULL)
 		return -1;
 
-	cf = MyMalloc(sizeof(struct ConfEntry));
+	cf = rb_malloc(sizeof(struct ConfEntry));
 
-	DupString(cf->cf_name, name);
+	cf->cf_name = name;
 	cf->cf_type = type;
 	cf->cf_func = func;
 	cf->cf_arg = NULL;
 
-	dlinkAddAlloc(cf, &tc->tc_items);
+	rb_dlinkAddAlloc(cf, &tc->tc_items);
 
 	return 0;
 }
@@ -1887,7 +1996,7 @@ remove_conf_item(const char *topconf, const char *name)
 {
 	struct TopConf *tc;
 	struct ConfEntry *cf;
-	dlink_node *ptr;
+	rb_dlink_node *ptr;
 
 	if((tc = find_top_conf(topconf)) == NULL)
 		return -1;
@@ -1895,11 +2004,11 @@ remove_conf_item(const char *topconf, const char *name)
 	if((cf = find_conf_item(tc, name)) == NULL)
 		return -1;
 
-	if((ptr = dlinkFind(cf, &tc->tc_items)) == NULL)
+	if((ptr = rb_dlinkFind(cf, &tc->tc_items)) == NULL)
 		return -1;
 
-	dlinkDestroy(ptr, &tc->tc_items);
-	MyFree(cf);
+	rb_dlinkDestroy(ptr, &tc->tc_items);
+	rb_free(cf);
 
 	return 0;
 }
@@ -1910,7 +2019,6 @@ static struct ConfEntry conf_serverinfo_table[] =
 	{ "description", 	CF_QSTRING, NULL, 0, &ServerInfo.description	},
 	{ "network_desc", 	CF_QSTRING, NULL, 0, &ServerInfo.network_desc	},
 	{ "hub", 		CF_YESNO,   NULL, 0, &ServerInfo.hub		},
-	{ "use_ts6", 		CF_YESNO,   NULL, 0, &ServerInfo.use_ts6	},
 
 	{ "network_name", 	CF_QSTRING, conf_set_serverinfo_network_name,	0, NULL },
 	{ "name", 		CF_QSTRING, conf_set_serverinfo_name,	0, NULL },
@@ -1918,6 +2026,14 @@ static struct ConfEntry conf_serverinfo_table[] =
 	{ "vhost", 		CF_QSTRING, conf_set_serverinfo_vhost,	0, NULL },
 	{ "vhost6", 		CF_QSTRING, conf_set_serverinfo_vhost6,	0, NULL },
 
+	{ "ssl_private_key",    CF_QSTRING, NULL, 0, &ServerInfo.ssl_private_key },
+	{ "ssl_ca_cert",        CF_QSTRING, NULL, 0, &ServerInfo.ssl_ca_cert },
+	{ "ssl_cert",           CF_QSTRING, NULL, 0, &ServerInfo.ssl_cert },   
+	{ "ssl_dh_params",      CF_QSTRING, NULL, 0, &ServerInfo.ssl_dh_params },
+	{ "ssld_count",		CF_INT,	    NULL, 0, &ServerInfo.ssld_count },
+
+	{ "default_max_clients",CF_INT,     NULL, 0, &ServerInfo.default_max_clients },
+
 	{ "\0",	0, NULL, 0, NULL }
 };
 
@@ -1937,7 +2053,6 @@ static struct ConfEntry conf_log_table[] =
 	{ "fname_foperlog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_foperlog	},
 	{ "fname_serverlog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_serverlog	},
 	{ "fname_killlog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_killlog	},
-	{ "fname_glinelog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_glinelog	},
 	{ "fname_klinelog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_klinelog	},
 	{ "fname_operspylog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_operspylog	},
 	{ "fname_ioerrorlog", 	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.fname_ioerrorlog },
@@ -1949,16 +2064,28 @@ static struct ConfEntry conf_operator_table[] =
 	{ "rsa_public_key_file",  CF_QSTRING, conf_set_oper_rsa_public_key_file, 0, NULL },
 	{ "flags",	CF_STRING | CF_FLIST, conf_set_oper_flags,	0, NULL },
 	{ "umodes",	CF_STRING | CF_FLIST, conf_set_oper_umodes,	0, NULL },
+	{ "privset",	CF_QSTRING, conf_set_oper_privset,	0, NULL },
 	{ "snomask",    CF_QSTRING, conf_set_oper_snomask,      0, NULL },
 	{ "user",	CF_QSTRING, conf_set_oper_user,		0, NULL },
 	{ "password",	CF_QSTRING, conf_set_oper_password,	0, NULL },
+	{ "fingerprint",	CF_QSTRING, conf_set_oper_fingerprint,	0, NULL },
 	{ "\0",	0, NULL, 0, NULL }
 };
 
+static struct ConfEntry conf_privset_table[] =
+{
+	{ "extends",	CF_QSTRING,		conf_set_privset_extends,	0, NULL },
+	{ "privs",	CF_STRING | CF_FLIST,	conf_set_privset_privs,		0, NULL },
+	{ "\0", 0, NULL, 0, NULL }
+};
+
 static struct ConfEntry conf_class_table[] =
 {
 	{ "ping_time", 		CF_TIME, conf_set_class_ping_time,		0, NULL },
-	{ "cidr_bitlen",	CF_INT,  conf_set_class_cidr_bitlen,		0, NULL },
+	{ "cidr_ipv4_bitlen",	CF_INT,  conf_set_class_cidr_ipv4_bitlen,		0, NULL },
+#ifdef RB_IPV6
+	{ "cidr_ipv6_bitlen",	CF_INT,  conf_set_class_cidr_ipv6_bitlen,		0, NULL },
+#endif
 	{ "number_per_cidr",	CF_INT,  conf_set_class_number_per_cidr,	0, NULL },
 	{ "number_per_ip",	CF_INT,  conf_set_class_number_per_ip,		0, NULL },
 	{ "number_per_ip_global", CF_INT,conf_set_class_number_per_ip_global,	0, NULL },
@@ -1972,9 +2099,12 @@ static struct ConfEntry conf_class_table[] =
 static struct ConfEntry conf_auth_table[] =
 {
 	{ "user",	CF_QSTRING, conf_set_auth_user,		0, NULL },
+	{ "auth_user",  CF_QSTRING, conf_set_auth_auth_user,    0, NULL },
 	{ "password",	CF_QSTRING, conf_set_auth_passwd,	0, NULL },
 	{ "class",	CF_QSTRING, conf_set_auth_class,	0, NULL },
 	{ "spoof",	CF_QSTRING, conf_set_auth_spoof,	0, NULL },
+	{ "autojoin",  CF_QSTRING, conf_set_auth_autojoin,		0, NULL },
+	{ "autojoin_opers",	CF_QSTRING, conf_set_auth_autojoin_opers,	0, NULL },
 	{ "redirserv",	CF_QSTRING, conf_set_auth_redir_serv,	0, NULL },
 	{ "redirport",	CF_INT,     conf_set_auth_redir_port,	0, NULL },
 	{ "flags",	CF_STRING | CF_FLIST, conf_set_auth_flags,	0, NULL },
@@ -2016,7 +2146,6 @@ static struct ConfEntry conf_general_table[] =
 	{ "kline_reason",	CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.kline_reason },
 	{ "identify_service",	CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifyservice },
 	{ "identify_command",	CF_QSTRING, NULL, REALLEN, &ConfigFileEntry.identifycommand },
-	{ "servlink_path",	CF_QSTRING, NULL, MAXPATHLEN, &ConfigFileEntry.servlink_path },
 
 	{ "anti_spam_exit_message_time", CF_TIME,  NULL, 0, &ConfigFileEntry.anti_spam_exit_message_time },
 	{ "disable_fake_channels",	 CF_YESNO, NULL, 0, &ConfigFileEntry.disable_fake_channels },
@@ -2033,15 +2162,9 @@ static struct ConfEntry conf_general_table[] =
 	{ "connect_timeout",	CF_TIME,  NULL, 0, &ConfigFileEntry.connect_timeout	},
 	{ "default_floodcount", CF_INT,   NULL, 0, &ConfigFileEntry.default_floodcount	},
 	{ "disable_auth",	CF_YESNO, NULL, 0, &ConfigFileEntry.disable_auth	},
-	{ "dot_in_ip6_addr",	CF_YESNO, NULL, 0, &ConfigFileEntry.dot_in_ip6_addr	},
 	{ "dots_in_ident",	CF_INT,   NULL, 0, &ConfigFileEntry.dots_in_ident	},
 	{ "failed_oper_notice",	CF_YESNO, NULL, 0, &ConfigFileEntry.failed_oper_notice	},
-	{ "glines",		CF_YESNO, NULL, 0, &ConfigFileEntry.glines		},
-	{ "gline_min_cidr",	CF_INT,   NULL, 0, &ConfigFileEntry.gline_min_cidr	},
-	{ "gline_min_cidr6",	CF_INT,   NULL, 0, &ConfigFileEntry.gline_min_cidr6	},
-	{ "gline_time",		CF_TIME,  NULL, 0, &ConfigFileEntry.gline_time		},
 	{ "global_snotices",	CF_YESNO, NULL, 0, &ConfigFileEntry.global_snotices	},
-	{ "idletime",		CF_TIME,  NULL, 0, &ConfigFileEntry.idletime		},
 	{ "hide_spoof_ips",	CF_YESNO, NULL, 0, &ConfigFileEntry.hide_spoof_ips	},
 	{ "dline_with_reason",	CF_YESNO, NULL, 0, &ConfigFileEntry.dline_with_reason	},
 	{ "kline_with_reason",	CF_YESNO, NULL, 0, &ConfigFileEntry.kline_with_reason	},
@@ -2056,12 +2179,15 @@ static struct ConfEntry conf_general_table[] =
 	{ "no_oper_flood",	CF_YESNO, NULL, 0, &ConfigFileEntry.no_oper_flood	},
 	{ "operspy_admin_only",	CF_YESNO, NULL, 0, &ConfigFileEntry.operspy_admin_only	},
 	{ "operspy_dont_care_user_info", CF_YESNO, NULL, 0, &ConfigFileEntry.operspy_dont_care_user_info },
+	{ "secret_channels_in_whois", CF_YESNO, NULL, 0, &ConfigFileEntry.secret_channels_in_whois },
 	{ "pace_wait",		CF_TIME,  NULL, 0, &ConfigFileEntry.pace_wait		},
 	{ "pace_wait_simple",	CF_TIME,  NULL, 0, &ConfigFileEntry.pace_wait_simple	},
 	{ "ping_cookie",	CF_YESNO, NULL, 0, &ConfigFileEntry.ping_cookie		},
 	{ "reject_after_count",	CF_INT,   NULL, 0, &ConfigFileEntry.reject_after_count	},
 	{ "reject_ban_time",	CF_TIME,  NULL, 0, &ConfigFileEntry.reject_ban_time	},
 	{ "reject_duration",	CF_TIME,  NULL, 0, &ConfigFileEntry.reject_duration	},
+	{ "throttle_count",	CF_INT,   NULL, 0, &ConfigFileEntry.throttle_count	},
+	{ "throttle_duration",	CF_TIME,  NULL, 0, &ConfigFileEntry.throttle_duration	},
 	{ "short_motd",		CF_YESNO, NULL, 0, &ConfigFileEntry.short_motd		},
 	{ "stats_c_oper_only",	CF_YESNO, NULL, 0, &ConfigFileEntry.stats_c_oper_only	},
 	{ "stats_e_disabled",	CF_YESNO, NULL, 0, &ConfigFileEntry.stats_e_disabled	},
@@ -2080,10 +2206,10 @@ static struct ConfEntry conf_general_table[] =
 
 static struct ConfEntry conf_channel_table[] =
 {
+	{ "autochanmodes",	CF_QSTRING, NULL, 0, &ConfigChannel.autochanmodes	},
 	{ "default_split_user_count",	CF_INT,  NULL, 0, &ConfigChannel.default_split_user_count	 },
 	{ "default_split_server_count",	CF_INT,	 NULL, 0, &ConfigChannel.default_split_server_count },
 	{ "burst_topicwho",	CF_YESNO, NULL, 0, &ConfigChannel.burst_topicwho	},
-	{ "invite_ops_only",	CF_YESNO, NULL, 0, &ConfigChannel.invite_ops_only	},
 	{ "kick_on_split_riding", CF_YESNO, NULL, 0, &ConfigChannel.kick_on_split_riding },
 	{ "knock_delay",	CF_TIME,  NULL, 0, &ConfigChannel.knock_delay		},
 	{ "knock_delay_channel",CF_TIME,  NULL, 0, &ConfigChannel.knock_delay_channel	},
@@ -2092,10 +2218,17 @@ static struct ConfEntry conf_channel_table[] =
 	{ "max_chans_per_user", CF_INT,   NULL, 0, &ConfigChannel.max_chans_per_user 	},
 	{ "no_create_on_split", CF_YESNO, NULL, 0, &ConfigChannel.no_create_on_split 	},
 	{ "no_join_on_split",	CF_YESNO, NULL, 0, &ConfigChannel.no_join_on_split	},
+	{ "only_ascii_channels", CF_YESNO, NULL, 0, &ConfigChannel.only_ascii_channels },
+	{ "cycle_host_change",	CF_YESNO, NULL, 0, &ConfigChannel.cycle_host_change },
+	{ "host_in_topic",	CF_YESNO, NULL, 0, &ConfigChannel.host_in_topic	},
+	{ "use_halfop",		CF_YESNO, NULL, 0, &ConfigChannel.use_halfop		},
+	{ "use_owner",		CF_YESNO, NULL, 0, &ConfigChannel.use_owner		},
 	{ "use_except",		CF_YESNO, NULL, 0, &ConfigChannel.use_except		},
 	{ "use_invex",		CF_YESNO, NULL, 0, &ConfigChannel.use_invex		},
 	{ "use_knock",		CF_YESNO, NULL, 0, &ConfigChannel.use_knock		},
 	{ "use_forward",	CF_YESNO, NULL, 0, &ConfigChannel.use_forward		},
+	{ "resv_forcepart",     CF_YESNO, NULL, 0, &ConfigChannel.resv_forcepart	},
+	{ "kick_no_rejoin_time", CF_INT,  NULL, 0, &ConfigChannel.kick_no_rejoin_time	},
 	{ "\0", 		0, 	  NULL, 0, NULL }
 };
 
@@ -2121,9 +2254,11 @@ newconf_init()
 	add_top_conf("log", NULL, NULL, conf_log_table);
 	add_top_conf("operator", conf_begin_oper, conf_end_oper, conf_operator_table);
 	add_top_conf("class", conf_begin_class, conf_end_class, conf_class_table);
+	add_top_conf("privset", NULL, NULL, conf_privset_table);
 
 	add_top_conf("listen", conf_begin_listen, conf_end_listen, NULL);
 	add_conf_item("listen", "port", CF_INT | CF_FLIST, conf_set_listen_port);
+	add_conf_item("listen", "sslport", CF_INT | CF_FLIST, conf_set_listen_sslport);
 	add_conf_item("listen", "ip", CF_QSTRING, conf_set_listen_address);
 	add_conf_item("listen", "host", CF_QSTRING, conf_set_listen_address);