ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.1.x/src/ircd.c
Revision: 3056
Committed: Wed Feb 26 18:38:31 2014 UTC (10 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 17286 byte(s)
Log Message:
- Removed FAKEHOST server capability for now

File Contents

# Content
1 /*
2 * ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3 *
4 * Copyright (c) 1997-2014 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
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
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
19 * USA
20 */
21
22 /*! \file ircd.c
23 * \brief Starts up and runs the ircd.
24 * \version $Id$
25 */
26
27 #include "stdinc.h"
28 #include "s_user.h"
29 #include "list.h"
30 #include "ircd.h"
31 #include "channel.h"
32 #include "channel_mode.h"
33 #include "client.h"
34 #include "event.h"
35 #include "fdlist.h"
36 #include "hash.h"
37 #include "irc_string.h"
38 #include "ircd_signal.h"
39 #include "s_gline.h"
40 #include "motd.h"
41 #include "conf.h"
42 #include "hostmask.h"
43 #include "numeric.h"
44 #include "packet.h"
45 #include "parse.h"
46 #include "irc_res.h"
47 #include "restart.h"
48 #include "rng_mt.h"
49 #include "s_auth.h"
50 #include "s_bsd.h"
51 #include "log.h"
52 #include "s_misc.h"
53 #include "s_serv.h" /* try_connections */
54 #include "send.h"
55 #include "whowas.h"
56 #include "modules.h"
57 #include "memory.h"
58 #include "mempool.h"
59 #include "hook.h"
60 #include "ircd_getopt.h"
61 #include "supported.h"
62 #include "watch.h"
63 #include "conf_db.h"
64 #include "conf_class.h"
65
66
67 #ifdef HAVE_LIBGEOIP
68 GeoIP *geoip_ctx;
69 #endif
70
71 /* /quote set variables */
72 struct SetOptions GlobalSetOptions;
73 struct Counter Count;
74 struct ServerState_t server_state;
75 struct ServerStatistics ServerStats;
76 struct timeval SystemTime;
77 struct Client me; /* That's me */
78 struct LocalUser meLocalUser; /* That's also part of me */
79
80 const char *logFileName = LPATH;
81 const char *pidFileName = PPATH;
82
83 char **myargv;
84
85 int dorehash = 0;
86 int doremotd = 0;
87
88 /* Set to zero because it should be initialized later using
89 * initialize_server_capabs
90 */
91 int default_server_capabs = 0;
92 unsigned int splitmode;
93 unsigned int splitchecking;
94 unsigned int split_users;
95 unsigned int split_servers;
96
97 /* Do klines the same way hybrid-6 did them, i.e. at the
98 * top of the next io_loop instead of in the same loop as
99 * the klines are being applied.
100 *
101 * This should fix strange CPU starvation as very indirectly reported.
102 * (Why do you people not email bug reports? WHY? WHY?)
103 *
104 * - Dianora
105 */
106
107 int rehashed_klines = 0;
108
109
110 /*
111 * print_startup - print startup information
112 */
113 static void
114 print_startup(int pid)
115 {
116 printf("ircd: version %s(%s)\n", ircd_version, serno);
117 printf("ircd: pid %d\n", pid);
118 printf("ircd: running in %s mode from %s\n", !server_state.foreground ? "background"
119 : "foreground", ConfigFileEntry.dpath);
120 }
121
122 static void
123 make_daemon(void)
124 {
125 int pid;
126
127 if ((pid = fork()) < 0)
128 {
129 perror("fork");
130 exit(EXIT_FAILURE);
131 }
132 else if (pid > 0)
133 {
134 print_startup(pid);
135 exit(EXIT_SUCCESS);
136 }
137
138 setsid();
139 }
140
141 static int printVersion = 0;
142
143 static struct lgetopt myopts[] = {
144 {"configfile", &ConfigFileEntry.configfile,
145 STRING, "File to use for ircd.conf"},
146 {"glinefile", &ConfigFileEntry.glinefile,
147 STRING, "File to use for gline database"},
148 {"klinefile", &ConfigFileEntry.klinefile,
149 STRING, "File to use for kline database"},
150 {"dlinefile", &ConfigFileEntry.dlinefile,
151 STRING, "File to use for dline database"},
152 {"xlinefile", &ConfigFileEntry.xlinefile,
153 STRING, "File to use for xline database"},
154 {"resvfile", &ConfigFileEntry.resvfile,
155 STRING, "File to use for resv database"},
156 {"logfile", &logFileName,
157 STRING, "File to use for ircd.log"},
158 {"pidfile", &pidFileName,
159 STRING, "File to use for process ID"},
160 {"foreground", &server_state.foreground,
161 YESNO, "Run in foreground (don't detach)"},
162 {"version", &printVersion,
163 YESNO, "Print version and exit"},
164 {"help", NULL, USAGE, "Print this text"},
165 {NULL, NULL, STRING, NULL},
166 };
167
168 void
169 set_time(void)
170 {
171 struct timeval newtime = { .tv_sec = 0, .tv_usec = 0 };
172
173 if (gettimeofday(&newtime, NULL) == -1)
174 {
175 ilog(LOG_TYPE_IRCD, "Clock Failure (%s), TS can be corrupted",
176 strerror(errno));
177 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
178 "Clock Failure (%s), TS can be corrupted",
179 strerror(errno));
180 restart("Clock Failure");
181 }
182
183 if (newtime.tv_sec < CurrentTime)
184 {
185 ilog(LOG_TYPE_IRCD, "System clock is running backwards - (%lu < %lu)",
186 (unsigned long)newtime.tv_sec, (unsigned long)CurrentTime);
187 sendto_realops_flags(UMODE_DEBUG, L_ALL, SEND_NOTICE,
188 "System clock is running backwards - (%lu < %lu)",
189 (unsigned long)newtime.tv_sec,
190 (unsigned long)CurrentTime);
191 set_back_events(CurrentTime - newtime.tv_sec);
192 }
193
194 SystemTime.tv_sec = newtime.tv_sec;
195 SystemTime.tv_usec = newtime.tv_usec;
196 }
197
198 static void
199 io_loop(void)
200 {
201 while (1 == 1)
202 {
203 /*
204 * Maybe we want a flags word?
205 * ie. if (REHASHED_KLINES(global_flags))
206 * SET_REHASHED_KLINES(global_flags)
207 * CLEAR_REHASHED_KLINES(global_flags)
208 *
209 * - Dianora
210 */
211 if (rehashed_klines)
212 {
213 check_conf_klines();
214 rehashed_klines = 0;
215 }
216
217 if (listing_client_list.head)
218 {
219 dlink_node *ptr = NULL, *ptr_next = NULL;
220 DLINK_FOREACH_SAFE(ptr, ptr_next, listing_client_list.head)
221 {
222 struct Client *client_p = ptr->data;
223 assert(client_p->localClient->list_task);
224 safe_list_channels(client_p, client_p->localClient->list_task, 0);
225 }
226 }
227
228 /* Run pending events, then get the number of seconds to the next
229 * event
230 */
231 while (eventNextTime() <= CurrentTime)
232 eventRun();
233
234 comm_select();
235 exit_aborted_clients();
236 free_exited_clients();
237
238 /* Check to see whether we have to rehash the configuration .. */
239 if (dorehash)
240 {
241 rehash(1);
242 dorehash = 0;
243 }
244 if (doremotd)
245 {
246 motd_recache();
247 sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE,
248 "Got signal SIGUSR1, reloading motd files");
249 doremotd = 0;
250 }
251 }
252 }
253
254 /* initalialize_global_set_options()
255 *
256 * inputs - none
257 * output - none
258 * side effects - This sets all global set options needed
259 */
260 static void
261 initialize_global_set_options(void)
262 {
263 memset(&GlobalSetOptions, 0, sizeof(GlobalSetOptions));
264
265 GlobalSetOptions.autoconn = 1;
266 GlobalSetOptions.spam_time = MIN_JOIN_LEAVE_TIME;
267 GlobalSetOptions.spam_num = MAX_JOIN_LEAVE_COUNT;
268
269 if (ConfigFileEntry.default_floodcount)
270 GlobalSetOptions.floodcount = ConfigFileEntry.default_floodcount;
271 else
272 GlobalSetOptions.floodcount = 10;
273
274 /* XXX I have no idea what to try here - Dianora */
275 GlobalSetOptions.joinfloodcount = 16;
276 GlobalSetOptions.joinfloodtime = 8;
277
278 split_servers = ConfigChannel.default_split_server_count;
279 split_users = ConfigChannel.default_split_user_count;
280
281 if (split_users && split_servers && (ConfigChannel.no_create_on_split ||
282 ConfigChannel.no_join_on_split))
283 {
284 splitmode = 1;
285 splitchecking = 1;
286 }
287
288 GlobalSetOptions.ident_timeout = IDENT_TIMEOUT;
289 /* End of global set options */
290 }
291
292 /* initialize_server_capabs()
293 *
294 * inputs - none
295 * output - none
296 */
297 static void
298 initialize_server_capabs(void)
299 {
300 add_capability("QS", CAP_QS, 1);
301 add_capability("EOB", CAP_EOB, 1);
302 add_capability("TS6", CAP_TS6, 0);
303 add_capability("CLUSTER", CAP_CLUSTER, 1);
304 add_capability("SVS", CAP_SVS, 1);
305 #ifdef HALFOPS
306 add_capability("HOPS", CAP_HOPS, 1);
307 #endif
308 }
309
310 /* write_pidfile()
311 *
312 * inputs - filename+path of pid file
313 * output - NONE
314 * side effects - write the pid of the ircd to filename
315 */
316 static void
317 write_pidfile(const char *filename)
318 {
319 FILE *fb;
320
321 if ((fb = fopen(filename, "w")))
322 {
323 char buff[IRCD_BUFSIZE];
324 unsigned int pid = (unsigned int)getpid();
325
326 snprintf(buff, sizeof(buff), "%u\n", pid);
327
328 if ((fputs(buff, fb) == -1))
329 ilog(LOG_TYPE_IRCD, "Error writing %u to pid file %s (%s)",
330 pid, filename, strerror(errno));
331
332 fclose(fb);
333 }
334 else
335 {
336 ilog(LOG_TYPE_IRCD, "Error opening pid file %s", filename);
337 }
338 }
339
340 /* check_pidfile()
341 *
342 * inputs - filename+path of pid file
343 * output - none
344 * side effects - reads pid from pidfile and checks if ircd is in process
345 * list. if it is, gracefully exits
346 * -kre
347 */
348 static void
349 check_pidfile(const char *filename)
350 {
351 FILE *fb;
352 char buff[IRCD_BUFSIZE];
353 pid_t pidfromfile;
354
355 /* Don't do logging here, since we don't have log() initialised */
356 if ((fb = fopen(filename, "r")))
357 {
358 if (fgets(buff, 20, fb) == NULL)
359 {
360 /* log(L_ERROR, "Error reading from pid file %s (%s)", filename,
361 * strerror(errno));
362 */
363 }
364 else
365 {
366 pidfromfile = atoi(buff);
367
368 if (!kill(pidfromfile, 0))
369 {
370 /* log(L_ERROR, "Server is already running"); */
371 printf("ircd: daemon is already running\n");
372 exit(-1);
373 }
374 }
375
376 fclose(fb);
377 }
378 else if (errno != ENOENT)
379 {
380 /* log(L_ERROR, "Error opening pid file %s", filename); */
381 }
382 }
383
384 /* setup_corefile()
385 *
386 * inputs - nothing
387 * output - nothing
388 * side effects - setups corefile to system limits.
389 * -kre
390 */
391 static void
392 setup_corefile(void)
393 {
394 #ifdef HAVE_SYS_RESOURCE_H
395 struct rlimit rlim; /* resource limits */
396
397 /* Set corefilesize to maximum */
398 if (!getrlimit(RLIMIT_CORE, &rlim))
399 {
400 rlim.rlim_cur = rlim.rlim_max;
401 setrlimit(RLIMIT_CORE, &rlim);
402 }
403 #endif
404 }
405
406 #ifdef HAVE_LIBCRYPTO
407 static int
408 always_accept_verify_cb(int preverify_ok, X509_STORE_CTX *x509_ctx)
409 {
410 return 1;
411 }
412 #endif
413
414 /* init_ssl()
415 *
416 * inputs - nothing
417 * output - nothing
418 * side effects - setups SSL context.
419 */
420 static void
421 ssl_init(void)
422 {
423 #ifdef HAVE_LIBCRYPTO
424 const unsigned char session_id[] = "ircd-hybrid";
425
426 SSL_load_error_strings();
427 SSLeay_add_ssl_algorithms();
428
429 if ((ServerInfo.server_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL)
430 {
431 const char *s;
432
433 fprintf(stderr, "ERROR: Could not initialize the SSL Server context -- %s\n",
434 s = ERR_lib_error_string(ERR_get_error()));
435 ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Server context -- %s\n", s);
436 }
437
438 SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
439 SSL_CTX_set_options(ServerInfo.server_ctx, SSL_OP_TLS_ROLLBACK_BUG|SSL_OP_ALL);
440 SSL_CTX_set_verify(ServerInfo.server_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
441 always_accept_verify_cb);
442 SSL_CTX_set_session_id_context(ServerInfo.server_ctx, session_id, sizeof(session_id) - 1);
443
444 if ((ServerInfo.client_ctx = SSL_CTX_new(SSLv23_client_method())) == NULL)
445 {
446 const char *s;
447
448 fprintf(stderr, "ERROR: Could not initialize the SSL Client context -- %s\n",
449 s = ERR_lib_error_string(ERR_get_error()));
450 ilog(LOG_TYPE_IRCD, "ERROR: Could not initialize the SSL Client context -- %s\n", s);
451 }
452
453 SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_NO_SSLv2|SSL_OP_NO_SSLv3|SSL_OP_NO_TLSv1);
454 SSL_CTX_set_options(ServerInfo.client_ctx, SSL_OP_TLS_ROLLBACK_BUG|SSL_OP_ALL);
455 SSL_CTX_set_verify(ServerInfo.client_ctx, SSL_VERIFY_PEER|SSL_VERIFY_CLIENT_ONCE,
456 always_accept_verify_cb);
457 #endif /* HAVE_LIBCRYPTO */
458 }
459
460 int
461 main(int argc, char *argv[])
462 {
463 /* Check to see if the user is running us as root, which is a nono */
464 if (geteuid() == 0)
465 {
466 fprintf(stderr, "Don't run ircd as root!!!\n");
467 return -1;
468 }
469
470 /* Setup corefile size immediately after boot -kre */
471 setup_corefile();
472
473 /* save server boot time right away, so getrusage works correctly */
474 set_time();
475
476 /* It ain't random, but it ought to be a little harder to guess */
477 init_genrand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
478
479 me.localClient = &meLocalUser;
480 dlinkAdd(&me, &me.node, &global_client_list); /* Pointer to beginning
481 of Client list */
482 /* Initialise the channel capability usage counts... */
483 init_chcap_usage_counts();
484
485 ConfigFileEntry.dpath = DPATH;
486 ConfigFileEntry.configfile = CPATH; /* Server configuration file */
487 ConfigFileEntry.klinefile = KPATH; /* Server kline file */
488 ConfigFileEntry.glinefile = GPATH; /* Server gline file */
489 ConfigFileEntry.xlinefile = XPATH; /* Server xline file */
490 ConfigFileEntry.dlinefile = DLPATH; /* dline file */
491 ConfigFileEntry.resvfile = RESVPATH; /* resv file */
492
493 myargv = argv;
494 umask(077); /* better safe than sorry --SRB */
495
496 parseargs(&argc, &argv, myopts);
497
498 if (printVersion)
499 {
500 printf("ircd: version %s(%s)\n", ircd_version, serno);
501 exit(EXIT_SUCCESS);
502 }
503
504 if (chdir(ConfigFileEntry.dpath))
505 {
506 perror("chdir");
507 exit(EXIT_FAILURE);
508 }
509
510 ssl_init();
511
512 if (!server_state.foreground)
513 {
514 make_daemon();
515 close_standard_fds(); /* this needs to be before init_netio()! */
516 }
517 else
518 print_startup(getpid());
519
520 setup_signals();
521
522 /* Init the event subsystem */
523 eventInit();
524
525 /* We need this to initialise the fd array before anything else */
526 fdlist_init();
527 log_set_file(LOG_TYPE_IRCD, 0, logFileName);
528 check_can_use_v6();
529 init_netio(); /* This needs to be setup early ! -- adrian */
530
531 /* Check if there is pidfile and daemon already running */
532 check_pidfile(pidFileName);
533
534 mp_pool_init();
535 init_dlink_nodes();
536 init_isupport();
537 dbuf_init();
538 hash_init();
539 init_ip_hash_table(); /* client host ip hash table */
540 init_host_hash(); /* Host-hashtable. */
541 client_init();
542 class_init();
543 whowas_init();
544 watch_init();
545 auth_init(); /* Initialise the auth code */
546 init_resolver(); /* Needs to be setup before the io loop */
547 modules_init();
548 read_conf_files(1); /* cold start init conf files */
549 init_uid();
550 initialize_server_capabs(); /* Set up default_server_capabs */
551 initialize_global_set_options();
552 channel_init();
553 read_links_file();
554 motd_init();
555 #ifdef HAVE_LIBGEOIP
556 geoip_ctx = GeoIP_new(GEOIP_MEMORY_CACHE);
557 #endif
558
559 if (EmptyString(ServerInfo.sid))
560 {
561 ilog(LOG_TYPE_IRCD, "ERROR: No server id specified in serverinfo block.");
562 exit(EXIT_FAILURE);
563 }
564
565 strlcpy(me.id, ServerInfo.sid, sizeof(me.id));
566
567 if (EmptyString(ServerInfo.name))
568 {
569 ilog(LOG_TYPE_IRCD, "ERROR: No server name specified in serverinfo block.");
570 exit(EXIT_FAILURE);
571 }
572
573 strlcpy(me.name, ServerInfo.name, sizeof(me.name));
574
575 /* serverinfo{} description must exist. If not, error out.*/
576 if (EmptyString(ServerInfo.description))
577 {
578 ilog(LOG_TYPE_IRCD, "ERROR: No server description specified in serverinfo block.");
579 exit(EXIT_FAILURE);
580 }
581
582 strlcpy(me.info, ServerInfo.description, sizeof(me.info));
583
584 me.from = &me;
585 me.servptr = &me;
586 me.localClient->lasttime = CurrentTime;
587 me.localClient->since = CurrentTime;
588 me.localClient->firsttime = CurrentTime;
589
590 SetMe(&me);
591 make_server(&me);
592
593 hash_add_id(&me);
594 hash_add_client(&me);
595
596 /* add ourselves to global_serv_list */
597 dlinkAdd(&me, make_dlink_node(), &global_serv_list);
598
599 load_kline_database();
600 load_dline_database();
601 load_gline_database();
602 load_xline_database();
603 load_resv_database();
604
605 if (chdir(MODPATH))
606 {
607 ilog(LOG_TYPE_IRCD, "Could not load core modules. Terminating!");
608 exit(EXIT_FAILURE);
609 }
610
611 load_all_modules(1);
612 load_conf_modules();
613 load_core_modules(1);
614
615 /* Go back to DPATH after checking to see if we can chdir to MODPATH */
616 if (chdir(ConfigFileEntry.dpath))
617 {
618 perror("chdir");
619 exit(EXIT_FAILURE);
620 }
621
622 /*
623 * assemble_umode_buffer() has to be called after
624 * reading conf/loading modules.
625 */
626 assemble_umode_buffer();
627
628 write_pidfile(pidFileName);
629
630 ilog(LOG_TYPE_IRCD, "Server Ready");
631
632 eventAddIsh("cleanup_glines", cleanup_glines, NULL, CLEANUP_GLINES_TIME);
633 eventAddIsh("cleanup_tklines", cleanup_tklines, NULL, CLEANUP_TKLINES_TIME);
634
635 /* We want try_connections to be called as soon as possible now! -- adrian */
636 /* No, 'cause after a restart it would cause all sorts of nick collides */
637 eventAddIsh("try_connections", try_connections, NULL, STARTUP_CONNECTIONS_TIME);
638
639 /* Setup the timeout check. I'll shift it later :) -- adrian */
640 eventAddIsh("comm_checktimeouts", comm_checktimeouts, NULL, 1);
641
642 eventAddIsh("save_all_databases", save_all_databases, NULL, DATABASE_UPDATE_TIMEOUT);
643
644 if (ConfigServerHide.links_delay > 0)
645 eventAddIsh("write_links_file", write_links_file, NULL, ConfigServerHide.links_delay);
646 else
647 ConfigServerHide.links_disabled = 1;
648
649 if (splitmode)
650 eventAddIsh("check_splitmode", check_splitmode, NULL, 60);
651
652 io_loop();
653 return 0;
654 }

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision