2 * charybdis: A slightly useful ircd.
3 * ircd.c: Starts up and runs the ircd.
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2002-2008 ircd-ratbox development team
8 * Copyright (C) 2005-2013 charybdis development team
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
36 #include "ircd_signal.h"
37 #include "msg.h" /* msgtab */
44 #include "s_serv.h" /* try_connections */
49 #include "supported.h"
53 #include "ircd_getopt.h"
56 #include "s_newconf.h"
59 #include "patchlevel.h"
64 #include "privilege.h"
70 ircd_die_cb(const char *str
) __attribute__((noreturn
));
72 /* /quote set variables */
73 struct SetOptions GlobalSetOptions
;
75 /* configuration set from ircd.conf */
76 struct config_file_entry ConfigFileEntry
;
77 /* server info set from ircd.conf */
78 struct server_info ServerInfo
;
79 /* admin info set from ircd.conf */
80 struct admin_info AdminInfo
;
83 struct ServerStatistics ServerStats
;
86 struct Client me
; /* That's me */
87 struct LocalUser meLocalUser
; /* That's also part of me */
89 rb_dlink_list global_client_list
;
91 /* unknown/client pointer lists */
92 rb_dlink_list unknown_list
; /* unknown clients ON this server only */
93 rb_dlink_list lclient_list
; /* local clients only ON this server */
94 rb_dlink_list serv_list
; /* local servers to this server ONLY */
95 rb_dlink_list global_serv_list
; /* global servers on the network */
96 rb_dlink_list local_oper_list
; /* our opers, duplicated in lclient_list */
97 rb_dlink_list oper_list
; /* network opers */
100 volatile sig_atomic_t dorehash
= false;
101 volatile sig_atomic_t dorehashbans
= false;
102 volatile sig_atomic_t doremotd
= false;
103 bool kline_queued
= false;
104 bool server_state_foreground
= false;
105 bool opers_see_all_users
= false;
106 bool ircd_ssl_ok
= false;
107 bool ircd_zlib_ok
= true;
109 int testing_conf
= 0;
112 int default_server_capabs
;
120 const char *ircd_paths
[IRCD_PATH_COUNT
] = {
121 [IRCD_PATH_PREFIX
] = DPATH
,
122 [IRCD_PATH_MODULES
] = MODPATH
,
123 [IRCD_PATH_AUTOLOAD_MODULES
] = AUTOMODPATH
,
124 [IRCD_PATH_ETC
] = ETCPATH
,
125 [IRCD_PATH_LOG
] = LOGPATH
,
126 [IRCD_PATH_USERHELP
] = UHPATH
,
127 [IRCD_PATH_OPERHELP
] = HPATH
,
128 [IRCD_PATH_IRCD_EXEC
] = SPATH
,
129 [IRCD_PATH_IRCD_CONF
] = CPATH
,
130 [IRCD_PATH_IRCD_MOTD
] = MPATH
,
131 [IRCD_PATH_IRCD_LOG
] = LPATH
,
132 [IRCD_PATH_IRCD_PID
] = PPATH
,
133 [IRCD_PATH_IRCD_OMOTD
] = OPATH
,
134 [IRCD_PATH_BANDB
] = DBPATH
,
135 [IRCD_PATH_BIN
] = BINPATH
,
136 [IRCD_PATH_LIBEXEC
] = PKGLIBEXECDIR
,
139 const char *ircd_pathnames
[IRCD_PATH_COUNT
] = {
140 [IRCD_PATH_PREFIX
] = "prefix",
141 [IRCD_PATH_MODULES
] = "modules",
142 [IRCD_PATH_AUTOLOAD_MODULES
] = "autoload modules",
143 [IRCD_PATH_ETC
] = "config",
144 [IRCD_PATH_LOG
] = "log",
145 [IRCD_PATH_USERHELP
] = "user help",
146 [IRCD_PATH_OPERHELP
] = "oper help",
147 [IRCD_PATH_IRCD_EXEC
] = "ircd binary",
148 [IRCD_PATH_IRCD_CONF
] = "ircd.conf",
149 [IRCD_PATH_IRCD_MOTD
] = "ircd.motd",
150 [IRCD_PATH_IRCD_LOG
] = "ircd.log",
151 [IRCD_PATH_IRCD_PID
] = "ircd.pid",
152 [IRCD_PATH_IRCD_OMOTD
] = "oper motd",
153 [IRCD_PATH_BANDB
] = "bandb",
154 [IRCD_PATH_BIN
] = "binary dir",
155 [IRCD_PATH_LIBEXEC
] = "libexec dir",
158 const char *logFileName
= NULL
;
159 const char *pidFileName
= NULL
;
162 ircd_shutdown(const char *reason
)
164 struct Client
*target_p
;
167 RB_DLINK_FOREACH(ptr
, lclient_list
.head
)
169 target_p
= ptr
->data
;
171 sendto_one(target_p
, ":%s NOTICE %s :Server Terminating. %s",
172 me
.name
, target_p
->name
, reason
);
175 RB_DLINK_FOREACH(ptr
, serv_list
.head
)
177 target_p
= ptr
->data
;
179 sendto_one(target_p
, ":%s ERROR :Terminated by %s",
183 ilog(L_MAIN
, "Server Terminating. %s", reason
);
193 * inputs - boot_daemon flag
195 * side effects - if boot_daemon flag is not set, don't daemonize
200 #if !defined(_WIN32) && defined(RLIMIT_NOFILE) && defined(HAVE_SYS_RESOURCE_H)
203 if(!getrlimit(RLIMIT_NOFILE
, &limit
))
205 maxconnections
= limit
.rlim_cur
;
206 if(maxconnections
<= MAX_BUFFER
)
208 fprintf(stderr
, "ERROR: Shell FD limits are too low.\n");
209 fprintf(stderr
, "ERROR: charybdis reserves %d FDs, shell limits must be above this\n", MAX_BUFFER
);
214 #endif /* RLIMIT_FD_MAX */
215 maxconnections
= MAXCONNECTIONS
;
222 int pid
, nullfd
, fdx
;
224 /* The below is approximately what daemon(1, 0) does, but
225 we need control over the parent after forking to print
226 the startup message -- Aaron */
228 if((nullfd
= open("/dev/null", O_RDWR
)) < 0)
230 perror("open /dev/null");
234 if((pid
= fork()) < 0)
241 inotice("now running in background mode from %s as pid %d ...",
242 ConfigFileEntry
.dpath
, pid
);
247 for(fdx
= 0; fdx
<= 2; fdx
++)
249 (void) dup2(nullfd
, fdx
);
252 (void) close(nullfd
);
260 static int printVersion
= 0;
262 struct lgetopt myopts
[] = {
263 {"configfile", &ConfigFileEntry
.configfile
,
264 STRING
, "File to use for ircd.conf"},
265 {"logfile", &logFileName
,
266 STRING
, "File to use for ircd.log"},
267 {"pidfile", &pidFileName
,
268 STRING
, "File to use for process ID"},
269 {"foreground", &server_state_foreground
,
270 YESNO
, "Run in foreground (don't detach)"},
271 {"version", &printVersion
,
272 YESNO
, "Print version and exit"},
273 {"conftest", &testing_conf
,
274 YESNO
, "Test the configuration files and exit"},
275 {"help", NULL
, USAGE
, "Print this text"},
276 {NULL
, NULL
, STRING
, NULL
},
280 check_rehash(void *unused
)
283 * Check to see whether we have to rehash the configuration ..
294 dorehashbans
= false;
299 sendto_realops_snomask(SNO_GENERAL
, L_ALL
,
300 "Got signal SIGUSR1, reloading ircd motd file");
307 * initalialize_global_set_options
311 * side effects - This sets all global set options needed
314 initialize_global_set_options(void)
316 memset(&GlobalSetOptions
, 0, sizeof(GlobalSetOptions
));
317 /* memset( &ConfigFileEntry, 0, sizeof(ConfigFileEntry)); */
319 GlobalSetOptions
.maxclients
= ServerInfo
.default_max_clients
;
321 if(GlobalSetOptions
.maxclients
> (maxconnections
- MAX_BUFFER
) || (GlobalSetOptions
.maxclients
<= 0))
322 GlobalSetOptions
.maxclients
= maxconnections
- MAX_BUFFER
;
324 GlobalSetOptions
.autoconn
= 1;
326 GlobalSetOptions
.spam_time
= MIN_JOIN_LEAVE_TIME
;
327 GlobalSetOptions
.spam_num
= MAX_JOIN_LEAVE_COUNT
;
329 GlobalSetOptions
.floodcount
= ConfigFileEntry
.default_floodcount
;
331 split_servers
= ConfigChannel
.default_split_server_count
;
332 split_users
= ConfigChannel
.default_split_user_count
;
334 if(split_users
&& split_servers
335 && (ConfigChannel
.no_create_on_split
|| ConfigChannel
.no_join_on_split
))
341 GlobalSetOptions
.ident_timeout
= ConfigFileEntry
.default_ident_timeout
;
343 rb_strlcpy(GlobalSetOptions
.operstring
,
344 ConfigFileEntry
.default_operstring
,
345 sizeof(GlobalSetOptions
.operstring
));
346 rb_strlcpy(GlobalSetOptions
.adminstring
,
347 ConfigFileEntry
.default_adminstring
,
348 sizeof(GlobalSetOptions
.adminstring
));
350 /* memset( &ConfigChannel, 0, sizeof(ConfigChannel)); */
352 /* End of global set options */
357 * initialize_server_capabs
363 initialize_server_capabs(void)
365 default_server_capabs
&= ~CAP_ZIP
;
374 * side effects - items in ircd_paths[] array are relocated
379 char prefix
[PATH_MAX
], workbuf
[PATH_MAX
];
382 rb_strlcpy(prefix
, rb_path_to_self(), sizeof prefix
);
384 ircd_paths
[IRCD_PATH_IRCD_EXEC
] = rb_strdup(prefix
);
386 /* if we're running from inside the source tree, we probably do not want to relocate any other paths */
387 if (strstr(prefix
, ".libs") != NULL
)
390 /* prefix = /home/kaniini/ircd/bin/ircd */
391 p
= strrchr(prefix
, RB_PATH_SEPARATOR
);
392 if (rb_unlikely(p
== NULL
))
396 /* prefix = /home/kaniini/ircd/bin */
397 p
= strrchr(prefix
, RB_PATH_SEPARATOR
);
398 if (rb_unlikely(p
== NULL
))
402 /* prefix = /home/kaniini/ircd */
403 ircd_paths
[IRCD_PATH_PREFIX
] = rb_strdup(prefix
);
405 /* now that we have our prefix, we can relocate the other paths... */
406 snprintf(workbuf
, sizeof workbuf
, "%s%cmodules", prefix
, RB_PATH_SEPARATOR
);
407 ircd_paths
[IRCD_PATH_MODULES
] = rb_strdup(workbuf
);
409 snprintf(workbuf
, sizeof workbuf
, "%s%cmodules%cautoload", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
410 ircd_paths
[IRCD_PATH_AUTOLOAD_MODULES
] = rb_strdup(workbuf
);
412 snprintf(workbuf
, sizeof workbuf
, "%s%cetc", prefix
, RB_PATH_SEPARATOR
);
413 ircd_paths
[IRCD_PATH_ETC
] = rb_strdup(workbuf
);
415 snprintf(workbuf
, sizeof workbuf
, "%s%clog", prefix
, RB_PATH_SEPARATOR
);
416 ircd_paths
[IRCD_PATH_LOG
] = rb_strdup(workbuf
);
418 snprintf(workbuf
, sizeof workbuf
, "%s%chelp%cusers", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
419 ircd_paths
[IRCD_PATH_USERHELP
] = rb_strdup(workbuf
);
421 snprintf(workbuf
, sizeof workbuf
, "%s%chelp%copers", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
422 ircd_paths
[IRCD_PATH_OPERHELP
] = rb_strdup(workbuf
);
424 snprintf(workbuf
, sizeof workbuf
, "%s%cetc%circd.conf", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
425 ircd_paths
[IRCD_PATH_IRCD_CONF
] = rb_strdup(workbuf
);
427 snprintf(workbuf
, sizeof workbuf
, "%s%cetc%circd.motd", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
428 ircd_paths
[IRCD_PATH_IRCD_MOTD
] = rb_strdup(workbuf
);
430 snprintf(workbuf
, sizeof workbuf
, "%s%cetc%copers.motd", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
431 ircd_paths
[IRCD_PATH_IRCD_OMOTD
] = rb_strdup(workbuf
);
433 snprintf(workbuf
, sizeof workbuf
, "%s%cetc%cban.db", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
434 ircd_paths
[IRCD_PATH_BANDB
] = rb_strdup(workbuf
);
436 snprintf(workbuf
, sizeof workbuf
, "%s%cetc%circd.pid", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
437 ircd_paths
[IRCD_PATH_IRCD_PID
] = rb_strdup(workbuf
);
439 snprintf(workbuf
, sizeof workbuf
, "%s%clogs%circd.log", prefix
, RB_PATH_SEPARATOR
, RB_PATH_SEPARATOR
);
440 ircd_paths
[IRCD_PATH_IRCD_LOG
] = rb_strdup(workbuf
);
442 snprintf(workbuf
, sizeof workbuf
, "%s%cbin", prefix
, RB_PATH_SEPARATOR
);
443 ircd_paths
[IRCD_PATH_BIN
] = rb_strdup(workbuf
);
444 ircd_paths
[IRCD_PATH_LIBEXEC
] = rb_strdup(workbuf
);
446 inotice("runtime paths:");
447 for (int i
= 0; i
< IRCD_PATH_COUNT
; i
++)
449 inotice(" %s: %s", ircd_pathnames
[i
], ircd_paths
[i
]);
457 * inputs - filename+path of pid file
459 * side effects - write the pid of the ircd to filename
462 write_pidfile(const char *filename
)
466 if((fb
= fopen(filename
, "w")))
468 unsigned int pid
= (unsigned int) getpid();
470 snprintf(buff
, sizeof(buff
), "%u\n", pid
);
471 if((fputs(buff
, fb
) == -1))
473 ilog(L_MAIN
, "Error writing %u to pid file %s (%s)",
474 pid
, filename
, strerror(errno
));
481 ilog(L_MAIN
, "Error opening pid file %s", filename
);
488 * inputs - filename+path of pid file
490 * side effects - reads pid from pidfile and checks if ircd is in process
491 * list. if it is, gracefully exits
495 check_pidfile(const char *filename
)
501 /* Don't do logging here, since we don't have log() initialised */
502 if((fb
= fopen(filename
, "r")))
504 if(fgets(buff
, 20, fb
) != NULL
)
506 pidfromfile
= atoi(buff
);
507 if(!rb_kill(pidfromfile
, 0))
509 printf("ircd: daemon is already running\n");
522 * side effects - setups corefile to system limits.
528 #ifdef HAVE_SYS_RESOURCE_H
529 struct rlimit rlim
; /* resource limits */
531 /* Set corefilesize to maximum */
532 if(!getrlimit(RLIMIT_CORE
, &rlim
))
534 rlim
.rlim_cur
= rlim
.rlim_max
;
535 setrlimit(RLIMIT_CORE
, &rlim
);
541 ircd_log_cb(const char *str
)
543 ilog(L_MAIN
, "librb reports: %s", str
);
547 ircd_restart_cb(const char *str
)
549 inotice("librb has called the restart callback: %s", str
);
554 * Why EXIT_FAILURE here?
555 * Because if ircd_die_cb() is called it's because of a fatal
556 * error inside libcharybdis, and we don't know how to handle the
557 * exception, so it is logical to return a FAILURE exit code here.
561 ircd_die_cb(const char *str
)
565 /* Try to get the message out to currently logged in operators. */
566 sendto_realops_snomask(SNO_GENERAL
, L_NETWIDE
, "librb has called the die callback..aborting: %s", str
);
567 inotice("librb has called the die callback..aborting: %s", str
);
570 inotice("librb has called the die callback..aborting");
576 struct ev_entry
*check_splitmode_ev
= NULL
;
579 seed_with_urandom(void)
584 fd
= open("/dev/urandom", O_RDONLY
);
587 if(read(fd
, &seed
, sizeof(seed
)) == sizeof(seed
))
599 seed_with_clock(void)
601 const struct timeval
*tv
;
603 tv
= rb_current_time_tv();
604 srand(tv
->tv_sec
^ (tv
->tv_usec
| (getpid() << 20)));
608 seed_random(void *unused
)
611 if(rb_get_random(&seed
, sizeof(seed
)) == -1)
613 if(!seed_with_urandom())
623 * Initializes the IRCd.
625 * Inputs - number of commandline args, args themselves
627 * Side Effects - this is where the ircd gets going right now
630 charybdis_main(int argc
, char * const argv
[])
635 /* Check to see if the user is running us as root, which is a nono */
638 fprintf(stderr
, "Don't run ircd as root!!!\n");
647 logFileName
= ircd_paths
[IRCD_PATH_IRCD_LOG
];
648 pidFileName
= ircd_paths
[IRCD_PATH_IRCD_PID
];
650 ConfigFileEntry
.dpath
= ircd_paths
[IRCD_PATH_PREFIX
];
651 ConfigFileEntry
.configfile
= ircd_paths
[IRCD_PATH_IRCD_CONF
]; /* Server configuration file */
652 ConfigFileEntry
.connect_timeout
= 30; /* Default to 30 */
656 umask(077); /* better safe than sorry --SRB */
659 parseargs(&argc
, &argv
, myopts
);
661 if(chdir(ConfigFileEntry
.dpath
))
663 fprintf(stderr
, "Unable to chdir to %s: %s\n", ConfigFileEntry
.dpath
, strerror(errno
));
670 * Setup corefile size immediately after boot -kre
674 /* initialise operhash fairly early. */
677 memset(&me
, 0, sizeof(me
));
678 memset(&meLocalUser
, 0, sizeof(meLocalUser
));
679 me
.localClient
= &meLocalUser
;
681 /* Make sure all lists are zeroed */
682 memset(&unknown_list
, 0, sizeof(unknown_list
));
683 memset(&lclient_list
, 0, sizeof(lclient_list
));
684 memset(&serv_list
, 0, sizeof(serv_list
));
685 memset(&global_serv_list
, 0, sizeof(global_serv_list
));
686 memset(&local_oper_list
, 0, sizeof(local_oper_list
));
687 memset(&oper_list
, 0, sizeof(oper_list
));
689 rb_dlinkAddTail(&me
, &me
.node
, &global_client_list
);
691 memset(&Count
, 0, sizeof(Count
));
692 memset(&ServerInfo
, 0, sizeof(ServerInfo
));
693 memset(&AdminInfo
, 0, sizeof(AdminInfo
));
694 memset(&ServerStats
, 0, sizeof(struct ServerStatistics
));
698 printf("ircd: version %s(%s)\n", ircd_version
, serno
);
699 #ifdef CUSTOM_BRANDING
700 printf("ircd: based on %s-%s\n", PACKAGE_NAME
, PACKAGE_VERSION
);
702 printf("ircd: %s\n", rb_lib_version());
709 server_state_foreground
= true;
712 /* Make sure fd 0, 1 and 2 are in use -- jilles */
715 fd
= open("/dev/null", O_RDWR
);
716 } while (fd
< 2 && fd
!= -1);
723 /* Check if there is pidfile and daemon already running */
726 check_pidfile(pidFileName
);
728 inotice("starting %s ...", ircd_version
);
729 inotice("%s", rb_lib_version());
732 if(!server_state_foreground
)
737 /* Init the event subsystem */
738 rb_lib_init(ircd_log_cb
, ircd_restart_cb
, ircd_die_cb
, !server_state_foreground
, maxconnections
, DNODE_HEAP_SIZE
, FD_HEAP_SIZE
);
739 rb_linebuf_init(LINEBUF_HEAP_SIZE
);
741 rb_init_prng(NULL
, RB_PRNG_DEFAULT
);
745 init_builtin_capabs();
746 default_server_capabs
= CAP_MASK
;
753 clear_scache_hash_table(); /* server cache name table */
765 construct_cflags_strings();
767 init_authd(); /* Start up authd. */
768 init_dns(); /* Start up DNS query system */
769 init_modules(); /* Start up modules system */
771 privilegeset_set_new("default", "", 0);
774 fprintf(stderr
, "\nBeginning config test\n");
775 read_conf_files(true); /* cold start init conf files */
778 load_core_modules(1);
788 initialize_server_capabs(); /* Set up default_server_capabs */
789 initialize_global_set_options();
791 if(ServerInfo
.name
== NULL
)
793 ierror("no server name specified in serverinfo block.");
796 rb_strlcpy(me
.name
, ServerInfo
.name
, sizeof(me
.name
));
798 if(ServerInfo
.sid
[0] == '\0')
800 ierror("no server sid specified in serverinfo block.");
803 rb_strlcpy(me
.id
, ServerInfo
.sid
, sizeof(me
.id
));
806 /* serverinfo{} description must exist. If not, error out. */
807 if(ServerInfo
.description
== NULL
)
809 ierror("no server description specified in serverinfo block.");
812 rb_strlcpy(me
.info
, ServerInfo
.description
, sizeof(me
.info
));
814 if(ServerInfo
.ssl_cert
!= NULL
)
816 /* just do the rb_setup_ssl_server to validate the config */
817 if(!rb_setup_ssl_server(ServerInfo
.ssl_cert
, ServerInfo
.ssl_private_key
, ServerInfo
.ssl_dh_params
, ServerInfo
.ssl_cipher_list
))
819 ilog(L_MAIN
, "WARNING: Unable to setup SSL.");
830 startup_time
= rb_current_time();
831 add_to_client_hash(me
.name
, &me
);
832 add_to_id_hash(me
.id
, &me
);
833 me
.serv
->nameinfo
= scache_connect(me
.name
, me
.info
, 0);
835 rb_dlinkAddAlloc(&me
, &global_serv_list
);
837 construct_umodebuf();
841 fprintf(stderr
, "\nConfig testing complete.\n");
843 return 0; /* Why? We want the launcher to exit out. */
847 write_pidfile(pidFileName
);
853 ilog(L_MAIN
, "Server Ready");
855 /* We want try_connections to be called as soon as possible now! -- adrian */
856 /* No, 'cause after a restart it would cause all sorts of nick collides */
857 /* um. by waiting even longer, that just means we have even *more*
858 * nick collisions. what a stupid idea. set an event for the IO loop --fl
860 rb_event_addish("try_connections", try_connections
, NULL
, STARTUP_CONNECTIONS_TIME
);
861 rb_event_addonce("try_connections_startup", try_connections
, NULL
, 2);
862 rb_event_add("check_rehash", check_rehash
, NULL
, 3);
863 rb_event_addish("reseed_srand", seed_random
, NULL
, 300); /* reseed every 10 minutes */
866 check_splitmode_ev
= rb_event_add("check_splitmode", check_splitmode
, NULL
, 5);
868 if(server_state_foreground
)
869 inotice("now running in foreground mode from %s as pid %d ...",
870 ConfigFileEntry
.dpath
, getpid());