ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/svn/ircd-hybrid/trunk/src/ircd.c

Comparing ircd-hybrid/trunk/src/ircd.c (file contents):
Revision 4105 by michael, Mon Jun 30 15:39:47 2014 UTC vs.
Revision 6370 by michael, Wed Aug 19 10:37:10 2015 UTC

#	Line 1 | Line 1
1		/*
2		*  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3		*
4	<	*  Copyright (c) 1997-2014 ircd-hybrid development team
4	>	*  Copyright (c) 1997-2015 ircd-hybrid development team
5		*
6		*  This program is free software; you can redistribute it and/or modify
7		*  it under the terms of the GNU General Public License as published by
#	Line 15 | Line 15
15		*
16		*  You should have received a copy of the GNU General Public License
17		*  along with this program; if not, write to the Free Software
18	<	*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18	>	*  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19		*  USA
20		*/
21
#	Line 33 | Line 33
33		#include "event.h"
34		#include "fdlist.h"
35		#include "hash.h"
36	+	#include "id.h"
37		#include "irc_string.h"
38		#include "ircd_signal.h"
38	–	#include "gline.h"
39		#include "motd.h"
40		#include "conf.h"
41		#include "hostmask.h"
#	Line 56 | Line 56
56		#include "watch.h"
57		#include "conf_db.h"
58		#include "conf_class.h"
59	+	#include "ipcache.h"
60	+	#include "isupport.h"
61
62
63		#ifdef HAVE_LIBGEOIP
64		GeoIP *geoip_ctx;
65		#endif
66
67	<	/* /quote set variables */
66	<	struct SetOptions GlobalSetOptions;
67	>	struct SetOptions GlobalSetOptions;  /* /quote set variables */
68		struct Counter Count;
69		struct ServerState_t server_state;
70		struct ServerStatistics ServerStats;
71		struct timeval SystemTime;
72	<	struct Client me;             /* That's me */
73	<	struct LocalUser meLocalUser; /* That's also part of me */
72	>	struct Connection meConnection;  /* That's also part of me */
73	>	struct Client me = { .connection = &meConnection };  /* That's me */
74
75	+	char **myargv;
76		const char *logFileName = LPATH;
77		const char *pidFileName = PPATH;
78
79	<	char **myargv;
80	<
79	<	int dorehash = 0;
80	<	int doremotd = 0;
81	<
82	<	/* Set to zero because it should be initialized later using
83	<	* initialize_server_capabs
84	<	*/
85	<	unsigned int default_server_capabs;
79	>	unsigned int dorehash;
80	>	unsigned int doremotd;
81		unsigned int splitmode;
82		unsigned int splitchecking;
83		unsigned int split_users;
84		unsigned int split_servers;
85
91	–	static struct event event_cleanup_glines =
92	–	{
93	–	.name = "cleanup_glines",
94	–	.handler = cleanup_glines,
95	–	.when = CLEANUP_GLINES_TIME
96	–	};
97	–
86		static struct event event_cleanup_tklines =
87		{
88		.name = "cleanup_tklines",
#	Line 129 | Line 117 | struct event event_write_links_file =
117		.handler = write_links_file,
118		};
119
132	–	struct event event_check_splitmode =
133	–	{
134	–	.name = "check_splitmode",
135	–	.handler = check_splitmode,
136	–	.when = 60
137	–	};
120
121		/*
122		* print_startup - print startup information
#	Line 145 | Line 127 | print_startup(int pid)
127		printf("ircd: version %s(%s)\n", ircd_version, serno);
128		printf("ircd: pid %d\n", pid);
129		printf("ircd: running in %s mode from %s\n", !server_state.foreground ? "background"
130	<	: "foreground", ConfigFileEntry.dpath);
130	>	: "foreground", ConfigGeneral.dpath);
131		}
132
133		static void
#	Line 171 | Line 153 | static int printVersion = 0;
153
154		static struct lgetopt myopts[] =
155		{
156	<	{"configfile", &ConfigFileEntry.configfile,
156	>	{"configfile", &ConfigGeneral.configfile,
157		STRING, "File to use for ircd.conf"},
158	<	{"glinefile",  &ConfigFileEntry.glinefile,
177	<	STRING, "File to use for gline database"},
178	<	{"klinefile",  &ConfigFileEntry.klinefile,
158	>	{"klinefile",  &ConfigGeneral.klinefile,
159		STRING, "File to use for kline database"},
160	<	{"dlinefile",  &ConfigFileEntry.dlinefile,
160	>	{"dlinefile",  &ConfigGeneral.dlinefile,
161		STRING, "File to use for dline database"},
162	<	{"xlinefile",  &ConfigFileEntry.xlinefile,
162	>	{"xlinefile",  &ConfigGeneral.xlinefile,
163		STRING, "File to use for xline database"},
164	<	{"resvfile",  &ConfigFileEntry.resvfile,
164	>	{"resvfile",  &ConfigGeneral.resvfile,
165		STRING, "File to use for resv database"},
166		{"logfile",    &logFileName,
167		STRING, "File to use for ircd.log"},
#	Line 204 | Line 184 | set_time(void)
184		{
185		ilog(LOG_TYPE_IRCD, "Clock Failure (%s), TS can be corrupted",
186		strerror(errno));
187	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
187	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
188		"Clock Failure (%s), TS can be corrupted",
189		strerror(errno));
190	<	server_die("Clock Failure", 1);
190	>	server_die("Clock Failure", SERVER_SHUTDOWN);
191		}
192
193		if (newtime.tv_sec < CurrentTime)
#	Line 218 | Line 198 | set_time(void)
198		"System clock is running backwards - (%lu < %lu)",
199		(unsigned long)newtime.tv_sec,
200		(unsigned long)CurrentTime);
201	<	set_back_events(CurrentTime - newtime.tv_sec);
201	>	event_set_back_events(CurrentTime - newtime.tv_sec);
202		}
203
204		SystemTime.tv_sec  = newtime.tv_sec;
#	Line 232 | Line 212 | io_loop(void)
212		{
213		if (listing_client_list.head)
214		{
215	<	dlink_node *ptr = NULL, *ptr_next = NULL;
216	<	DLINK_FOREACH_SAFE(ptr, ptr_next, listing_client_list.head)
217	<	safe_list_channels(ptr->data, 0);
215	>	dlink_node *node = NULL, *node_next = NULL;
216	>	DLINK_FOREACH_SAFE(node, node_next, listing_client_list.head)
217	>	safe_list_channels(node->data, 0);
218		}
219
220		/* Run pending events */
#	Line 247 | Line 227 | io_loop(void)
227		/* Check to see whether we have to rehash the configuration .. */
228		if (dorehash)
229		{
230	<	rehash(1);
230	>	conf_rehash(1);
231		dorehash = 0;
232		}
233
234		if (doremotd)
235		{
236		motd_recache();
237	<	sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
237	>	sendto_realops_flags(UMODE_SERVNOTICE, L_ALL, SEND_NOTICE,
238		"Got signal SIGUSR1, reloading motd file(s)");
239		doremotd = 0;
240		}
#	Line 270 | Line 250 | io_loop(void)
250		static void
251		initialize_global_set_options(void)
252		{
253	<	memset(&GlobalSetOptions, 0, sizeof(GlobalSetOptions));
254	<
275	<	GlobalSetOptions.autoconn  = 1;
253	>	GlobalSetOptions.maxclients = ConfigServerInfo.default_max_clients;
254	>	GlobalSetOptions.autoconn = 1;
255		GlobalSetOptions.spam_time = MIN_JOIN_LEAVE_TIME;
256	<	GlobalSetOptions.spam_num  = MAX_JOIN_LEAVE_COUNT;
257	<
258	<	if (ConfigFileEntry.default_floodcount)
259	<	GlobalSetOptions.floodcount = ConfigFileEntry.default_floodcount;
281	<	else
282	<	GlobalSetOptions.floodcount = 10;
283	<
284	<	/* XXX I have no idea what to try here - Dianora */
285	<	GlobalSetOptions.joinfloodcount = 16;
286	<	GlobalSetOptions.joinfloodtime = 8;
256	>	GlobalSetOptions.spam_num = MAX_JOIN_LEAVE_COUNT;
257	>	GlobalSetOptions.floodcount = ConfigGeneral.default_floodcount;
258	>	GlobalSetOptions.joinfloodcount = ConfigChannel.default_join_flood_count;
259	>	GlobalSetOptions.joinfloodtime = ConfigChannel.default_join_flood_time;
260
261		split_servers = ConfigChannel.default_split_server_count;
262		split_users   = ConfigChannel.default_split_user_count;
#	Line 296 | Line 269 | initialize_global_set_options(void)
269		}
270
271		GlobalSetOptions.ident_timeout = IDENT_TIMEOUT;
299	–	/* End of global set options */
272		}
273
274		/* initialize_server_capabs()
#	Line 307 | Line 279 | initialize_global_set_options(void)
279		static void
280		initialize_server_capabs(void)
281		{
282	<	add_capability("QS", CAP_QS, 1);
283	<	add_capability("EOB", CAP_EOB, 1);
284	<	add_capability("TS6", CAP_TS6, 0);
285	<	add_capability("CLUSTER", CAP_CLUSTER, 1);
286	<	add_capability("SVS", CAP_SVS, 1);
287	<	add_capability("CHW", CAP_CHW, 1);
316	<	add_capability("HOPS", CAP_HOPS, 1);
282	>	add_capability("QS", CAPAB_QS);
283	>	add_capability("EOB", CAPAB_EOB);
284	>	add_capability("CLUSTER", CAPAB_CLUSTER);
285	>	add_capability("SVS", CAPAB_SVS);
286	>	add_capability("CHW", CAPAB_CHW);
287	>	add_capability("HOPS", CAPAB_HOPS);
288		}
289
290		/* write_pidfile()
#	Line 334 | Line 305 | write_pidfile(const char *filename)
305
306		snprintf(buff, sizeof(buff), "%u\n", pid);
307
308	<	if ((fputs(buff, fb) == -1))
309	<	ilog(LOG_TYPE_IRCD, "Error writing %u to pid file %s (%s)",
310	<	pid, filename, strerror(errno));
308	>	if (fputs(buff, fb) == -1)
309	>	ilog(LOG_TYPE_IRCD, "Error writing to pid file %s: %s",
310	>	filename, strerror(errno));
311
312		fclose(fb);
313		}
314		else
315	<	{
316	<	ilog(LOG_TYPE_IRCD, "Error opening pid file %s", filename);
346	<	}
315	>	ilog(LOG_TYPE_IRCD, "Error opening pid file %s: %s",
316	>	filename, strerror(errno));
317		}
318
319		/* check_pidfile()
#	Line 361 | Line 331 | check_pidfile(const char *filename)
331		char buff[IRCD_BUFSIZE];
332		pid_t pidfromfile;
333
364	–	/* Don't do logging here, since we don't have log() initialised */
334		if ((fb = fopen(filename, "r")))
335		{
336	<	if (fgets(buff, 20, fb) == NULL)
337	<	{
338	<	/* log(L_ERROR, "Error reading from pid file %s (%s)", filename,
370	<	* strerror(errno));
371	<	*/
372	<	}
336	>	if (!fgets(buff, 20, fb))
337	>	ilog(LOG_TYPE_IRCD, "Error reading from pid file %s: %s",
338	>	filename, strerror(errno));
339		else
340		{
341		pidfromfile = atoi(buff);
#	Line 385 | Line 351 | check_pidfile(const char *filename)
351		fclose(fb);
352		}
353		else if (errno != ENOENT)
354	<	{
355	<	/* log(L_ERROR, "Error opening pid file %s", filename); */
390	<	}
354	>	ilog(LOG_TYPE_IRCD, "Error opening pid file %s: %s",
355	>	filename, strerror(errno));
356		}
357
358		/* setup_corefile()
#	Line 430 | Line 395 | static void
395		ssl_init(void)
396		{
397		#ifdef HAVE_LIBCRYPTO
433	–	const unsigned char session_id[] = "ircd-hybrid";
434	–
398		SSL_load_error_strings();
399		SSLeay_add_ssl_algorithms();
400
401	<	if ((ServerInfo.server_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL)
401	>	if (!(ConfigServerInfo.server_ctx = SSL_CTX_new(SSLv23_server_method())))
402		{
403	<	const char *s;
403	>	const char *s = ERR_lib_error_string(ERR_get_error());
404
405	<	fprintf(stderr, "ERROR: Could not initialize the SSL Server context -- %s\n",
406	<	s = ERR_lib_error_string(ERR_get_error()));
407	<	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Server context -- %s\n", s);
405	>	fprintf(stderr, "ERROR: Could not initialize the SSL Server context -- %s\n", s);
406	>	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Server context -- %s", s);
407	>	exit(EXIT_FAILURE);
408	>	return;  /* Not reached */
409		}
410
411	<	SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
412	<	SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_TLS_ROLLBACK_BUG);
413	<	SSL_CTX_set_verify(ServerInfo.server_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
411	>	SSL_CTX_set_options(ConfigServerInfo.server_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TICKET);
412	>	SSL_CTX_set_options(ConfigServerInfo.server_ctx, SSL_OP_SINGLE_DH_USE|SSL_OP_CIPHER_SERVER_PREFERENCE);
413	>	SSL_CTX_set_verify(ConfigServerInfo.server_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
414		always_accept_verify_cb);
415	<	SSL_CTX_set_session_id_context(ServerInfo.server_ctx, session_id, sizeof(session_id) - 1);
415	>	SSL_CTX_set_session_cache_mode(ConfigServerInfo.server_ctx, SSL_SESS_CACHE_OFF);
416	>	SSL_CTX_set_cipher_list(ConfigServerInfo.server_ctx, "EECDH+HIGH:EDH+HIGH:HIGH:!aNULL");
417
418	<	#if OPENSSL_VERSION_NUMBER >= 0x1000005FL && !defined(OPENSSL_NO_ECDH)
418	>	#if OPENSSL_VERSION_NUMBER >= 0x009080FFL && !defined(OPENSSL_NO_ECDH)
419		{
420		EC_KEY *key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1);
421
422		if (key)
423		{
424	<	SSL_CTX_set_tmp_ecdh(ServerInfo.server_ctx, key);
424	>	SSL_CTX_set_tmp_ecdh(ConfigServerInfo.server_ctx, key);
425		EC_KEY_free(key);
426		}
427		}
428
429	<	SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_SINGLE_ECDH_USE);
429	>	SSL_CTX_set_options(ConfigServerInfo.server_ctx, SSL_OP_SINGLE_ECDH_USE);
430		#endif
431
432	<	if ((ServerInfo.client_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL)
432	>	if (!(ConfigServerInfo.client_ctx = SSL_CTX_new(SSLv23_client_method())))
433		{
434	<	const char *s;
434	>	const char *s = ERR_lib_error_string(ERR_get_error());
435
436	<	fprintf(stderr, "ERROR: Could not initialize the SSL Client context -- %s\n",
437	<	s = ERR_lib_error_string(ERR_get_error()));
438	<	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Client context -- %s\n", s);
436	>	fprintf(stderr, "ERROR: Could not initialize the SSL Client context -- %s\n", s);
437	>	ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Client context -- %s", s);
438	>	exit(EXIT_FAILURE);
439	>	return;  /* Not reached */
440		}
441
442	<	SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
443	<	SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_TLS_ROLLBACK_BUG);
444	<	SSL_CTX_set_verify(ServerInfo.client_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
442	>	SSL_CTX_set_options(ConfigServerInfo.client_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TICKET);
443	>	SSL_CTX_set_options(ConfigServerInfo.client_ctx, SSL_OP_SINGLE_DH_USE);
444	>	SSL_CTX_set_verify(ConfigServerInfo.client_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
445		always_accept_verify_cb);
446	+	SSL_CTX_set_session_cache_mode(ConfigServerInfo.client_ctx, SSL_SESS_CACHE_OFF);
447		#endif /* HAVE_LIBCRYPTO */
448		}
449
#	Line 484 | Line 451 | int
451		main(int argc, char *argv[])
452		{
453		/* Check to see if the user is running us as root, which is a nono */
454	<	if (geteuid() == 0)
454	>	if (!geteuid())
455		{
456		fprintf(stderr, "ERROR: This server won't run as root/superuser\n");
457		return -1;
#	Line 493 | Line 460 | main(int argc, char *argv[])
460		/* Setup corefile size immediately after boot -kre */
461		setup_corefile();
462
463	<	/* save server boot time right away, so getrusage works correctly */
463	>	/* Save server boot time right away, so getrusage works correctly */
464		set_time();
465
466	<	/* It ain't random, but it ought to be a little harder to guess */
466	>	/* It's not random, but it ought to be a little harder to guess */
467		init_genrand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
468
469	<	me.localClient = &meLocalUser;
470	<	dlinkAdd(&me, &me.node, &global_client_list);  /* Pointer to beginning
471	<	of Client list */
472	<	ConfigLoggingEntry.use_logging = 1;
473	<	ConfigFileEntry.dpath      = DPATH;
474	<	ConfigFileEntry.spath      = SPATH;
475	<	ConfigFileEntry.mpath      = MPATH;
476	<	ConfigFileEntry.configfile = CPATH;    /* Server configuration file */
477	<	ConfigFileEntry.klinefile  = KPATH;    /* Server kline file         */
478	<	ConfigFileEntry.glinefile  = GPATH;    /* Server gline file         */
512	<	ConfigFileEntry.xlinefile  = XPATH;    /* Server xline file         */
513	<	ConfigFileEntry.dlinefile  = DLPATH;   /* dline file                */
514	<	ConfigFileEntry.resvfile   = RESVPATH; /* resv file                 */
469	>	dlinkAdd(&me, &me.node, &global_client_list);
470	>
471	>	ConfigGeneral.dpath      = DPATH;
472	>	ConfigGeneral.spath      = SPATH;
473	>	ConfigGeneral.mpath      = MPATH;
474	>	ConfigGeneral.configfile = CPATH;    /* Server configuration file */
475	>	ConfigGeneral.klinefile  = KPATH;    /* Server kline file         */
476	>	ConfigGeneral.xlinefile  = XPATH;    /* Server xline file         */
477	>	ConfigGeneral.dlinefile  = DLPATH;   /* dline file                */
478	>	ConfigGeneral.resvfile   = RESVPATH; /* resv file                 */
479
480		myargv = argv;
481	<	umask(077);                /* better safe than sorry --SRB */
481	>	umask(077);  /* umask 077: u=rwx,g=,o= */
482
483		parseargs(&argc, &argv, myopts);
484
#	Line 524 | Line 488 | main(int argc, char *argv[])
488		exit(EXIT_SUCCESS);
489		}
490
491	<	if (chdir(ConfigFileEntry.dpath))
491	>	if (chdir(ConfigGeneral.dpath))
492		{
493		perror("chdir");
494		exit(EXIT_FAILURE);
#	Line 545 | Line 509 | main(int argc, char *argv[])
509		/* We need this to initialise the fd array before anything else */
510		fdlist_init();
511		log_set_file(LOG_TYPE_IRCD, 0, logFileName);
512	<	check_can_use_v6();
512	>
513		init_netio();         /* This needs to be setup early ! -- adrian */
514
515		/* Check if there is pidfile and daemon already running */
#	Line 553 | Line 517 | main(int argc, char *argv[])
517
518		mp_pool_init();
519		init_dlink_nodes();
520	<	init_isupport();
520	>	isupport_init();
521		dbuf_init();
522		hash_init();
523	<	init_ip_hash_table();      /* client host ip hash table */
560	<	init_host_hash();          /* Host-hashtable. */
523	>	ipcache_init();
524		client_init();
525		class_init();
526		whowas_init();
#	Line 566 | Line 529 | main(int argc, char *argv[])
529		init_resolver();      /* Needs to be setup before the io loop */
530		modules_init();
531		read_conf_files(1);   /* cold start init conf files */
569	–	init_uid();
532		initialize_server_capabs();   /* Set up default_server_capabs */
533	<	initialize_global_set_options();
533	>	initialize_global_set_options();  /* Has to be called after read_conf_files() */
534		channel_init();
535		read_links_file();
536		motd_init();
537	+	user_modes_init();
538		#ifdef HAVE_LIBGEOIP
539		geoip_ctx = GeoIP_new(GEOIP_MEMORY_CACHE);
540		#endif
541
542	<	if (EmptyString(ServerInfo.sid))
580	<	{
581	<	ilog(LOG_TYPE_IRCD, "ERROR: No server id specified in serverinfo block.");
582	<	exit(EXIT_FAILURE);
583	<	}
584	<
585	<	strlcpy(me.id, ServerInfo.sid, sizeof(me.id));
586	<
587	<	if (EmptyString(ServerInfo.name))
542	>	if (EmptyString(ConfigServerInfo.name))
543		{
544		ilog(LOG_TYPE_IRCD, "ERROR: No server name specified in serverinfo block.");
545		exit(EXIT_FAILURE);
546		}
547
548	<	strlcpy(me.name, ServerInfo.name, sizeof(me.name));
548	>	strlcpy(me.name, ConfigServerInfo.name, sizeof(me.name));
549
550		/* serverinfo{} description must exist.  If not, error out.*/
551	<	if (EmptyString(ServerInfo.description))
551	>	if (EmptyString(ConfigServerInfo.description))
552		{
553		ilog(LOG_TYPE_IRCD, "ERROR: No server description specified in serverinfo block.");
554		exit(EXIT_FAILURE);
555		}
556
557	<	strlcpy(me.info, ServerInfo.description, sizeof(me.info));
557	>	strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
558	>
559	>	if (EmptyString(ConfigServerInfo.sid))
560	>	{
561	>	ilog(LOG_TYPE_IRCD, "Generating server ID");
562	>	generate_sid();
563	>	}
564	>	else
565	>	{
566	>	strlcpy(me.id, ConfigServerInfo.sid, sizeof(me.id));
567	>	}
568
569	<	me.from                   = &me;
570	<	me.servptr                = &me;
571	<	me.localClient->lasttime  = CurrentTime;
572	<	me.localClient->since     = CurrentTime;
573	<	me.localClient->firsttime = CurrentTime;
569	>	me.from = &me;
570	>	me.servptr = &me;
571	>	me.connection->lasttime = CurrentTime;
572	>	me.connection->since = CurrentTime;
573	>	me.connection->firsttime = CurrentTime;
574
575		SetMe(&me);
576		make_server(&me);
#	Line 613 | Line 578 | main(int argc, char *argv[])
578		hash_add_id(&me);
579		hash_add_client(&me);
580
581	<	/* add ourselves to global_serv_list */
582	<	dlinkAdd(&me, make_dlink_node(), &global_serv_list);
581	>	dlinkAdd(&me, make_dlink_node(), &global_server_list);
582	>
583	>	init_uid();
584
585		load_kline_database();
586		load_dline_database();
621	–	load_gline_database();
587		load_xline_database();
588		load_resv_database();
589
625	–	if (chdir(MODPATH))
626	–	{
627	–	ilog(LOG_TYPE_IRCD, "Could not load core modules. Terminating!");
628	–	exit(EXIT_FAILURE);
629	–	}
630	–
590		load_all_modules(1);
591		load_conf_modules();
592		load_core_modules(1);
593
635	–	/* Go back to DPATH after checking to see if we can chdir to MODPATH */
636	–	if (chdir(ConfigFileEntry.dpath))
637	–	{
638	–	perror("chdir");
639	–	exit(EXIT_FAILURE);
640	–	}
641	–
642	–	/*
643	–	* assemble_umode_buffer() has to be called after
644	–	* reading conf/loading modules.
645	–	*/
646	–	assemble_umode_buffer();
647	–
594		write_pidfile(pidFileName);
595
596		ilog(LOG_TYPE_IRCD, "Server Ready");
597
652	–	event_addish(&event_cleanup_glines, NULL);
598		event_addish(&event_cleanup_tklines, NULL);
599
600		/* We want try_connections to be called as soon as possible now! -- adrian */
#	Line 657 | Line 602 | main(int argc, char *argv[])
602		event_addish(&event_try_connections, NULL);
603
604		/* Setup the timeout check. I'll shift it later :)  -- adrian */
605	<	event_addish(&event_comm_checktimeouts, NULL);
605	>	event_add(&event_comm_checktimeouts, NULL);
606
607		event_addish(&event_save_all_databases, NULL);
608
#	Line 670 | Line 615 | main(int argc, char *argv[])
615		ConfigServerHide.links_disabled = 1;
616
617		if (splitmode)
618	<	event_addish(&event_check_splitmode, NULL);
618	>	event_addish(&splitmode_event, NULL);
619
620		io_loop();
621		return 0;

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)