int main (int argc, char **argv) {
int i;
int cnt = 0;
int localport;
loop = uv_default_loop ();
for (i = 1; i < argc; i ++) {
switch (argv [i] [0]) {
case 'a':
remaddr = argv [i] + 1;
break;
case 'p':
remport = atoi (argv [i] + 1);
if (!remport) remport = 9000;
break;
case 'l':
localport = atoi (argv [i] + 1);
if (!localport) localport = 2222;
make_server (localport, cnt ++);
break;
case 'd':
debug = atoi (argv [i] + 1);
break;
default:
fprintf (stderr, "Bad arg %s\n", argv [i]);
break;
}
}
fprintf (stderr, "%d:%s:%d\n", localport, remaddr, remport);
return uv_run (loop, UV_RUN_DEFAULT);
}
void dssim_t::configure(Net* _net, const dssim_t::Config& _config) {
net = _net;
config = _config;
rand_gen.seed(config.rand_seed);
rand_percent = std::make_unique<std::uniform_int_distribution<int>>(0, 100);
// Initially, servers do know about each other. This corresponds to
// a service starting by booting some machines who then contact
// each other for a view change
MASSERT(config.nservers > 0, "impossible");
std::unordered_set<node_id_t> serv_ids;
for(int i = 0; i < config.nservers; ++i) {
serv_ids.insert(net->get_new_nid());
}
for(auto& nid : serv_ids) {
make_server(nid);
}
// Gosh, isn't there a simpler way?
std::vector<std::string> prefix;
if(config.nclients <= 26) {
prefix.resize(26);
int i = 0;
for(char c = 'a'; c <= 'z'; ++c) {
prefix[i++] = std::string(1, c);
}
} else if(config.nclients <= 26*26) {
prefix.resize(26*26);
int i = 0;
for(char b = 'a'; b <= 'z'; ++b) {
for(char c = 'a'; c <= 'z'; ++c) {
prefix[i++] = std::string(1, b) + c;
}
}
} else if(config.nclients <= 26*26*26) {
prefix.resize(26*26*26);
int i = 0;
for(char a = 'a'; a <= 'z'; ++a) {
for(char b = 'a'; b <= 'z'; ++b) {
for(char c = 'a'; c <= 'z'; ++c) {
prefix[i++] = std::string(1, a) + b + c;
}
}
}
} else {
std::fprintf(stderr, "Too many clients %d (max is %d)\n",
config.nclients, 26*26*26);
exit(79);
}
for(int i = 0; i < config.nclients; ++i) {
node_id_t nid = net->get_new_nid();
make_client(nid, prefix[i]);
}
}
void
connect_server()
{
struct Client *client = make_client(NULL);
struct Server *server = make_server(client);
struct Module *protomod;
char modes[MODEBUFLEN+1] = "";
int i, j = 0;
protomod = find_module(Connect.protocol, NO);
if(protomod == NULL)
{
ilog(L_CRIT, "Unable to connect to uplink, protocol module %s not found.",
Connect.protocol);
services_die("Connect error", NO);
}
ServerModeList = (struct ModeList *)modsym(protomod->handle, "ModeList");
for(i = 0; ServerModeList[i].letter != '\0'; i++)
{
modes[j++] = ServerModeList[i].letter;
if(j > MODEBUFLEN)
break;
}
modes[j] = '\0';
ilog(L_DEBUG, "Loaded server mode list %p %s %d", ServerModeList, modes, j);
strlcpy(server->pass, Connect.password, sizeof(server->pass));
strlcpy(client->name, Connect.name, sizeof(client->name));
strlcpy(client->host, Connect.host, sizeof(client->host));
SetConnecting(client);
client->from = client;
dlinkAdd(client, &client->node, &global_client_list);
if(comm_open(&server->fd, AF_INET, SOCK_STREAM, 0, NULL) < 0)
{
ilog(L_CRIT, "connect_server: Could not open socket");
exit(1);
}
comm_connect_tcp(&server->fd, Connect.host, Connect.port,
NULL, 0, serv_connect_callback, client, AF_INET, CONNECTTIMEOUT);
eventAdd("Server connection check", try_reconnect, NULL, 60);
}
u_entity *u_entity_from_name(u_entity *e, char *s)
{
if (!s) return NULL;
if (strchr(s, '.')) {
if (!(e->v.sv = u_server_by_name(s)))
return NULL;
make_server(e);
} else {
if (!(e->v.u = u_user_by_nick(s)))
return NULL;
make_user(e);
}
return e;
}
u_entity *u_entity_from_id(u_entity *e, char *s)
{
if (!s) return NULL;
if (s[3]) {
if (!(e->v.u = u_user_by_uid(s)))
return NULL;
make_user(e);
} else {
if (!(e->v.sv = u_server_by_sid(s)))
return NULL;
make_server(e);
}
return e;
}
static void
getaddresses(dig_lookup_t *lookup, const char *host) {
isc_result_t result;
isc_sockaddr_t sockaddrs[DIG_MAX_ADDRESSES];
isc_netaddr_t netaddr;
int count, i;
dig_server_t *srv;
char tmp[ISC_NETADDR_FORMATSIZE];
result = bind9_getaddresses(host, 0, sockaddrs,
DIG_MAX_ADDRESSES, &count);
if (result != ISC_R_SUCCESS)
fatal("couldn't get address for '%s': %s",
host, isc_result_totext(result));
for (i = 0; i < count; i++) {
isc_netaddr_fromsockaddr(&netaddr, &sockaddrs[i]);
isc_netaddr_format(&netaddr, tmp, sizeof(tmp));
srv = make_server(tmp, host);
ISC_LIST_APPEND(lookup->my_server_list, srv, link);
}
addresscount = count;
}
struct Client *make_remote_server_full(struct Client *uplink, const char *name, const char *id)
{
struct Client *client;
client = make_client(NULL);
client->servptr = uplink;
attach_server_conf(client, find_server_conf(name));
rb_strlcpy(client->name, name, sizeof(client->name));
rb_strlcpy(client->id, id, sizeof(client->id));
rb_dlinkAdd(client, &client->lnode, &uplink->serv->servers);
rb_dlinkMoveNode(&client->localClient->tnode, &unknown_list, &serv_list);
rb_dlinkAddTailAlloc(client, &global_serv_list);
make_server(client);
SetServer(client);
add_to_client_hash(client->name, client);
return client;
}
// XXX Check IDs to make sure they are legal
void dssim_t::do_events() {
while(config.sched.eventp(ticks)) {
Sched::event ev = config.sched.pop();
node_id_t nid = config.sched.nidid2nid[ev.nidid];
LOG(l::DBG_EV, "Event tick:" << ticks
<< " nidid:" << ev.nidid
<< " nid:" << nid
<< " aid:" << aid2str[ev.aid]
<< "\n");
switch(ev.aid){
case Sched::A_DIE:
net->die(nid);
nodes.erase(nid);
break;
case Sched::A_SJOIN: {
node_id_t nid = net->get_new_nid();
make_server(nid);
}
break;
case Sched::A_CJOIN: {
node_id_t nid = net->get_new_nid();
make_client(nid, "dynamic");
}
break;
case Sched::A_PAUSE:
paused.insert(nid);
break;
case Sched::A_UNPAUSE:
if(paused.count(nid) > 0) {
paused.erase(nid);
nodes[nid]->set_unpaused_tick(now());
}
break;
}
}
}
/*
* Main program. Initialize us, disconnect us from the tty if necessary,
* and loop waiting for I/O and/or timer expiries.
*/
int
ntpdmain(
int argc,
char *argv[]
)
{
l_fp now;
struct recvbuf *rbuf;
#ifdef _AIX /* HMS: ifdef SIGDANGER? */
struct sigaction sa;
#endif
progname = argv[0];
initializing = 1; /* mark that we are initializing */
process_commandline_opts(&argc, &argv);
init_logging(progname, 1); /* Open the log file */
char *error = NULL;
if (sandbox_init("ntpd", SANDBOX_NAMED, &error) == -1) {
msyslog(LOG_ERR, "sandbox_init(ntpd, SANDBOX_NAMED) failed: %s", error);
sandbox_free_error(error);
}
#ifdef HAVE_UMASK
{
mode_t uv;
uv = umask(0);
if(uv)
(void) umask(uv);
else
(void) umask(022);
}
#endif
#if defined(HAVE_GETUID) && !defined(MPE) /* MPE lacks the concept of root */
{
uid_t uid;
uid = getuid();
if (uid && !HAVE_OPT( SAVECONFIGQUIT )) {
msyslog(LOG_ERR, "ntpd: must be run as root, not uid %ld", (long)uid);
printf("must be run as root, not uid %ld\n", (long)uid);
exit(1);
}
}
#endif
/* getstartup(argc, argv); / * startup configuration, may set debug */
#ifdef DEBUG
debug = DESC(DEBUG_LEVEL).optOccCt;
DPRINTF(1, ("%s\n", Version));
#endif
/* honor -l/--logfile option to log to a file */
setup_logfile();
/*
* Enable the Multi-Media Timer for Windows?
*/
#ifdef SYS_WINNT
if (HAVE_OPT( MODIFYMMTIMER ))
set_mm_timer(MM_TIMER_HIRES);
#endif
if (HAVE_OPT( NOFORK ) || HAVE_OPT( QUIT )
#ifdef DEBUG
|| debug
#endif
|| HAVE_OPT( SAVECONFIGQUIT ))
nofork = 1;
if (HAVE_OPT( NOVIRTUALIPS ))
listen_to_virtual_ips = 0;
/*
* --interface, listen on specified interfaces
*/
if (HAVE_OPT( INTERFACE )) {
int ifacect = STACKCT_OPT( INTERFACE );
const char** ifaces = STACKLST_OPT( INTERFACE );
isc_netaddr_t netaddr;
while (ifacect-- > 0) {
add_nic_rule(
is_ip_address(*ifaces, &netaddr)
? MATCH_IFADDR
: MATCH_IFNAME,
*ifaces, -1, ACTION_LISTEN);
ifaces++;
}
}
if (HAVE_OPT( NICE ))
priority_done = 0;
#if defined(HAVE_SCHED_SETSCHEDULER)
if (HAVE_OPT( PRIORITY )) {
config_priority = OPT_VALUE_PRIORITY;
config_priority_override = 1;
priority_done = 0;
}
#endif
#ifdef SYS_WINNT
/*
* Start interpolation thread, must occur before first
* get_systime()
*/
init_winnt_time();
#endif
/*
* Initialize random generator and public key pair
*/
get_systime(&now);
ntp_srandom((int)(now.l_i * now.l_uf));
#if !defined(VMS)
# ifndef NODETACH
/*
* Detach us from the terminal. May need an #ifndef GIZMO.
*/
if (!nofork) {
/*
* Install trap handlers to log errors and assertion
* failures. Default handlers print to stderr which
* doesn't work if detached.
*/
isc_assertion_setcallback(assertion_failed);
isc_error_setfatal(library_fatal_error);
isc_error_setunexpected(library_unexpected_error);
# ifndef SYS_WINNT
# ifdef HAVE_DAEMON
daemon(0, 0);
# else /* not HAVE_DAEMON */
if (fork()) /* HMS: What about a -1? */
exit(0);
{
#if !defined(F_CLOSEM)
u_long s;
int max_fd;
#endif /* !FCLOSEM */
if (syslog_file != NULL) {
fclose(syslog_file);
syslog_file = NULL;
}
#if defined(F_CLOSEM)
/*
* From 'Writing Reliable AIX Daemons,' SG24-4946-00,
* by Eric Agar (saves us from doing 32767 system
* calls)
*/
if (fcntl(0, F_CLOSEM, 0) == -1)
msyslog(LOG_ERR, "ntpd: failed to close open files(): %m");
#else /* not F_CLOSEM */
# if defined(HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
max_fd = sysconf(_SC_OPEN_MAX);
# else /* HAVE_SYSCONF && _SC_OPEN_MAX */
max_fd = getdtablesize();
# endif /* HAVE_SYSCONF && _SC_OPEN_MAX */
for (s = 0; s < max_fd; s++)
(void) close((int)s);
#endif /* not F_CLOSEM */
(void) open("/", 0);
(void) dup2(0, 1);
(void) dup2(0, 2);
init_logging(progname, 0);
/* we lost our logfile (if any) daemonizing */
setup_logfile();
#ifdef SYS_DOMAINOS
{
uid_$t puid;
status_$t st;
proc2_$who_am_i(&puid);
proc2_$make_server(&puid, &st);
}
#endif /* SYS_DOMAINOS */
#if defined(HAVE_SETPGID) || defined(HAVE_SETSID)
# ifdef HAVE_SETSID
if (setsid() == (pid_t)-1)
msyslog(LOG_ERR, "ntpd: setsid(): %m");
# else
if (setpgid(0, 0) == -1)
msyslog(LOG_ERR, "ntpd: setpgid(): %m");
# endif
#else /* HAVE_SETPGID || HAVE_SETSID */
{
# if defined(TIOCNOTTY)
int fid;
fid = open("/dev/tty", 2);
if (fid >= 0)
{
(void) ioctl(fid, (u_long) TIOCNOTTY, (char *) 0);
(void) close(fid);
}
# endif /* defined(TIOCNOTTY) */
# ifdef HAVE_SETPGRP_0
(void) setpgrp();
# else /* HAVE_SETPGRP_0 */
(void) setpgrp(0, getpid());
# endif /* HAVE_SETPGRP_0 */
}
#endif /* HAVE_SETPGID || HAVE_SETSID */
#ifdef _AIX
/* Don't get killed by low-on-memory signal. */
sa.sa_handler = catch_danger;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
(void) sigaction(SIGDANGER, &sa, NULL);
#endif /* _AIX */
}
# endif /* not HAVE_DAEMON */
# endif /* SYS_WINNT */
}
# endif /* NODETACH */
#endif /* VMS */
#ifdef SCO5_CLOCK
/*
* SCO OpenServer's system clock offers much more precise timekeeping
* on the base CPU than the other CPUs (for multiprocessor systems),
* so we must lock to the base CPU.
*/
{
int fd = open("/dev/at1", O_RDONLY);
if (fd >= 0) {
int zero = 0;
if (ioctl(fd, ACPU_LOCK, &zero) < 0)
msyslog(LOG_ERR, "cannot lock to base CPU: %m");
close( fd );
} /* else ...
* If we can't open the device, this probably just isn't
* a multiprocessor system, so we're A-OK.
*/
}
#endif
#if defined(HAVE_MLOCKALL) && defined(MCL_CURRENT) && defined(MCL_FUTURE)
# ifdef HAVE_SETRLIMIT
/*
* Set the stack limit to something smaller, so that we don't lock a lot
* of unused stack memory.
*/
{
struct rlimit rl;
/* HMS: must make the rlim_cur amount configurable */
if (getrlimit(RLIMIT_STACK, &rl) != -1
&& (rl.rlim_cur = 50 * 4096) < rl.rlim_max)
{
if (setrlimit(RLIMIT_STACK, &rl) == -1)
{
msyslog(LOG_ERR,
"Cannot adjust stack limit for mlockall: %m");
}
}
# ifdef RLIMIT_MEMLOCK
/*
* The default RLIMIT_MEMLOCK is very low on Linux systems.
* Unless we increase this limit malloc calls are likely to
* fail if we drop root privlege. To be useful the value
* has to be larger than the largest ntpd resident set size.
*/
rl.rlim_cur = rl.rlim_max = 32*1024*1024;
if (setrlimit(RLIMIT_MEMLOCK, &rl) == -1) {
msyslog(LOG_ERR, "Cannot set RLIMIT_MEMLOCK: %m");
}
# endif /* RLIMIT_MEMLOCK */
}
# endif /* HAVE_SETRLIMIT */
/*
* lock the process into memory
*/
if (mlockall(MCL_CURRENT|MCL_FUTURE) < 0)
msyslog(LOG_ERR, "mlockall(): %m");
#else /* not (HAVE_MLOCKALL && MCL_CURRENT && MCL_FUTURE) */
# ifdef HAVE_PLOCK
# ifdef PROCLOCK
# ifdef _AIX
/*
* set the stack limit for AIX for plock().
* see get_aix_stack() for more info.
*/
if (ulimit(SET_STACKLIM, (get_aix_stack() - 8*4096)) < 0)
{
msyslog(LOG_ERR,"Cannot adjust stack limit for plock on AIX: %m");
}
# endif /* _AIX */
/*
* lock the process into memory
*/
if (plock(PROCLOCK) < 0)
msyslog(LOG_ERR, "plock(PROCLOCK): %m");
# else /* not PROCLOCK */
# ifdef TXTLOCK
/*
* Lock text into ram
*/
if (plock(TXTLOCK) < 0)
msyslog(LOG_ERR, "plock(TXTLOCK) error: %m");
# else /* not TXTLOCK */
msyslog(LOG_ERR, "plock() - don't know what to lock!");
# endif /* not TXTLOCK */
# endif /* not PROCLOCK */
# endif /* HAVE_PLOCK */
#endif /* not (HAVE_MLOCKALL && MCL_CURRENT && MCL_FUTURE) */
/*
* Set up signals we pay attention to locally.
*/
#ifdef SIGDIE1
(void) signal_no_reset(SIGDIE1, finish);
#endif /* SIGDIE1 */
#ifdef SIGDIE2
(void) signal_no_reset(SIGDIE2, finish);
#endif /* SIGDIE2 */
#ifdef SIGDIE3
(void) signal_no_reset(SIGDIE3, finish);
#endif /* SIGDIE3 */
#ifdef SIGDIE4
(void) signal_no_reset(SIGDIE4, finish);
#endif /* SIGDIE4 */
#ifdef SIGBUS
(void) signal_no_reset(SIGBUS, finish);
#endif /* SIGBUS */
#if !defined(SYS_WINNT) && !defined(VMS)
# ifdef DEBUG
(void) signal_no_reset(MOREDEBUGSIG, moredebug);
(void) signal_no_reset(LESSDEBUGSIG, lessdebug);
# else
(void) signal_no_reset(MOREDEBUGSIG, no_debug);
(void) signal_no_reset(LESSDEBUGSIG, no_debug);
# endif /* DEBUG */
#endif /* !SYS_WINNT && !VMS */
/*
* Set up signals we should never pay attention to.
*/
#if defined SIGPIPE
(void) signal_no_reset(SIGPIPE, SIG_IGN);
#endif /* SIGPIPE */
/*
* Call the init_ routines to initialize the data structures.
*
* Exactly what command-line options are we expecting here?
*/
init_auth();
init_util();
init_restrict();
init_mon();
init_timer();
init_lib();
init_request();
init_control();
init_peer();
#ifdef REFCLOCK
init_refclock();
#endif
set_process_priority();
init_proto(); /* Call at high priority */
init_io();
init_loopfilter();
mon_start(MON_ON); /* monitor on by default now */
/* turn off in config if unwanted */
/*
* Get the configuration. This is done in a separate module
* since this will definitely be different for the gizmo board.
*/
getconfig(argc, argv);
NLOG(NLOG_SYSINFO) /* 'if' clause for syslog */
msyslog(LOG_NOTICE, "%s", Version);
report_event(EVNT_SYSRESTART, NULL, NULL);
loop_config(LOOP_DRIFTCOMP, old_drift);
initializing = 0;
#ifdef HAVE_DROPROOT
if( droproot ) {
/* Drop super-user privileges and chroot now if the OS supports this */
#ifdef HAVE_LINUX_CAPABILITIES
/* set flag: keep privileges accross setuid() call (we only really need cap_sys_time): */
if (prctl( PR_SET_KEEPCAPS, 1L, 0L, 0L, 0L ) == -1) {
msyslog( LOG_ERR, "prctl( PR_SET_KEEPCAPS, 1L ) failed: %m" );
exit(-1);
}
#else
/* we need a user to switch to */
if (user == NULL) {
msyslog(LOG_ERR, "Need user name to drop root privileges (see -u flag!)" );
exit(-1);
}
#endif /* HAVE_LINUX_CAPABILITIES */
if (user != NULL) {
if (isdigit((unsigned char)*user)) {
sw_uid = (uid_t)strtoul(user, &endp, 0);
if (*endp != '\0')
goto getuser;
if ((pw = getpwuid(sw_uid)) != NULL) {
user = strdup(pw->pw_name);
if (NULL == user) {
msyslog(LOG_ERR, "strdup() failed: %m");
exit (-1);
}
sw_gid = pw->pw_gid;
} else {
errno = 0;
msyslog(LOG_ERR, "Cannot find user ID %s", user);
exit (-1);
}
} else {
getuser:
errno = 0;
if ((pw = getpwnam(user)) != NULL) {
sw_uid = pw->pw_uid;
sw_gid = pw->pw_gid;
} else {
if (errno)
msyslog(LOG_ERR, "getpwnam(%s) failed: %m", user);
else
msyslog(LOG_ERR, "Cannot find user `%s'", user);
exit (-1);
}
}
}
if (group != NULL) {
if (isdigit((unsigned char)*group)) {
sw_gid = (gid_t)strtoul(group, &endp, 0);
if (*endp != '\0')
goto getgroup;
} else {
getgroup:
if ((gr = getgrnam(group)) != NULL) {
sw_gid = gr->gr_gid;
} else {
errno = 0;
msyslog(LOG_ERR, "Cannot find group `%s'", group);
exit (-1);
}
}
}
if (chrootdir ) {
/* make sure cwd is inside the jail: */
if (chdir(chrootdir)) {
msyslog(LOG_ERR, "Cannot chdir() to `%s': %m", chrootdir);
exit (-1);
}
if (chroot(chrootdir)) {
msyslog(LOG_ERR, "Cannot chroot() to `%s': %m", chrootdir);
exit (-1);
}
if (chdir("/")) {
msyslog(LOG_ERR, "Cannot chdir() to`root after chroot(): %m");
exit (-1);
}
}
if (user && initgroups(user, sw_gid)) {
msyslog(LOG_ERR, "Cannot initgroups() to user `%s': %m", user);
exit (-1);
}
if (group && setgid(sw_gid)) {
msyslog(LOG_ERR, "Cannot setgid() to group `%s': %m", group);
exit (-1);
}
if (group && setegid(sw_gid)) {
msyslog(LOG_ERR, "Cannot setegid() to group `%s': %m", group);
exit (-1);
}
if (user && setuid(sw_uid)) {
msyslog(LOG_ERR, "Cannot setuid() to user `%s': %m", user);
exit (-1);
}
if (user && seteuid(sw_uid)) {
msyslog(LOG_ERR, "Cannot seteuid() to user `%s': %m", user);
exit (-1);
}
#ifndef HAVE_LINUX_CAPABILITIES
/*
* for now assume that the privilege to bind to privileged ports
* is associated with running with uid 0 - should be refined on
* ports that allow binding to NTP_PORT with uid != 0
*/
disable_dynamic_updates |= (sw_uid != 0); /* also notifies routing message listener */
#endif
if (disable_dynamic_updates && interface_interval) {
interface_interval = 0;
msyslog(LOG_INFO, "running in unprivileged mode disables dynamic interface tracking");
}
#ifdef HAVE_LINUX_CAPABILITIES
do {
/*
* We may be running under non-root uid now, but we still hold full root privileges!
* We drop all of them, except for the crucial one or two: cap_sys_time and
* cap_net_bind_service if doing dynamic interface tracking.
*/
cap_t caps;
char *captext = (interface_interval)
? "cap_sys_time,cap_net_bind_service=ipe"
: "cap_sys_time=ipe";
if( ! ( caps = cap_from_text( captext ) ) ) {
msyslog( LOG_ERR, "cap_from_text() failed: %m" );
exit(-1);
}
if( cap_set_proc( caps ) == -1 ) {
msyslog( LOG_ERR, "cap_set_proc() failed to drop root privileges: %m" );
exit(-1);
}
cap_free( caps );
} while(0);
#endif /* HAVE_LINUX_CAPABILITIES */
} /* if( droproot ) */
#endif /* HAVE_DROPROOT */
/*
* Use select() on all on all input fd's for unlimited
* time. select() will terminate on SIGALARM or on the
* reception of input. Using select() means we can't do
* robust signal handling and we get a potential race
* between checking for alarms and doing the select().
* Mostly harmless, I think.
*/
/* On VMS, I suspect that select() can't be interrupted
* by a "signal" either, so I take the easy way out and
* have select() time out after one second.
* System clock updates really aren't time-critical,
* and - lacking a hardware reference clock - I have
* yet to learn about anything else that is.
*/
#if defined(HAVE_IO_COMPLETION_PORT)
for (;;) {
GetReceivedBuffers();
#else /* normal I/O */
BLOCK_IO_AND_ALARM();
was_alarmed = 0;
for (;;)
{
# if !defined(HAVE_SIGNALED_IO)
extern fd_set activefds;
extern int maxactivefd;
fd_set rdfdes;
int nfound;
# endif
if (alarm_flag) /* alarmed? */
{
was_alarmed = 1;
alarm_flag = 0;
}
if (!was_alarmed && has_full_recv_buffer() == ISC_FALSE)
{
/*
* Nothing to do. Wait for something.
*/
# ifndef HAVE_SIGNALED_IO
rdfdes = activefds;
# if defined(VMS) || defined(SYS_VXWORKS)
/* make select() wake up after one second */
{
struct timeval t1;
t1.tv_sec = 1; t1.tv_usec = 0;
nfound = select(maxactivefd+1, &rdfdes, (fd_set *)0,
(fd_set *)0, &t1);
}
# else
nfound = select(maxactivefd+1, &rdfdes, (fd_set *)0,
(fd_set *)0, (struct timeval *)0);
# endif /* VMS */
if (nfound > 0)
{
l_fp ts;
get_systime(&ts);
(void)input_handler(&ts);
}
else if (nfound == -1 && errno != EINTR)
msyslog(LOG_ERR, "select() error: %m");
# ifdef DEBUG
else if (debug > 5)
msyslog(LOG_DEBUG, "select(): nfound=%d, error: %m", nfound);
# endif /* DEBUG */
# else /* HAVE_SIGNALED_IO */
wait_for_signal();
# endif /* HAVE_SIGNALED_IO */
if (alarm_flag) /* alarmed? */
{
was_alarmed = 1;
alarm_flag = 0;
}
}
if (was_alarmed)
{
UNBLOCK_IO_AND_ALARM();
/*
* Out here, signals are unblocked. Call timer routine
* to process expiry.
*/
timer();
was_alarmed = 0;
BLOCK_IO_AND_ALARM();
}
#endif /* ! HAVE_IO_COMPLETION_PORT */
#ifdef DEBUG_TIMING
{
l_fp pts;
l_fp tsa, tsb;
int bufcount = 0;
get_systime(&pts);
tsa = pts;
#endif
rbuf = get_full_recv_buffer();
while (rbuf != NULL)
{
if (alarm_flag)
{
was_alarmed = 1;
alarm_flag = 0;
}
UNBLOCK_IO_AND_ALARM();
if (was_alarmed)
{ /* avoid timer starvation during lengthy I/O handling */
timer();
was_alarmed = 0;
}
/*
* Call the data procedure to handle each received
* packet.
*/
if (rbuf->receiver != NULL) /* This should always be true */
{
#ifdef DEBUG_TIMING
l_fp dts = pts;
L_SUB(&dts, &rbuf->recv_time);
DPRINTF(2, ("processing timestamp delta %s (with prec. fuzz)\n", lfptoa(&dts, 9)));
collect_timing(rbuf, "buffer processing delay", 1, &dts);
bufcount++;
#endif
(rbuf->receiver)(rbuf);
} else {
msyslog(LOG_ERR, "receive buffer corruption - receiver found to be NULL - ABORTING");
abort();
}
BLOCK_IO_AND_ALARM();
freerecvbuf(rbuf);
rbuf = get_full_recv_buffer();
}
#ifdef DEBUG_TIMING
get_systime(&tsb);
L_SUB(&tsb, &tsa);
if (bufcount) {
collect_timing(NULL, "processing", bufcount, &tsb);
DPRINTF(2, ("processing time for %d buffers %s\n", bufcount, lfptoa(&tsb, 9)));
}
}
#endif
/*
* Go around again
*/
#ifdef HAVE_DNSREGISTRATION
if (mdnsreg && (current_time - mdnsreg ) > 60 && mdnstries && sys_leap != LEAP_NOTINSYNC) {
mdnsreg = current_time;
msyslog(LOG_INFO, "Attemping to register mDNS");
if ( DNSServiceRegister (&mdns, 0, 0, NULL, "_ntp._udp", NULL, NULL,
htons(NTP_PORT), 0, NULL, NULL, NULL) != kDNSServiceErr_NoError ) {
if (!--mdnstries) {
msyslog(LOG_ERR, "Unable to register mDNS, giving up.");
} else {
msyslog(LOG_INFO, "Unable to register mDNS, will try later.");
}
} else {
msyslog(LOG_INFO, "mDNS service registered.");
mdnsreg = 0;
}
}
#endif /* HAVE_DNSREGISTRATION */
}
UNBLOCK_IO_AND_ALARM();
return 1;
}
#ifdef SIGDIE2
/*
* finish - exit gracefully
*/
static RETSIGTYPE
finish(
int sig
)
{
msyslog(LOG_NOTICE, "ntpd exiting on signal %d", sig);
#ifdef HAVE_DNSREGISTRATION
if (mdns != NULL)
DNSServiceRefDeallocate(mdns);
#endif
switch (sig) {
# ifdef SIGBUS
case SIGBUS:
printf("\nfinish(SIGBUS)\n");
exit(0);
# endif
case 0: /* Should never happen... */
return;
default:
exit(0);
}
}
/*
* m_server
* parv[0] = sender prefix
* parv[1] = servername
* parv[2] = serverinfo/hopcount
* parv[3] = serverinfo
*/
int m_server(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
int i;
char info[REALLEN + 1], *host;
aClient *acptr, *bcptr;
aConnect *aconn;
int hop;
char nbuf[HOSTLEN * 2 + USERLEN + 5]; /* same size as in s_misc.c */
info[0] = '\0';
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(cptr, "ERROR :No servername");
return 0;
}
hop = 0;
host = parv[1];
if (parc > 3 && atoi(parv[2]))
{
hop = atoi(parv[2]);
strncpyzt(info, parv[3], REALLEN + 1);
}
else if (parc > 2)
{
strncpyzt(info, parv[2], REALLEN + 1);
if ((parc > 3) && ((i = strlen(info)) < (REALLEN - 2)))
{
strcat(info, " ");
strncat(info, parv[3], REALLEN - i - 2);
info[REALLEN] = '\0';
}
}
/*
* July 5, 1997
* Rewritten to throw away server cruft from users,
* combined the hostname validity test with cleanup of host name,
* so a cleaned up hostname can be returned as an error if
* necessary. - Dianora
*/
/* yes, the if(strlen) below is really needed!! */
if (strlen(host) > HOSTLEN)
host[HOSTLEN] = '\0';
if (IsPerson(cptr))
{
/* A local link that has been identified as a USER tries
* something fishy... ;-)
*/
sendto_one(cptr, err_str(ERR_UNKNOWNCOMMAND),
me.name, parv[0], "SERVER");
return 0;
}
else
/* hostile servername check */
{
/*
* Lets check for bogus names and clean them up we don't bother
* cleaning up ones from users, becasuse we will never see them
* any more - Dianora
*/
int bogus_server = 0;
int found_dot = 0;
char clean_host[(2 * HOSTLEN) + 1];
char *s;
char *d;
int n;
s = host;
d = clean_host;
n = (2 * HOSTLEN) - 2;
while (*s && n > 0)
{
if ((unsigned char) *s < (unsigned char) ' ')
/* Is it a control character? */
{
bogus_server = 1;
*d++ = '^';
*d++ = (char) ((unsigned char) *s + 0x40);
/* turn it into a printable */
n -= 2;
}
else if ((unsigned char) *s > (unsigned char) '~')
{
bogus_server = 1;
*d++ = '.';
n--;
}
else
{
if (*s == '.')
found_dot = 1;
*d++ = *s;
n--;
}
s++;
}
*d = '\0';
if ((!found_dot) || bogus_server)
{
sendto_one(sptr, "ERROR :Bogus server name (%s)",
clean_host);
return exit_client(cptr, cptr, cptr, "Bogus server name");
}
}
/* new connection */
if (IsUnknown(cptr) || IsHandshake(cptr))
{
strncpyzt(cptr->name, host, sizeof(cptr->name));
strncpyzt(cptr->info, info[0] ? info : me.name, REALLEN + 1);
cptr->hopcount = hop;
switch (check_server_init(cptr))
{
case 0:
return m_server_estab(cptr);
case 1:
sendto_ops("Access check for %s in progress",
get_client_name(cptr, HIDEME));
return 1;
default:
ircstp->is_ref++;
sendto_ops_lev(ADMIN_LEV, "Link %s dropped, no Connect block",
get_client_name(cptr, TRUE));
return exit_client(cptr, cptr, cptr, "No Connect block");
}
}
/* already linked server */
if (!IsServer(cptr))
return 0;
if ((acptr = find_name(host, NULL)))
{
/*
* * This link is trying feed me a server that I already have
* access through another path -- multiple paths not accepted
* currently, kill this link immediately!!
*
* Rather than KILL the link which introduced it, KILL the
* youngest of the two links. -avalon
*/
bcptr = (cptr->firsttime > acptr->from->firsttime) ? cptr :
acptr->from;
sendto_one(bcptr, "ERROR :Server %s already exists", host);
if (bcptr == cptr)
{
/* Don't complain for servers that are juped */
/* (don't complain if the server that already exists is U: lined,
unless I actually have a .conf U: line for it */
if(!IsULine(acptr) || find_aUserver(acptr->name))
{
sendto_gnotice("from %s: Link %s cancelled, server %s already "
"exists", me.name, get_client_name(bcptr, HIDEME),
host);
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, "
"server %s already exists", me.name,
get_client_name(bcptr, HIDEME), host);
}
return exit_client(bcptr, bcptr, &me, "Server Exists");
}
/* inform all those who care (set +n) -epi */
strcpy(nbuf, get_client_name(bcptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, server %s reintroduced "
"by %s", me.name, nbuf, host,
get_client_name(cptr, HIDEME));
sendto_serv_butone(bcptr, ":%s GNOTICE :Link %s cancelled, server %s "
"reintroduced by %s", me.name, nbuf, host,
get_client_name(cptr, HIDEME));
exit_client(bcptr, bcptr, &me, "Server Exists");
}
/*
* The following if statement would be nice to remove since user
* nicks never have '.' in them and servers must always have '.' in
* them. There should never be a server/nick name collision, but it
* is possible a capricious server admin could deliberately do
* something strange.
*
* -Dianora
*/
if ((acptr = find_client(host, NULL)) && acptr != cptr)
{
/*
* * Server trying to use the same name as a person. Would
* cause a fair bit of confusion. Enough to make it hellish for
* a while and servers to send stuff to the wrong place.
*/
sendto_one(cptr, "ERROR :Nickname %s already exists!", host);
strcpy(nbuf, get_client_name(cptr, HIDEME));
sendto_gnotice("from %s: Link %s cancelled, servername/nick collision",
me.name, nbuf);
sendto_serv_butone(cptr, ":%s GNOTICE :Link %s cancelled, "
"servername/nick collision", me.name, nbuf);
return exit_client(cptr, cptr, cptr, "Nick as Server");
}
if (IsServer(cptr))
{
/*
* * Server is informing about a new server behind this link.
* Create REMOTE server structure, add it to list and propagate
* word to my other server links...
*/
if (parc == 1 || info[0] == '\0')
{
sendto_one(cptr, "ERROR :No server info specified for %s", host);
return 0;
}
/*
* * See if the newly found server is behind a guaranteed leaf
* (L-line). If so, close the link.
*
* Depreciated. Kinda redundant with Hlines. -epi
*/
if (!(cptr->serv->aconn->flags & CONN_HUB))
{
aconn = cptr->serv->aconn;
sendto_gnotice("from %s: Non-Hub link %s introduced %s",
me.name, get_client_name(cptr, HIDEME), host);
sendto_serv_butone(cptr,":%s GNOTICE :Non-Hub link %s introduced "
"%s", me.name, get_client_name(cptr, HIDEME),
host);
sendto_one(cptr, "ERROR :You're not a hub (introducing %s)",
host);
return exit_client(cptr, cptr, cptr, "Too many servers");
}
acptr = make_client(cptr, sptr);
make_server(acptr);
acptr->hopcount = hop;
strncpyzt(acptr->name, host, sizeof(acptr->name));
strncpyzt(acptr->info, info, REALLEN + 1);
acptr->serv->up = find_or_add(parv[0]);
fakelinkserver_update(acptr->name, acptr->info);
SetServer(acptr);
/*
* if this server is behind a U-lined server, make it U-lined as
* well. - lucas
*/
if (IsULine(sptr) || find_aUserver(acptr->name))
{
acptr->flags |= FLAGS_ULINE;
sendto_realops_lev(DEBUG_LEV, "%s introducing super server %s",
cptr->name, acptr->name);
}
Count.server++;
add_client_to_list(acptr);
add_to_client_hash_table(acptr->name, acptr);
/*
* Old sendto_serv_but_one() call removed because we now need
* to send different names to different servers (domain name matching)
*/
for (i = 0; i <= highest_fd; i++)
{
if (!(bcptr = local[i]) || !IsServer(bcptr) || bcptr == cptr ||
IsMe(bcptr))
continue;
if (!(aconn = bcptr->serv->aconn))
{
sendto_gnotice("from %s: Lost Connect block for %s on %s."
" Closing", me.name,
get_client_name(cptr, HIDEME), host);
sendto_serv_butone(cptr, ":%s GNOTICE :Lost Connect block for"
" %s on %s. Closing", me.name,
get_client_name(cptr, HIDEME), host);
return exit_client(cptr, cptr, cptr, "Lost Connect block");
}
if (match(my_name_for_link(me.name, aconn), acptr->name) == 0)
continue;
sendto_one(bcptr, ":%s SERVER %s %d :%s",
parv[0], acptr->name, hop + 1, acptr->info);
}
return 0;
}
return 0;
}
/*
** mo_jupe
** parv[0] = sender prefix
** parv[1] = server we're juping
** parv[2] = reason for jupe
*/
static void mo_jupe(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
struct Client *target_p;
struct Client *ajupe;
dlink_node *m;
char reason[REALLEN+2];
if(!ServerInfo.hub)
return;
if(!IsOperAdmin(source_p))
{
sendto_one(source_p, ":%s NOTICE %s :You must be an admin to use this command",
me.name, parv[0]);
return;
}
if (bogus_host(parv[1]))
{
sendto_one(source_p, ":%s NOTICE %s :Invalid servername: %s",
me.name, parv[0], parv[1]);
return;
}
if(match(parv[1], me.name))
{
sendto_one(source_p, ":%s NOTICE %s :I cant jupe myself!",
me.name, source_p->name);
return;
}
sendto_wallops_flags(UMODE_WALLOP, &me,
"JUPE for %s requested by %s: %s",
parv[1], get_oper_name(source_p), parv[2]);
sendto_server(NULL, NOCAPS, NOCAPS,
":%s WALLOPS :JUPE for %s requested by %s!%s@%s: %s",
parv[0], parv[1], source_p->name,
source_p->username, source_p->host, parv[2]);
ilog(L_NOTICE, "JUPE for %s requested by %s: %s",
parv[1], get_oper_name(source_p), parv[2]);
target_p= find_server(parv[1]);
if(target_p)
exit_client(client_p, target_p, &me, parv[2]);
sendto_server(NULL, NOCAPS, NOCAPS,
":%s SERVER %s 1 :JUPED: %s",
me.name, parv[1], parv[2]);
sendto_realops_flags(UMODE_ALL, L_ALL,
"Link with %s established: (JUPED) link",
parv[1]);
ajupe = make_client(NULL);
/* make_client() adds client to unknown_list */
m = dlinkFind(&unknown_list, ajupe);
if(m != NULL)
dlinkDelete(m, &unknown_list);
free_dlink_node(m);
make_server(ajupe);
ajupe->hopcount = 1;
strlcpy(ajupe->name,parv[1],HOSTLEN);
/* we need to give 7 chars to prepend "JUPED: " */
if(strlen(parv[2]) > (REALLEN-7))
parv[2][REALLEN-7] = '\0';
ircsprintf(reason, "%s %s", "JUPED:", parv[2]);
strlcpy(ajupe->info,reason,REALLEN);
ajupe->serv->up = me.name;
ajupe->servptr = &me;
SetServer(ajupe);
SetDead(ajupe);
Count.server++;
Count.myserver++;
/* Some day, all these lists will be consolidated *sigh* */
add_client_to_list(ajupe);
add_to_client_hash_table(ajupe->name, ajupe);
dlinkAdd(ajupe, &ajupe->lnode, &ajupe->servptr->serv->servers);
add_server_to_list(ajupe);
}
int node_make_server(struct node *node)
{
return make_server(node->remote_ip, node->remote_port);
}
int
main(int argc, char *argv[])
{
/* Check to see if the user is running us as root, which is a nono */
if(geteuid() == 0)
{
fprintf(stderr, "Don't run ircd as root!!!\n");
return -1;
}
/*
* save server boot time right away, so getrusage works correctly
*/
set_time();
/*
* Setup corefile size immediately after boot -kre
*/
setup_corefile();
/*
* set initialVMTop before we allocate any memory
*/
initialVMTop = get_vm_top();
ServerRunning = 0;
/* It ain't random, but it ought to be a little harder to guess */
srand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
memset(&me, 0, sizeof(me));
memset(&meLocalUser, 0, sizeof(meLocalUser));
me.localClient = &meLocalUser;
/* Make sure all lists are zeroed */
memset(&unknown_list, 0, sizeof(unknown_list));
memset(&lclient_list, 0, sizeof(lclient_list));
memset(&serv_list, 0, sizeof(serv_list));
memset(&global_serv_list, 0, sizeof(global_serv_list));
memset(&oper_list, 0, sizeof(oper_list));
dlinkAddTail(&me, &me.node, &global_client_list);
memset((void *) &Count, 0, sizeof(Count));
memset((void *) &ServerInfo, 0, sizeof(ServerInfo));
memset((void *) &AdminInfo, 0, sizeof(AdminInfo));
/* Initialise the channel capability usage counts... */
init_chcap_usage_counts();
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
ConfigFileEntry.dlinefile = DLPATH; /* dline file */
ConfigFileEntry.xlinefile = XPATH;
ConfigFileEntry.resvfile = RESVPATH;
ConfigFileEntry.connect_timeout = 30; /* Default to 30 */
myargv = argv;
umask(077); /* better safe than sorry --SRB */
parseargs(&argc, &argv, myopts);
if(printVersion)
{
printf("ircd: version %s\n", ircd_version);
exit(EXIT_SUCCESS);
}
if(chdir(ConfigFileEntry.dpath))
{
fprintf(stderr, "Unable to chdir to %s: %s\n", ConfigFileEntry.dpath, strerror(errno));
exit(EXIT_FAILURE);
}
setup_signals();
#ifdef __CYGWIN__
server_state_foreground = 1;
#endif
if (testing_conf)
server_state_foreground = 1;
/* We need this to initialise the fd array before anything else */
fdlist_init();
if(!server_state_foreground)
{
comm_close_all();
}
/* Check if there is pidfile and daemon already running */
if(!testing_conf)
{
check_pidfile(pidFileName);
if(!server_state_foreground)
make_daemon();
else
print_startup(getpid());
}
init_netio(); /* This needs to be setup early ! -- adrian */
/* Init the event subsystem */
eventInit();
init_sys();
init_main_logfile();
initBlockHeap();
init_dlink_nodes();
init_patricia();
newconf_init();
init_s_conf();
init_s_newconf();
linebuf_init(); /* set up some linebuf stuff to control paging */
init_hash();
clear_scache_hash_table(); /* server cache name table */
init_host_hash();
clear_hash_parse();
init_client();
initUser();
init_channels();
initclass();
initwhowas();
init_stats();
init_hook();
init_reject();
init_cache();
init_monitor();
load_all_modules(1);
#ifndef STATIC_MODULES
load_core_modules(1);
#endif
init_auth(); /* Initialise the auth code */
init_resolver(); /* Needs to be setup before the io loop */
if (testing_conf)
fprintf(stderr, "\nBeginning config test\n");
read_conf_files(YES); /* cold start init conf files */
rehash_bans(0);
#ifndef STATIC_MODULES
mod_add_path(MODULE_DIR);
mod_add_path(MODULE_DIR "/autoload");
#endif
initialize_server_capabs(); /* Set up default_server_capabs */
initialize_global_set_options();
if(ServerInfo.name == NULL)
{
fprintf(stderr, "ERROR: No server name specified in serverinfo block.\n");
ilog(L_MAIN, "No server name specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.name, ServerInfo.name, sizeof(me.name));
if(ServerInfo.sid[0] == '\0')
{
fprintf(stderr, "ERROR: No server sid specified in serverinfo block.\n");
ilog(L_MAIN, "No server sid specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strcpy(me.id, ServerInfo.sid);
init_uid();
/* serverinfo{} description must exist. If not, error out. */
if(ServerInfo.description == NULL)
{
fprintf(stderr, "ERROR: No server description specified in serverinfo block.\n");
ilog(L_MAIN, "ERROR: No server description specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.info, ServerInfo.description, sizeof(me.info));
if (testing_conf)
{
fprintf(stderr, "\nConfig testing complete.\n");
fflush(stderr);
exit(EXIT_SUCCESS);
}
me.from = &me;
me.servptr = &me;
SetMe(&me);
make_server(&me);
me.serv->up = me.name;
startup_time = CurrentTime;
add_to_client_hash(me.name, &me);
add_to_id_hash(me.id, &me);
dlinkAddAlloc(&me, &global_serv_list);
check_class();
write_pidfile(pidFileName);
load_help();
open_logfiles();
ilog(L_MAIN, "Server Ready");
eventAddIsh("cleanup_glines", cleanup_glines, NULL, CLEANUP_GLINES_TIME);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
/* um. by waiting even longer, that just means we have even *more*
* nick collisions. what a stupid idea. set an event for the IO loop --fl
*/
eventAddIsh("try_connections", try_connections, NULL, STARTUP_CONNECTIONS_TIME);
eventAddOnce("try_connections_startup", try_connections, NULL, 0);
eventAddIsh("collect_zipstats", collect_zipstats, NULL, ZIPSTATS_TIME);
/* Setup the timeout check. I'll shift it later :) -- adrian */
eventAddIsh("comm_checktimeouts", comm_checktimeouts, NULL, 1);
if(ConfigServerHide.links_delay > 0)
eventAddIsh("cache_links", cache_links, NULL,
ConfigServerHide.links_delay);
else
ConfigServerHide.links_disabled = 1;
if(splitmode)
eventAdd("check_splitmode", check_splitmode, NULL, 2);
ServerRunning = 1;
io_loop();
return 0;
}
/** Handle a SERVER message from another server.
*
* \a parv has the following elements:
* \li \a parv[1] is the server name
* \li \a parv[2] is the hop count to the server
* \li \a parv[3] is the start timestamp for the server
* \li \a parv[4] is the link timestamp
* \li \a parv[5] is the protocol version (P10 or J10)
* \li \a parv[6] is the numnick mask for the server
* \li \a parv[7] is a string of flags like +hs to mark hubs and services
* \li \a parv[\a parc - 1] is the server description
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int ms_server(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
int i;
char* host;
struct Client* acptr;
struct Client* bcptr;
int hop;
int ret;
unsigned short prot;
time_t start_timestamp;
time_t timestamp;
if (parc < 8)
{
return need_more_params(sptr, "SERVER");
return exit_client(cptr, cptr, &me, "Need more parameters");
}
host = clean_servername(parv[1]);
if (!host)
{
sendto_opmask(0, SNO_OLDSNO, "Bogus server name (%s) from %s",
host, cli_name(cptr));
return exit_client_msg(cptr, cptr, &me, "Bogus server name (%s)", host);
}
/*
* Detect protocol
*/
hop = atoi(parv[2]);
start_timestamp = atoi(parv[3]);
timestamp = atoi(parv[4]);
prot = parse_protocol(parv[5]);
if (!prot)
return exit_client_msg(cptr, sptr, &me, "Bogus protocol (%s)", parv[5]);
else if (prot < atoi(MINOR_PROTOCOL))
return exit_new_server(cptr, sptr, host, timestamp,
"Incompatible protocol: %s", parv[5]);
Debug((DEBUG_INFO, "Got SERVER %s with timestamp [%s] age %Tu (%Tu)",
host, parv[4], start_timestamp, cli_serv(&me)->timestamp));
if (timestamp < OLDEST_TS)
return exit_client_msg(cptr, sptr, &me,
"Bogus timestamps (%s %s)", parv[3], parv[4]);
if (parv[parc - 1][0] == '\0')
return exit_client_msg(cptr, cptr, &me,
"No server info specified for %s", host);
ret = check_loop_and_lh(cptr, sptr, NULL, host, (parc > 7 ? parv[6] : NULL), timestamp, hop, parv[5][0] == 'J');
if (ret != 1)
return ret;
/*
* Server is informing about a new server behind
* this link. Create REMOTE server structure,
* add it to list and propagate word to my other
* server links...
*/
acptr = make_client(cptr, STAT_SERVER);
make_server(acptr);
cli_serv(acptr)->prot = prot;
cli_serv(acptr)->timestamp = timestamp;
cli_hopcount(acptr) = hop;
ircd_strncpy(cli_name(acptr), host, HOSTLEN);
ircd_strncpy(cli_info(acptr), parv[parc-1], REALLEN);
cli_serv(acptr)->up = sptr;
cli_serv(acptr)->updown = add_dlink(&(cli_serv(sptr))->down, acptr);
/* Use cptr, because we do protocol 9 -> 10 translation
for numeric nicks ! */
SetServerYXX(cptr, acptr, parv[6]);
update_uworld_flags(cptr);
if (*parv[7] == '+')
set_server_flags(acptr, parv[7] + 1);
Count_newremoteserver(UserStats);
add_client_to_list(acptr);
hAddClient(acptr);
if (*parv[5] == 'J')
{
SetBurst(acptr);
SetJunction(acptr);
for (bcptr = cli_serv(acptr)->up; !IsMe(bcptr); bcptr = cli_serv(bcptr)->up)
if (IsBurstOrBurstAck(bcptr))
break;
if (IsMe(bcptr))
sendto_opmask(0, SNO_NETWORK, "Net junction: %s %s",
cli_name(sptr), cli_name(acptr));
}
/*
* Old sendto_serv_but_one() call removed because we now need to send
* different names to different servers (domain name matching).
*/
for (i = 0; i <= HighestFd; i++)
{
if (!(bcptr = LocalClientArray[i]) || !IsServer(bcptr) ||
bcptr == cptr || IsMe(bcptr))
continue;
if (0 == match(cli_name(&me), cli_name(acptr)))
continue;
sendcmdto_one(sptr, CMD_SERVER, bcptr, "%s %d 0 %s %s %s%s +%s%s%s :%s",
cli_name(acptr), hop + 1, parv[4], parv[5],
NumServCap(acptr), IsHub(acptr) ? "h" : "",
IsService(acptr) ? "s" : "", IsIPv6(acptr) ? "6" : "",
cli_info(acptr));
}
return 0;
}
int
ntpdmain(
int argc,
char *argv[]
)
{
l_fp now;
struct recvbuf *rbuf;
const char * logfilename;
# ifdef HAVE_UMASK
mode_t uv;
# endif
# if defined(HAVE_GETUID) && !defined(MPE) /* MPE lacks the concept of root */
uid_t uid;
# endif
# if defined(HAVE_WORKING_FORK)
long wait_sync = 0;
int pipe_fds[2];
int rc;
int exit_code;
# ifdef _AIX
struct sigaction sa;
# endif
# if !defined(HAVE_SETSID) && !defined (HAVE_SETPGID) && defined(TIOCNOTTY)
int fid;
# endif
# endif /* HAVE_WORKING_FORK*/
# ifdef SCO5_CLOCK
int fd;
int zero;
# endif
# ifdef NEED_PTHREAD_WARMUP
my_pthread_warmup();
# endif
# ifdef HAVE_UMASK
uv = umask(0);
if (uv)
umask(uv);
else
umask(022);
# endif
saved_argc = argc;
saved_argv = argv;
progname = argv[0];
initializing = TRUE; /* mark that we are initializing */
parse_cmdline_opts(&argc, &argv);
# ifdef DEBUG
debug = OPT_VALUE_SET_DEBUG_LEVEL;
# ifdef HAVE_SETLINEBUF
setlinebuf(stdout);
# endif
# endif
if (HAVE_OPT(NOFORK) || HAVE_OPT(QUIT)
# ifdef DEBUG
|| debug
# endif
|| HAVE_OPT(SAVECONFIGQUIT))
nofork = TRUE;
init_logging(progname, NLOG_SYNCMASK, TRUE);
/* honor -l/--logfile option to log to a file */
if (HAVE_OPT(LOGFILE)) {
logfilename = OPT_ARG(LOGFILE);
syslogit = FALSE;
change_logfile(logfilename, FALSE);
} else {
logfilename = NULL;
if (nofork)
msyslog_term = TRUE;
if (HAVE_OPT(SAVECONFIGQUIT))
syslogit = FALSE;
}
msyslog(LOG_NOTICE, "%s: Starting", Version);
{
int i;
char buf[1024]; /* Secret knowledge of msyslog buf length */
char *cp = buf;
/* Note that every arg has an initial space character */
snprintf(cp, sizeof(buf), "Command line:");
cp += strlen(cp);
for (i = 0; i < saved_argc ; ++i) {
snprintf(cp, sizeof(buf) - (cp - buf),
" %s", saved_argv[i]);
cp += strlen(cp);
}
msyslog(LOG_INFO, "%s", buf);
}
/*
* Install trap handlers to log errors and assertion failures.
* Default handlers print to stderr which doesn't work if detached.
*/
isc_assertion_setcallback(assertion_failed);
isc_error_setfatal(library_fatal_error);
isc_error_setunexpected(library_unexpected_error);
/* MPE lacks the concept of root */
# if defined(HAVE_GETUID) && !defined(MPE)
uid = getuid();
if (uid && !HAVE_OPT( SAVECONFIGQUIT )) {
msyslog_term = TRUE;
msyslog(LOG_ERR,
"must be run as root, not uid %ld", (long)uid);
exit(1);
}
# endif
/*
* Enable the Multi-Media Timer for Windows?
*/
# ifdef SYS_WINNT
if (HAVE_OPT( MODIFYMMTIMER ))
set_mm_timer(MM_TIMER_HIRES);
# endif
#ifdef HAVE_DNSREGISTRATION
/*
* Enable mDNS registrations?
*/
if (HAVE_OPT( MDNS )) {
mdnsreg = TRUE;
}
#endif /* HAVE_DNSREGISTRATION */
if (HAVE_OPT( NOVIRTUALIPS ))
listen_to_virtual_ips = 0;
/*
* --interface, listen on specified interfaces
*/
if (HAVE_OPT( INTERFACE )) {
int ifacect = STACKCT_OPT( INTERFACE );
const char** ifaces = STACKLST_OPT( INTERFACE );
sockaddr_u addr;
while (ifacect-- > 0) {
add_nic_rule(
is_ip_address(*ifaces, AF_UNSPEC, &addr)
? MATCH_IFADDR
: MATCH_IFNAME,
*ifaces, -1, ACTION_LISTEN);
ifaces++;
}
}
if (HAVE_OPT( NICE ))
priority_done = 0;
# ifdef HAVE_SCHED_SETSCHEDULER
if (HAVE_OPT( PRIORITY )) {
config_priority = OPT_VALUE_PRIORITY;
config_priority_override = 1;
priority_done = 0;
}
# endif
# ifdef HAVE_WORKING_FORK
/* make sure the FDs are initialised */
pipe_fds[0] = -1;
pipe_fds[1] = -1;
do { /* 'loop' once */
if (!HAVE_OPT( WAIT_SYNC ))
break;
wait_sync = OPT_VALUE_WAIT_SYNC;
if (wait_sync <= 0) {
wait_sync = 0;
break;
}
/* -w requires a fork() even with debug > 0 */
nofork = FALSE;
if (pipe(pipe_fds)) {
exit_code = (errno) ? errno : -1;
msyslog(LOG_ERR,
"Pipe creation failed for --wait-sync: %m");
exit(exit_code);
}
waitsync_fd_to_close = pipe_fds[1];
} while (0); /* 'loop' once */
# endif /* HAVE_WORKING_FORK */
init_lib();
# ifdef SYS_WINNT
/*
* Start interpolation thread, must occur before first
* get_systime()
*/
init_winnt_time();
# endif
/*
* Initialize random generator and public key pair
*/
get_systime(&now);
ntp_srandom((int)(now.l_i * now.l_uf));
/*
* Detach us from the terminal. May need an #ifndef GIZMO.
*/
if (!nofork) {
# ifdef HAVE_WORKING_FORK
rc = fork();
if (-1 == rc) {
exit_code = (errno) ? errno : -1;
msyslog(LOG_ERR, "fork: %m");
exit(exit_code);
}
if (rc > 0) {
/* parent */
exit_code = wait_child_sync_if(pipe_fds[0],
wait_sync);
exit(exit_code);
}
/*
* child/daemon
* close all open files excepting waitsync_fd_to_close.
* msyslog() unreliable until after init_logging().
*/
closelog();
if (syslog_file != NULL) {
fclose(syslog_file);
syslog_file = NULL;
syslogit = TRUE;
}
close_all_except(waitsync_fd_to_close);
INSIST(0 == open("/dev/null", 0) && 1 == dup2(0, 1) \
&& 2 == dup2(0, 2));
init_logging(progname, 0, TRUE);
/* we lost our logfile (if any) daemonizing */
setup_logfile(logfilename);
# ifdef SYS_DOMAINOS
{
uid_$t puid;
status_$t st;
proc2_$who_am_i(&puid);
proc2_$make_server(&puid, &st);
}
# endif /* SYS_DOMAINOS */
# ifdef HAVE_SETSID
if (setsid() == (pid_t)-1)
msyslog(LOG_ERR, "setsid(): %m");
# elif defined(HAVE_SETPGID)
if (setpgid(0, 0) == -1)
msyslog(LOG_ERR, "setpgid(): %m");
# else /* !HAVE_SETSID && !HAVE_SETPGID follows */
# ifdef TIOCNOTTY
fid = open("/dev/tty", 2);
if (fid >= 0) {
ioctl(fid, (u_long)TIOCNOTTY, NULL);
close(fid);
}
# endif /* TIOCNOTTY */
ntp_setpgrp(0, getpid());
# endif /* !HAVE_SETSID && !HAVE_SETPGID */
# ifdef _AIX
/* Don't get killed by low-on-memory signal. */
sa.sa_handler = catch_danger;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sigaction(SIGDANGER, &sa, NULL);
# endif /* _AIX */
# endif /* HAVE_WORKING_FORK */
}
# ifdef SCO5_CLOCK
/*
* SCO OpenServer's system clock offers much more precise timekeeping
* on the base CPU than the other CPUs (for multiprocessor systems),
* so we must lock to the base CPU.
*/
fd = open("/dev/at1", O_RDONLY);
if (fd >= 0) {
zero = 0;
if (ioctl(fd, ACPU_LOCK, &zero) < 0)
msyslog(LOG_ERR, "cannot lock to base CPU: %m");
close(fd);
}
# endif
/* Setup stack size in preparation for locking pages in memory. */
# if defined(HAVE_MLOCKALL)
# ifdef HAVE_SETRLIMIT
ntp_rlimit(RLIMIT_STACK, DFLT_RLIMIT_STACK * 4096, 4096, "4k");
# ifdef RLIMIT_MEMLOCK
/*
* The default RLIMIT_MEMLOCK is very low on Linux systems.
* Unless we increase this limit malloc calls are likely to
* fail if we drop root privilege. To be useful the value
* has to be larger than the largest ntpd resident set size.
*/
ntp_rlimit(RLIMIT_MEMLOCK, DFLT_RLIMIT_MEMLOCK * 1024 * 1024, 1024 * 1024, "MB");
# endif /* RLIMIT_MEMLOCK */
# endif /* HAVE_SETRLIMIT */
# else /* !HAVE_MLOCKALL follows */
# ifdef HAVE_PLOCK
# ifdef PROCLOCK
# ifdef _AIX
/*
* set the stack limit for AIX for plock().
* see get_aix_stack() for more info.
*/
if (ulimit(SET_STACKLIM, (get_aix_stack() - 8 * 4096)) < 0)
msyslog(LOG_ERR,
"Cannot adjust stack limit for plock: %m");
# endif /* _AIX */
# endif /* PROCLOCK */
# endif /* HAVE_PLOCK */
# endif /* !HAVE_MLOCKALL */
/*
* Set up signals we pay attention to locally.
*/
# ifdef SIGDIE1
signal_no_reset(SIGDIE1, finish);
signal_no_reset(SIGDIE2, finish);
signal_no_reset(SIGDIE3, finish);
signal_no_reset(SIGDIE4, finish);
# endif
# ifdef SIGBUS
signal_no_reset(SIGBUS, finish);
# endif
# if !defined(SYS_WINNT) && !defined(VMS)
# ifdef DEBUG
(void) signal_no_reset(MOREDEBUGSIG, moredebug);
(void) signal_no_reset(LESSDEBUGSIG, lessdebug);
# else
(void) signal_no_reset(MOREDEBUGSIG, no_debug);
(void) signal_no_reset(LESSDEBUGSIG, no_debug);
# endif /* DEBUG */
# endif /* !SYS_WINNT && !VMS */
/*
* Set up signals we should never pay attention to.
*/
# ifdef SIGPIPE
signal_no_reset(SIGPIPE, SIG_IGN);
# endif
/*
* Call the init_ routines to initialize the data structures.
*
* Exactly what command-line options are we expecting here?
*/
INIT_SSL();
init_auth();
init_util();
init_restrict();
init_mon();
init_timer();
init_request();
init_control();
init_peer();
# ifdef REFCLOCK
init_refclock();
# endif
set_process_priority();
init_proto(); /* Call at high priority */
init_io();
init_loopfilter();
mon_start(MON_ON); /* monitor on by default now */
/* turn off in config if unwanted */
/*
* Get the configuration. This is done in a separate module
* since this will definitely be different for the gizmo board.
*/
getconfig(argc, argv);
if (-1 == cur_memlock) {
# if defined(HAVE_MLOCKALL)
/*
* lock the process into memory
*/
if ( !HAVE_OPT(SAVECONFIGQUIT)
# ifdef RLIMIT_MEMLOCK
&& -1 != DFLT_RLIMIT_MEMLOCK
# endif
&& 0 != mlockall(MCL_CURRENT|MCL_FUTURE))
msyslog(LOG_ERR, "mlockall(): %m");
# else /* !HAVE_MLOCKALL follows */
# ifdef HAVE_PLOCK
# ifdef PROCLOCK
/*
* lock the process into memory
*/
if (!HAVE_OPT(SAVECONFIGQUIT) && 0 != plock(PROCLOCK))
msyslog(LOG_ERR, "plock(PROCLOCK): %m");
# else /* !PROCLOCK follows */
# ifdef TXTLOCK
/*
* Lock text into ram
*/
if (!HAVE_OPT(SAVECONFIGQUIT) && 0 != plock(TXTLOCK))
msyslog(LOG_ERR, "plock(TXTLOCK) error: %m");
# else /* !TXTLOCK follows */
msyslog(LOG_ERR, "plock() - don't know what to lock!");
# endif /* !TXTLOCK */
# endif /* !PROCLOCK */
# endif /* HAVE_PLOCK */
# endif /* !HAVE_MLOCKALL */
}
loop_config(LOOP_DRIFTINIT, 0);
report_event(EVNT_SYSRESTART, NULL, NULL);
initializing = FALSE;
# ifdef HAVE_DROPROOT
if (droproot) {
/* Drop super-user privileges and chroot now if the OS supports this */
# ifdef HAVE_LINUX_CAPABILITIES
/* set flag: keep privileges accross setuid() call (we only really need cap_sys_time): */
if (prctl( PR_SET_KEEPCAPS, 1L, 0L, 0L, 0L ) == -1) {
msyslog( LOG_ERR, "prctl( PR_SET_KEEPCAPS, 1L ) failed: %m" );
exit(-1);
}
# elif HAVE_SOLARIS_PRIVS
/* Nothing to do here */
# else
/* we need a user to switch to */
if (user == NULL) {
msyslog(LOG_ERR, "Need user name to drop root privileges (see -u flag!)" );
exit(-1);
}
# endif /* HAVE_LINUX_CAPABILITIES || HAVE_SOLARIS_PRIVS */
if (user != NULL) {
if (isdigit((unsigned char)*user)) {
sw_uid = (uid_t)strtoul(user, &endp, 0);
if (*endp != '\0')
goto getuser;
if ((pw = getpwuid(sw_uid)) != NULL) {
free(user);
user = estrdup(pw->pw_name);
sw_gid = pw->pw_gid;
} else {
errno = 0;
msyslog(LOG_ERR, "Cannot find user ID %s", user);
exit (-1);
}
} else {
getuser:
errno = 0;
if ((pw = getpwnam(user)) != NULL) {
sw_uid = pw->pw_uid;
sw_gid = pw->pw_gid;
} else {
if (errno)
msyslog(LOG_ERR, "getpwnam(%s) failed: %m", user);
else
msyslog(LOG_ERR, "Cannot find user `%s'", user);
exit (-1);
}
}
}
if (group != NULL) {
if (isdigit((unsigned char)*group)) {
sw_gid = (gid_t)strtoul(group, &endp, 0);
if (*endp != '\0')
goto getgroup;
} else {
getgroup:
if ((gr = getgrnam(group)) != NULL) {
sw_gid = gr->gr_gid;
} else {
errno = 0;
msyslog(LOG_ERR, "Cannot find group `%s'", group);
exit (-1);
}
}
}
if (chrootdir ) {
/* make sure cwd is inside the jail: */
if (chdir(chrootdir)) {
msyslog(LOG_ERR, "Cannot chdir() to `%s': %m", chrootdir);
exit (-1);
}
if (chroot(chrootdir)) {
msyslog(LOG_ERR, "Cannot chroot() to `%s': %m", chrootdir);
exit (-1);
}
if (chdir("/")) {
msyslog(LOG_ERR, "Cannot chdir() to`root after chroot(): %m");
exit (-1);
}
}
# ifdef HAVE_SOLARIS_PRIVS
if ((lowprivs = priv_str_to_set(LOWPRIVS, ",", NULL)) == NULL) {
msyslog(LOG_ERR, "priv_str_to_set() failed:%m");
exit(-1);
}
if ((highprivs = priv_allocset()) == NULL) {
msyslog(LOG_ERR, "priv_allocset() failed:%m");
exit(-1);
}
(void) getppriv(PRIV_PERMITTED, highprivs);
(void) priv_intersect(highprivs, lowprivs);
if (setppriv(PRIV_SET, PRIV_PERMITTED, lowprivs) == -1) {
msyslog(LOG_ERR, "setppriv() failed:%m");
exit(-1);
}
# endif /* HAVE_SOLARIS_PRIVS */
if (user && initgroups(user, sw_gid)) {
msyslog(LOG_ERR, "Cannot initgroups() to user `%s': %m", user);
exit (-1);
}
if (group && setgid(sw_gid)) {
msyslog(LOG_ERR, "Cannot setgid() to group `%s': %m", group);
exit (-1);
}
if (group && setegid(sw_gid)) {
msyslog(LOG_ERR, "Cannot setegid() to group `%s': %m", group);
exit (-1);
}
if (group) {
if (0 != setgroups(1, &sw_gid)) {
msyslog(LOG_ERR, "setgroups(1, %d) failed: %m", sw_gid);
exit (-1);
}
}
else if (pw)
if (0 != initgroups(pw->pw_name, pw->pw_gid)) {
msyslog(LOG_ERR, "initgroups(<%s>, %d) filed: %m", pw->pw_name, pw->pw_gid);
exit (-1);
}
if (user && setuid(sw_uid)) {
msyslog(LOG_ERR, "Cannot setuid() to user `%s': %m", user);
exit (-1);
}
if (user && seteuid(sw_uid)) {
msyslog(LOG_ERR, "Cannot seteuid() to user `%s': %m", user);
exit (-1);
}
# if !defined(HAVE_LINUX_CAPABILITIES) && !defined(HAVE_SOLARIS_PRIVS)
/*
* for now assume that the privilege to bind to privileged ports
* is associated with running with uid 0 - should be refined on
* ports that allow binding to NTP_PORT with uid != 0
*/
disable_dynamic_updates |= (sw_uid != 0); /* also notifies routing message listener */
# endif /* !HAVE_LINUX_CAPABILITIES && !HAVE_SOLARIS_PRIVS */
if (disable_dynamic_updates && interface_interval) {
interface_interval = 0;
msyslog(LOG_INFO, "running as non-root disables dynamic interface tracking");
}
# ifdef HAVE_LINUX_CAPABILITIES
{
/*
* We may be running under non-root uid now, but we still hold full root privileges!
* We drop all of them, except for the crucial one or two: cap_sys_time and
* cap_net_bind_service if doing dynamic interface tracking.
*/
cap_t caps;
char *captext;
captext = (0 != interface_interval)
? "cap_sys_time,cap_net_bind_service=pe"
: "cap_sys_time=pe";
caps = cap_from_text(captext);
if (!caps) {
msyslog(LOG_ERR,
"cap_from_text(%s) failed: %m",
captext);
exit(-1);
}
if (-1 == cap_set_proc(caps)) {
msyslog(LOG_ERR,
"cap_set_proc() failed to drop root privs: %m");
exit(-1);
}
cap_free(caps);
}
# endif /* HAVE_LINUX_CAPABILITIES */
# ifdef HAVE_SOLARIS_PRIVS
if (priv_delset(lowprivs, "proc_setid") == -1) {
msyslog(LOG_ERR, "priv_delset() failed:%m");
exit(-1);
}
if (setppriv(PRIV_SET, PRIV_PERMITTED, lowprivs) == -1) {
msyslog(LOG_ERR, "setppriv() failed:%m");
exit(-1);
}
priv_freeset(lowprivs);
priv_freeset(highprivs);
# endif /* HAVE_SOLARIS_PRIVS */
root_dropped = TRUE;
fork_deferred_worker();
} /* if (droproot) */
# endif /* HAVE_DROPROOT */
/* libssecomp sandboxing */
#if defined (LIBSECCOMP) && (KERN_SECCOMP)
scmp_filter_ctx ctx;
if ((ctx = seccomp_init(SCMP_ACT_KILL)) < 0)
msyslog(LOG_ERR, "%s: seccomp_init(SCMP_ACT_KILL) failed: %m", __func__);
else {
msyslog(LOG_DEBUG, "%s: seccomp_init(SCMP_ACT_KILL) succeeded", __func__);
}
#ifdef __x86_64__
int scmp_sc[] = {
SCMP_SYS(adjtimex),
SCMP_SYS(bind),
SCMP_SYS(brk),
SCMP_SYS(chdir),
SCMP_SYS(clock_gettime),
SCMP_SYS(clock_settime),
SCMP_SYS(close),
SCMP_SYS(connect),
SCMP_SYS(exit_group),
SCMP_SYS(fstat),
SCMP_SYS(fsync),
SCMP_SYS(futex),
SCMP_SYS(getitimer),
SCMP_SYS(getsockname),
SCMP_SYS(ioctl),
SCMP_SYS(lseek),
SCMP_SYS(madvise),
SCMP_SYS(mmap),
SCMP_SYS(munmap),
SCMP_SYS(open),
SCMP_SYS(poll),
SCMP_SYS(read),
SCMP_SYS(recvmsg),
SCMP_SYS(rename),
SCMP_SYS(rt_sigaction),
SCMP_SYS(rt_sigprocmask),
SCMP_SYS(rt_sigreturn),
SCMP_SYS(select),
SCMP_SYS(sendto),
SCMP_SYS(setitimer),
SCMP_SYS(setsid),
SCMP_SYS(socket),
SCMP_SYS(stat),
SCMP_SYS(time),
SCMP_SYS(write),
};
#endif
#ifdef __i386__
int scmp_sc[] = {
SCMP_SYS(_newselect),
SCMP_SYS(adjtimex),
SCMP_SYS(brk),
SCMP_SYS(chdir),
SCMP_SYS(clock_gettime),
SCMP_SYS(clock_settime),
SCMP_SYS(close),
SCMP_SYS(exit_group),
SCMP_SYS(fsync),
SCMP_SYS(futex),
SCMP_SYS(getitimer),
SCMP_SYS(madvise),
SCMP_SYS(mmap),
SCMP_SYS(mmap2),
SCMP_SYS(munmap),
SCMP_SYS(open),
SCMP_SYS(poll),
SCMP_SYS(read),
SCMP_SYS(rename),
SCMP_SYS(rt_sigaction),
SCMP_SYS(rt_sigprocmask),
SCMP_SYS(select),
SCMP_SYS(setitimer),
SCMP_SYS(setsid),
SCMP_SYS(sigprocmask),
SCMP_SYS(sigreturn),
SCMP_SYS(socketcall),
SCMP_SYS(stat64),
SCMP_SYS(time),
SCMP_SYS(write),
};
#endif
{
int i;
for (i = 0; i < COUNTOF(scmp_sc); i++) {
if (seccomp_rule_add(ctx,
SCMP_ACT_ALLOW, scmp_sc[i], 0) < 0) {
msyslog(LOG_ERR,
"%s: seccomp_rule_add() failed: %m",
__func__);
}
}
}
if (seccomp_load(ctx) < 0)
msyslog(LOG_ERR, "%s: seccomp_load() failed: %m",
__func__);
else {
msyslog(LOG_DEBUG, "%s: seccomp_load() succeeded", __func__);
}
#endif /* LIBSECCOMP and KERN_SECCOMP */
# ifdef HAVE_IO_COMPLETION_PORT
for (;;) {
GetReceivedBuffers();
# else /* normal I/O */
BLOCK_IO_AND_ALARM();
was_alarmed = FALSE;
for (;;) {
if (alarm_flag) { /* alarmed? */
was_alarmed = TRUE;
alarm_flag = FALSE;
}
if (!was_alarmed && !has_full_recv_buffer()) {
/*
* Nothing to do. Wait for something.
*/
io_handler();
}
if (alarm_flag) { /* alarmed? */
was_alarmed = TRUE;
alarm_flag = FALSE;
}
if (was_alarmed) {
UNBLOCK_IO_AND_ALARM();
/*
* Out here, signals are unblocked. Call timer routine
* to process expiry.
*/
timer();
was_alarmed = FALSE;
BLOCK_IO_AND_ALARM();
}
# endif /* !HAVE_IO_COMPLETION_PORT */
# ifdef DEBUG_TIMING
{
l_fp pts;
l_fp tsa, tsb;
int bufcount = 0;
get_systime(&pts);
tsa = pts;
# endif
rbuf = get_full_recv_buffer();
while (rbuf != NULL) {
if (alarm_flag) {
was_alarmed = TRUE;
alarm_flag = FALSE;
}
UNBLOCK_IO_AND_ALARM();
if (was_alarmed) {
/* avoid timer starvation during lengthy I/O handling */
timer();
was_alarmed = FALSE;
}
/*
* Call the data procedure to handle each received
* packet.
*/
if (rbuf->receiver != NULL) {
# ifdef DEBUG_TIMING
l_fp dts = pts;
L_SUB(&dts, &rbuf->recv_time);
DPRINTF(2, ("processing timestamp delta %s (with prec. fuzz)\n", lfptoa(&dts, 9)));
collect_timing(rbuf, "buffer processing delay", 1, &dts);
bufcount++;
# endif
(*rbuf->receiver)(rbuf);
} else {
msyslog(LOG_ERR, "fatal: receive buffer callback NULL");
abort();
}
BLOCK_IO_AND_ALARM();
freerecvbuf(rbuf);
rbuf = get_full_recv_buffer();
}
# ifdef DEBUG_TIMING
get_systime(&tsb);
L_SUB(&tsb, &tsa);
if (bufcount) {
collect_timing(NULL, "processing", bufcount, &tsb);
DPRINTF(2, ("processing time for %d buffers %s\n", bufcount, lfptoa(&tsb, 9)));
}
}
# endif
/*
* Go around again
*/
# ifdef HAVE_DNSREGISTRATION
if (mdnsreg && (current_time - mdnsreg ) > 60 && mdnstries && sys_leap != LEAP_NOTINSYNC) {
mdnsreg = current_time;
msyslog(LOG_INFO, "Attempting to register mDNS");
if ( DNSServiceRegister (&mdns, 0, 0, NULL, "_ntp._udp", NULL, NULL,
htons(NTP_PORT), 0, NULL, NULL, NULL) != kDNSServiceErr_NoError ) {
if (!--mdnstries) {
msyslog(LOG_ERR, "Unable to register mDNS, giving up.");
} else {
msyslog(LOG_INFO, "Unable to register mDNS, will try later.");
}
} else {
msyslog(LOG_INFO, "mDNS service registered.");
mdnsreg = FALSE;
}
}
# endif /* HAVE_DNSREGISTRATION */
}
UNBLOCK_IO_AND_ALARM();
return 1;
}
#endif /* !SIM */
#if !defined(SIM) && defined(SIGDIE1)
/*
* finish - exit gracefully
*/
static RETSIGTYPE
finish(
int sig
)
{
const char *sig_desc;
sig_desc = NULL;
#ifdef HAVE_STRSIGNAL
sig_desc = strsignal(sig);
#endif
if (sig_desc == NULL)
sig_desc = "";
msyslog(LOG_NOTICE, "%s exiting on signal %d (%s)", progname,
sig, sig_desc);
/* See Bug 2513 and Bug 2522 re the unlink of PIDFILE */
# ifdef HAVE_DNSREGISTRATION
if (mdns != NULL)
DNSServiceRefDeallocate(mdns);
# endif
peer_cleanup();
exit(0);
}
#endif /* !SIM && SIGDIE1 */
#ifndef SIM
/*
* wait_child_sync_if - implements parent side of -w/--wait-sync
*/
# ifdef HAVE_WORKING_FORK
static int
wait_child_sync_if(
int pipe_read_fd,
long wait_sync
)
{
int rc;
int exit_code;
time_t wait_end_time;
time_t cur_time;
time_t wait_rem;
fd_set readset;
struct timeval wtimeout;
if (0 == wait_sync)
return 0;
/* waitsync_fd_to_close used solely by child */
close(waitsync_fd_to_close);
wait_end_time = time(NULL) + wait_sync;
do {
cur_time = time(NULL);
wait_rem = (wait_end_time > cur_time)
? (wait_end_time - cur_time)
: 0;
wtimeout.tv_sec = wait_rem;
wtimeout.tv_usec = 0;
FD_ZERO(&readset);
FD_SET(pipe_read_fd, &readset);
rc = select(pipe_read_fd + 1, &readset, NULL, NULL,
&wtimeout);
if (-1 == rc) {
if (EINTR == errno)
continue;
exit_code = (errno) ? errno : -1;
msyslog(LOG_ERR,
"--wait-sync select failed: %m");
return exit_code;
}
if (0 == rc) {
/*
* select() indicated a timeout, but in case
* its timeouts are affected by a step of the
* system clock, select() again with a zero
* timeout to confirm.
*/
FD_ZERO(&readset);
FD_SET(pipe_read_fd, &readset);
wtimeout.tv_sec = 0;
wtimeout.tv_usec = 0;
rc = select(pipe_read_fd + 1, &readset, NULL,
NULL, &wtimeout);
if (0 == rc) /* select() timeout */
break;
else /* readable */
return 0;
} else /* readable */
return 0;
} while (wait_rem > 0);
fprintf(stderr, "%s: -w/--wait-sync %ld timed out.\n",
progname, wait_sync);
return ETIMEDOUT;
}
static int
parse (const char *arg, char **path_ret, char **protocol_ret,
char ***server_ret, char **username_ret, char **password_ret)
{
CLEANUP_XMLFREEURI xmlURIPtr uri = NULL;
CLEANUP_FREE char *socket = NULL;
char *path;
uri = xmlParseURI (arg);
if (!uri) {
fprintf (stderr, _("%s: --add: could not parse URI '%s'\n"),
getprogname (), arg);
return -1;
}
/* Note we don't do much checking of the parsed URI, since the
* underlying function 'guestfs_add_drive_opts' will check for us.
* So just the basics here.
*/
if (uri->scheme == NULL || STREQ (uri->scheme, "")) {
/* Probably can never happen. */
fprintf (stderr, _("%s: %s: scheme of URI is NULL or empty\n"),
getprogname (), arg);
return -1;
}
socket = query_get (uri, "socket");
if (uri->server && STRNEQ (uri->server, "") && socket) {
fprintf (stderr, _("%s: %s: cannot both a server name and a socket query parameter\n"),
getprogname (), arg);
return -1;
}
/* Is this needed? XXX
if (socket && socket[0] != '/') {
fprintf (stderr, _("%s: --add %s: socket query parameter must be an absolute path\n"),
getprogname (), arg);
return -1;
}
*/
*protocol_ret = strdup (uri->scheme);
if (*protocol_ret == NULL) {
perror ("strdup: protocol");
return -1;
}
if (make_server (uri, socket, server_ret) == -1) {
free (*protocol_ret);
return -1;
}
*password_ret = NULL;
*username_ret = NULL;
if (uri->user && STRNEQ (uri->user, "")) {
char *p = strchr (uri->user, ':');
if (p != NULL) {
if (STRNEQ (p+1, "")) {
*password_ret = strdup (p+1);
if (*password_ret == NULL) {
perror ("strdup: password");
free (*protocol_ret);
guestfs_int_free_string_list (*server_ret);
return -1;
}
}
*p = '\0';
}
*username_ret = strdup (uri->user);
if (*username_ret == NULL) {
perror ("strdup: username");
free (*password_ret);
free (*protocol_ret);
guestfs_int_free_string_list (*server_ret);
return -1;
}
}
/* We may have to adjust the path depending on the protocol. For
* example ceph/rbd URIs look like rbd:///pool/disk, but the
* exportname expected will be "pool/disk". Here, uri->path will be
* "/pool/disk" so we have to knock off the leading '/' character.
*/
path = uri->path;
if (path && path[0] == '/' &&
(STREQ (uri->scheme, "gluster") ||
STREQ (uri->scheme, "iscsi") ||
STREQ (uri->scheme, "rbd") ||
STREQ (uri->scheme, "sheepdog")))
path++;
*path_ret = strdup (path ? path : "");
if (*path_ret == NULL) {
perror ("strdup: path");
free (*protocol_ret);
guestfs_int_free_string_list (*server_ret);
free (*username_ret);
free (*password_ret);
return -1;
}
return 0;
}
int
main(int argc, char *argv[])
{
/* Check to see if the user is running us as root, which is a nono */
if (!geteuid())
{
fprintf(stderr, "ERROR: This server won't run as root/superuser\n");
return -1;
}
/* Setup corefile size immediately after boot -kre */
setup_corefile();
/* Save server boot time right away, so getrusage works correctly */
set_time();
/* It's not random, but it ought to be a little harder to guess */
init_genrand(SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid() << 20)));
dlinkAdd(&me, &me.node, &global_client_list);
ConfigGeneral.dpath = DPATH;
ConfigGeneral.spath = SPATH;
ConfigGeneral.mpath = MPATH;
ConfigGeneral.configfile = CPATH; /* Server configuration file */
ConfigGeneral.klinefile = KPATH; /* Server kline file */
ConfigGeneral.glinefile = GPATH; /* Server gline file */
ConfigGeneral.xlinefile = XPATH; /* Server xline file */
ConfigGeneral.dlinefile = DLPATH; /* dline file */
ConfigGeneral.resvfile = RESVPATH; /* resv file */
myargv = argv;
umask(077); /* umask 077: u=rwx,g=,o= */
parseargs(&argc, &argv, myopts);
if (printVersion)
{
printf("ircd: version %s(%s)\n", ircd_version, serno);
exit(EXIT_SUCCESS);
}
if (chdir(ConfigGeneral.dpath))
{
perror("chdir");
exit(EXIT_FAILURE);
}
ssl_init();
if (!server_state.foreground)
{
make_daemon();
close_standard_fds(); /* this needs to be before init_netio()! */
}
else
print_startup(getpid());
setup_signals();
/* We need this to initialise the fd array before anything else */
fdlist_init();
log_set_file(LOG_TYPE_IRCD, 0, logFileName);
init_netio(); /* This needs to be setup early ! -- adrian */
/* Check if there is pidfile and daemon already running */
check_pidfile(pidFileName);
mp_pool_init();
init_dlink_nodes();
init_isupport();
dbuf_init();
hash_init();
ipcache_init();
client_init();
class_init();
whowas_init();
watch_init();
auth_init(); /* Initialise the auth code */
init_resolver(); /* Needs to be setup before the io loop */
modules_init();
read_conf_files(1); /* cold start init conf files */
init_uid();
initialize_server_capabs(); /* Set up default_server_capabs */
initialize_global_set_options(); /* Has to be called after read_conf_files() */
channel_init();
read_links_file();
motd_init();
user_usermodes_init();
#ifdef HAVE_LIBGEOIP
geoip_ctx = GeoIP_new(GEOIP_MEMORY_CACHE);
#endif
if (EmptyString(ConfigServerInfo.sid))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server id specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.id, ConfigServerInfo.sid, sizeof(me.id));
if (EmptyString(ConfigServerInfo.name))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server name specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.name, ConfigServerInfo.name, sizeof(me.name));
/* serverinfo{} description must exist. If not, error out.*/
if (EmptyString(ConfigServerInfo.description))
{
ilog(LOG_TYPE_IRCD, "ERROR: No server description specified in serverinfo block.");
exit(EXIT_FAILURE);
}
strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
me.from = &me;
me.servptr = &me;
me.connection->lasttime = CurrentTime;
me.connection->since = CurrentTime;
me.connection->firsttime = CurrentTime;
SetMe(&me);
make_server(&me);
hash_add_id(&me);
hash_add_client(&me);
dlinkAdd(&me, make_dlink_node(), &global_server_list);
load_kline_database();
load_dline_database();
load_gline_database();
load_xline_database();
load_resv_database();
load_all_modules(1);
load_conf_modules();
load_core_modules(1);
write_pidfile(pidFileName);
ilog(LOG_TYPE_IRCD, "Server Ready");
event_addish(&event_cleanup_glines, NULL);
event_addish(&event_cleanup_tklines, NULL);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
event_addish(&event_try_connections, NULL);
/* Setup the timeout check. I'll shift it later :) -- adrian */
event_add(&event_comm_checktimeouts, NULL);
event_addish(&event_save_all_databases, NULL);
if (ConfigServerHide.links_delay > 0)
{
event_write_links_file.when = ConfigServerHide.links_delay;
event_addish(&event_write_links_file, NULL);
}
else
ConfigServerHide.links_disabled = 1;
if (splitmode)
event_addish(&splitmode_event, NULL);
io_loop();
return 0;
}
int
main(int argc, char *argv[])
{
uid_t uid, euid;
int portarg = 0, fd;
#ifdef SAVE_MAXCLIENT_STATS
FILE *mcsfp;
#endif
memset(&me, 0, sizeof(aClient));
if ((timeofday = time(NULL)) == -1)
{
(void) fprintf(stderr, "ERROR: Clock Failure (%d)\n", errno);
exit(errno);
}
build_version();
Count.server = 1; /* us */
Count.oper = 0;
Count.chan = 0;
Count.local = 0;
Count.total = 0;
Count.invisi = 0;
Count.unknown = 0;
Count.max_loc = 0;
Count.max_tot = 0;
Count.today = 0;
Count.weekly = 0;
Count.monthly = 0;
Count.yearly = 0;
Count.start = NOW;
Count.day = NOW;
Count.week = NOW;
Count.month = NOW;
Count.year = NOW;
#ifdef SAVE_MAXCLIENT_STATS
mcsfp=fopen(DPATH "/.maxclients", "r");
if(mcsfp!=NULL) {
fscanf(mcsfp, "%d %d %li %li %li %ld %ld %ld %ld", &Count.max_loc,
&Count.max_tot, &Count.weekly, &Count.monthly, &Count.yearly,
&Count.start, &Count.week, &Count.month, &Count.year);
fclose(mcsfp);
}
#endif
/*
* this code by [email protected]
* it is intended to keep the ircd from being swapped out. BSD
* swapping criteria do not match the requirements of ircd
*/
#ifdef INITIAL_DBUFS
dbuf_init(); /* set up some dbuf stuff to control paging */
#endif
sbrk0 = (char *) sbrk((size_t) 0);
uid = getuid();
euid = geteuid();
#ifdef PROFIL
(void) monstartup(0, etext);
(void) moncontrol(1);
(void) signal(SIGUSR1, s_monitor);
#endif
myargv = argv;
(void) umask(077); /* better safe than sorry --SRB */
memset((char *) &me, '\0', sizeof(me));
setup_signals();
/*
* * All command line parameters have the syntax "-fstring" or "-f
* string" (e.g. the space is optional). String may be empty. Flag
* characters cannot be concatenated (like "-fxyz"), it would
* conflict with the form "-fstring".
*/
while (--argc > 0 && (*++argv)[0] == '-')
{
char *p = argv[0] + 1;
int flag = *p++;
if (flag == '\0' || *p == '\0')
{
if (argc > 1 && argv[1][0] != '-')
{
p = *++argv;
argc -= 1;
}
else
p = "";
}
switch (flag)
{
case 'a':
bootopt |= BOOT_AUTODIE;
break;
case 'c':
bootopt |= BOOT_CONSOLE;
break;
case 'q':
bootopt |= BOOT_QUICK;
break;
case 'd':
(void) setuid((uid_t) uid);
dpath = p;
break;
case 'o': /* Per user local daemon... */
(void) setuid((uid_t) uid);
bootopt |= BOOT_OPER;
break;
#ifdef CMDLINE_CONFIG
case 'f':
(void) setuid((uid_t) uid);
configfile = p;
break;
# ifdef KPATH
case 'k':
(void) setuid((uid_t) uid);
klinefile = p;
break;
# endif
#endif
case 'h':
strncpyzt(me.name, p, sizeof(me.name));
break;
case 'i':
bootopt |= BOOT_INETD | BOOT_AUTODIE;
break;
case 'p':
if ((portarg = atoi(p)) > 0)
portnum = portarg;
break;
case 's':
bootopt |= BOOT_STDERR;
break;
case 't':
(void) setuid((uid_t) uid);
bootopt |= BOOT_TTY;
break;
case 'v':
(void) printf("ircd %s\n", version);
exit(0);
case 'x':
#ifdef DEBUGMODE
(void) setuid((uid_t) uid);
debuglevel = atoi(p);
debugmode = *p ? p : "0";
bootopt |= BOOT_DEBUG;
break;
#else
(void) fprintf(stderr,
"%s: DEBUGMODE must be defined for -x y\n",
myargv[0]);
exit(0);
#endif
default:
bad_command();
break;
}
}
if (chdir(dpath))
{
perror("chdir");
exit(-1);
}
if ((uid != euid) && !euid)
{
(void) fprintf(stderr,
"ERROR: do not run ircd setuid root. Make it setuid a normal user.\n");
exit(-1);
}
if (argc > 0)
return bad_command(); /* This should exit out */
initialize_ssl();
motd = (aMotd *) NULL;
helpfile = (aMotd *) NULL;
motd_tm = NULL;
#ifdef SHORT_MOTD
shortmotd = NULL;
#endif
read_motd(MOTD);
read_help(HELPFILE);
#ifdef SHORT_MOTD
read_shortmotd(SHORTMOTD);
#endif
clear_client_hash_table();
clear_channel_hash_table();
clear_scache_hash_table(); /* server cache name table */
clear_ip_hash_table(); /* client host ip hash table */
initlists();
initclass();
initwhowas();
initstats();
init_tree_parse(msgtab);
init_send();
NOW = time(NULL);
open_debugfile();
NOW = time(NULL);
init_fdlist(&serv_fdlist);
init_fdlist(&oper_fdlist);
init_fdlist(&listen_fdlist);
#ifndef NO_PRIORITY
init_fdlist(&busycli_fdlist);
#endif
init_fdlist(&default_fdlist);
{
int i;
for (i = MAXCONNECTIONS + 1; i > 0; i--)
{
default_fdlist.entry[i] = i - 1;
}
}
if ((timeofday = time(NULL)) == -1)
{
#ifdef USE_SYSLOG
syslog(LOG_WARNING, "Clock Failure (%d), TS can be corrupted", errno);
#endif
sendto_ops("Clock Failure (%d), TS can be corrupted", errno);
}
#ifdef WINGATE_NOTICE
strcpy(ProxyMonURL, "http://");
strncpyzt((ProxyMonURL + 7), DEFAULT_PROXY_INFO_URL, (TOPICLEN + 1) - 7);
strncpyzt(ProxyMonHost, MONITOR_HOST, (HOSTLEN + 1));
#endif
if (portnum < 0)
portnum = PORTNUM;
me.port = portnum;
(void) init_sys();
me.flags = FLAGS_LISTEN;
#ifndef _WIN32
if (bootopt & BOOT_INETD)
{
me.fd = 0;
local[0] = &me;
me.flags = FLAGS_LISTEN;
}
else
#endif
me.fd = -1;
#ifdef USE_SYSLOG
# define SYSLOG_ME "ircd"
openlog(SYSLOG_ME, LOG_PID | LOG_NDELAY, LOG_FACILITY);
#endif
if ((fd = openconf(configfile)) == -1)
{
Debug((DEBUG_FATAL, "Failed in reading configuration file %s",
configfile));
(void) printf("Couldn't open configuration file %s\n",
configfile);
exit(-1);
}
(void) initconf(bootopt, fd);
/* comstuds SEPARATE_QUOTE_KLINES_BY_DATE code */
#ifdef SEPARATE_QUOTE_KLINES_BY_DATE
{
struct tm *tmptr;
char timebuffer[20], filename[200];
tmptr = localtime(&NOW);
(void) strftime(timebuffer, 20, "%y%m%d", tmptr);
ircsprintf(filename, "%s.%s", klinefile, timebuffer);
if ((fd = openconf(filename)) == -1)
{
Debug((DEBUG_ERROR, "Failed reading kline file %s",
filename));
(void) printf("Couldn't open kline file %s\n",
filename);
}
else
(void) initconf(0, fd);
}
#else
# ifdef KPATH
if ((fd = openconf(klinefile)) == -1)
{
Debug((DEBUG_ERROR, "Failed reading kline file %s", klinefile));
(void) printf("Couldn't open kline file %s\n", klinefile);
}
else
(void) initconf(0, fd);
# endif
#endif
if (!(bootopt & BOOT_INETD))
{
static char star[] = "*";
aConfItem *aconf;
u_long vaddr;
if ((aconf = find_me()) && portarg <= 0 && aconf->port > 0)
portnum = aconf->port;
Debug((DEBUG_ERROR, "Port = %d", portnum));
if ((aconf->passwd[0] != '\0') && (aconf->passwd[0] != '*'))
vaddr = inet_addr(aconf->passwd);
else
vaddr = (u_long) NULL;
if (inetport(&me, star, portnum, vaddr))
{
if (bootopt & BOOT_STDERR)
fprintf(stderr, "Couldn't bind to primary port %d\n", portnum);
#ifdef USE_SYSLOG
(void) syslog(LOG_CRIT, "Couldn't bind to primary port %d\n", portnum);
#endif
exit(1);
}
}
else if (inetport(&me, "*", 0, 0))
{
if (bootopt & BOOT_STDERR)
fprintf(stderr, "Couldn't bind to port passed from inetd\n");
#ifdef USE_SYSLOG
(void) syslog(LOG_CRIT, "Couldn't bind to port passed from inetd\n");
#endif
exit(1);
}
(void) get_my_name(&me, me.sockhost, sizeof(me.sockhost) - 1);
if (me.name[0] == '\0')
strncpyzt(me.name, me.sockhost, sizeof(me.name));
me.hopcount = 0;
me.authfd = -1;
me.confs = NULL;
me.next = NULL;
me.user = NULL;
me.from = &me;
SetMe(&me);
make_server(&me);
me.serv->up = me.name;
me.lasttime = me.since = me.firsttime = NOW;
(void) add_to_client_hash_table(me.name, &me);
/* We don't want to calculate these every time they are used :) */
sprintf(REPORT_DO_DNS, REPORT_DO_DNS_, me.name);
sprintf(REPORT_FIN_DNS, REPORT_FIN_DNS_, me.name);
sprintf(REPORT_FIN_DNSC, REPORT_FIN_DNSC_, me.name);
sprintf(REPORT_FAIL_DNS, REPORT_FAIL_DNS_, me.name);
sprintf(REPORT_DO_ID, REPORT_DO_ID_, me.name);
sprintf(REPORT_FIN_ID, REPORT_FIN_ID_, me.name);
sprintf(REPORT_FAIL_ID, REPORT_FAIL_ID_, me.name);
R_do_dns = strlen(REPORT_DO_DNS);
R_fin_dns = strlen(REPORT_FIN_DNS);
R_fin_dnsc = strlen(REPORT_FIN_DNSC);
R_fail_dns = strlen(REPORT_FAIL_DNS);
R_do_id = strlen(REPORT_DO_ID);
R_fin_id = strlen(REPORT_FIN_ID);
R_fail_id = strlen(REPORT_FAIL_ID);
check_class();
if (bootopt & BOOT_OPER)
{
aClient *tmp = add_connection(&me, 0);
if (!tmp)
exit(1);
SetMaster(tmp);
}
else
write_pidfile();
Debug((DEBUG_NOTICE, "Server ready..."));
#ifdef USE_SYSLOG
syslog(LOG_NOTICE, "Server Ready");
#endif
NOW = time(NULL);
#ifndef NO_PRIORITY
check_fdlists();
#endif
if ((timeofday = time(NULL)) == -1)
{
#ifdef USE_SYSLOG
syslog(LOG_WARNING, "Clock Failure (%d), TS can be corrupted", errno);
#endif
sendto_ops("Clock Failure (%d), TS can be corrupted", errno);
}
#ifdef DUMP_DEBUG
dumpfp=fopen("dump.log", "w");
#endif
io_loop();
return 0;
}
/** Run the daemon.
* @param[in] argc Number of arguments in \a argv.
* @param[in] argv Arguments to program execution.
*/
int main(int argc, char **argv) {
CurrentTime = time(NULL);
thisServer.argc = argc;
thisServer.argv = argv;
thisServer.uid = getuid();
thisServer.euid = geteuid();
#ifdef MDEBUG
mem_dbg_initialise();
#endif
#if defined(HAVE_SETRLIMIT) && defined(RLIMIT_CORE)
set_core_limit();
#endif
umask(077); /* better safe than sorry --SRB */
memset(&me, 0, sizeof(me));
memset(&me_con, 0, sizeof(me_con));
cli_connect(&me) = &me_con;
cli_fd(&me) = -1;
parse_command_line(argc, argv);
if (chdir(dpath)) {
fprintf(stderr, "Fail: Cannot chdir(%s): %s, check DPATH\n", dpath, strerror(errno));
return 2;
}
if (!set_userid_if_needed())
return 3;
/* Check paths for accessibility */
if (!check_file_access(SPATH, 'S', X_OK) ||
!check_file_access(configfile, 'C', R_OK))
return 4;
if (!init_connection_limits())
return 9;
close_connections(!(thisServer.bootopt & (BOOT_DEBUG | BOOT_TTY | BOOT_CHKCONF)));
/* daemon_init() must be before event_init() because kqueue() FDs
* are, perversely, not inherited across fork().
*/
daemon_init(thisServer.bootopt & BOOT_TTY);
#ifdef DEBUGMODE
/* Must reserve fd 2... */
if (debuglevel >= 0 && !(thisServer.bootopt & BOOT_TTY)) {
int fd;
if ((fd = open("/dev/null", O_WRONLY)) < 0) {
fprintf(stderr, "Unable to open /dev/null (to reserve fd 2): %s\n",
strerror(errno));
return 8;
}
if (fd != 2 && dup2(fd, 2) < 0) {
fprintf(stderr, "Unable to reserve fd 2; dup2 said: %s\n",
strerror(errno));
return 8;
}
}
#endif
event_init(MAXCONNECTIONS);
setup_signals();
feature_init(); /* initialize features... */
log_init(*argv);
set_nomem_handler(outofmemory);
initload();
init_list();
init_hash();
init_class();
initwhowas();
initmsgtree();
initstats();
/* we need this for now, when we're modular this
should be removed -- hikari */
ircd_crypt_init();
motd_init();
if (!init_conf()) {
log_write(LS_SYSTEM, L_CRIT, 0, "Failed to read configuration file %s",
configfile);
return 7;
}
if (thisServer.bootopt & BOOT_CHKCONF) {
if (dbg_client)
conf_debug_iline(dbg_client);
fprintf(stderr, "Configuration file %s checked okay.\n", configfile);
return 0;
}
debug_init(thisServer.bootopt & BOOT_TTY);
if (check_pid()) {
Debug((DEBUG_FATAL, "Failed to acquire PID file lock after fork"));
exit(2);
}
init_server_identity();
uping_init();
stats_init();
IPcheck_init();
timer_add(timer_init(&connect_timer), try_connections, 0, TT_RELATIVE, 1);
timer_add(timer_init(&ping_timer), check_pings, 0, TT_RELATIVE, 1);
timer_add(timer_init(&destruct_event_timer), exec_expired_destruct_events, 0, TT_PERIODIC, 60);
timer_add(timer_init(&mute_timer), check_expired_mutes, 0, TT_PERIODIC, 30);
CurrentTime = time(NULL);
SetMe(&me);
cli_magic(&me) = CLIENT_MAGIC;
cli_from(&me) = &me;
make_server(&me);
cli_serv(&me)->timestamp = TStime(); /* Abuse own link timestamp as start TS */
cli_serv(&me)->prot = atoi(MAJOR_PROTOCOL);
cli_serv(&me)->up = &me;
cli_serv(&me)->down = NULL;
cli_handler(&me) = SERVER_HANDLER;
SetYXXCapacity(&me, MAXCLIENTS);
cli_lasttime(&me) = cli_since(&me) = cli_firsttime(&me) = CurrentTime;
hAddClient(&me);
write_pidfile();
init_counters();
Debug((DEBUG_NOTICE, "Server ready..."));
log_write(LS_SYSTEM, L_NOTICE, 0, "Server Ready");
event_loop();
return 0;
}
int ssl_a(char *cookie) {
int s;
struct sockaddr_in server;
char *content_length, *content_length2, *content_length3;
int kkk = 0;
int cc, lc;
char buf[BUF_LEN];
SSL *ssl;
SSL_CTX *ctx;
char request[BUF_LEN];
char *host = "p.eagate.573.jp";
char *origin_path = "/gate/p/login.html";
char path[BUF_LEN];
FILE *tmp_fp;
make_server(host, &server, "https", 443);
strcpy(path, origin_path);
SSL_load_error_strings();
SSL_library_init();
ctx = SSL_CTX_new(SSLv23_client_method());
if(ctx == NULL) {
ERR_print_errors_fp(stderr);
exit(1);
}
ssl = SSL_new(ctx);
if(ssl == NULL) {
ERR_print_errors_fp(stderr);
exit(1);
}
s = connect_ssl_server(&server, ssl);
sprintf(request,
"HEAD %s HTTP/1.0\r\n"
"Host: %s\r\n"
"%s\r\n"
"\r\n",
path, host, BOT_UA);
if((tmp_fp = tmpfile()) == NULL) {
print_line("tmpfile");
exit(1);
}
ssl_put_and_get(s, ssl, request, tmp_fp);
while(1) {
if(fgets(buf, sizeof(buf), tmp_fp) == NULL) {
print_line("");
exit(1);
}
fputs(buf, stdout);
if(buf[0] == '\r' && buf[1] == '\n') {
print_line("Cookie not found");
exit(1);
}
if((content_length = strstr(buf, "Set-Cookie: ")) != '\0') {
content_length += strlen("Set-Cookie: ");
content_length2 = strstr(content_length, ";");
*content_length2 = '\0';
strcpy(cookie, content_length);
break;
}
}
fclose(tmp_fp);
s = connect_ssl_server(&server, ssl);
sprintf(request,
"POST %s HTTP/1.0\r\n"
"Host: %s\r\n"
"%s\r\n"
"Cookie: %s\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"Content-Length: %d\r\n"
"\r\n"
"%s\r\n",
path, host, BOT_UA, cookie, strlen(ea_user), ea_user);
if((tmp_fp = tmpfile()) == NULL) {
print_line("tmpfile");
exit(1);
}
ssl_put_and_get(s, ssl, request, tmp_fp);
if(fgets(buf, sizeof(buf), tmp_fp) == NULL) {
print_line("");
exit(1);
//return 1;
}
fputs(buf, stdout);
while(buf[9] == '3' && buf[10] == '0' && buf[11] == '2') {
cc = 1;
lc = 1;
while(cc | lc) {
if(fgets(buf, sizeof(buf), tmp_fp) == NULL) {
print_line("");
exit(1);
}
fputs(buf, stdout);
if(buf[0] == '\r' && buf[1] == '\n') {
print_line("Location not found");
return 1;
}
if((content_length = strstr(buf, "Location: ")) != '\0') {
content_length += strlen("Location: ");
if((content_length3 = strchr(content_length, ':')) != '\0') {
content_length3 += 3; /* :の後は//なのでそこを飛ばす */
}
content_length = strchr(content_length3, '/');
content_length2 = strstr(content_length, "\r\n");
*content_length2 = '\0';
strcpy(path, content_length);
lc = 0;
}
if((content_length = strstr(buf, "Set-Cookie: ")) != '\0') {
content_length += strlen("Set-Cookie: ");
content_length2 = strstr(content_length, ";");
*content_length2 = '\0';
strcpy(cookie, content_length);
cc = 0;
}
}
fclose(tmp_fp);
if((strstr(path, "login_complete.html")) != '\0') {
kkk = 1;
break;
}
s = connect_ssl_server(&server, ssl);
sprintf(request,
"GET %s HTTP/1.0\r\n"
"Host: %s\r\n"
"%s\r\n"
"Cookie: %s\r\n"
"\r\n",
path, host, BOT_UA, cookie);
if((tmp_fp = tmpfile()) == NULL) {
print_line("tmpfile");
exit(1);
}
fprintf(stdout, "認証サーバからのレスポンス\n");
ssl_put_and_get(s, ssl, request, tmp_fp);
if(fgets(buf, sizeof(buf), tmp_fp) == NULL) {
print_line("");
exit(1);
//return 1;
}
fputs(buf, stdout);
}
if(kkk) {
fprintf(stdout, "\n\nCookieを取得\n%s\n", cookie);
}
else {
while(fgets(buf, sizeof(buf), tmp_fp) != NULL) {
fputs(buf, stdout);
}
fclose(tmp_fp);
print_line("認証失敗");
exit(1);
}
SSL_free(ssl);
SSL_CTX_free(ctx);
ERR_free_strings();
return kkk;
}
/*
* ms_server - SERVER message handler
* parv[0] = sender prefix
* parv[1] = servername
* parv[2] = serverinfo/hopcount
* parv[3] = serverinfo
*/
static void ms_server(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
char info[REALLEN + 1];
/* same size as in s_misc.c */
char* name;
struct Client* target_p;
struct Client* bclient_p;
struct ConfItem* aconf;
int hop;
int hlined = 0;
int llined = 0;
dlink_node *ptr;
/* Just to be sure -A1kmm. */
if (!IsServer(source_p))
return;
if (parc < 4)
{
sendto_one(client_p,"ERROR :No servername");
return;
}
name = parv[1];
hop = atoi(parv[2]);
strlcpy(info, parv[3], REALLEN);
if ((target_p = server_exists(name)))
{
/*
* This link is trying feed me a server that I already have
* access through another path -- multiple paths not accepted
* currently, kill this link immediately!!
*
* Rather than KILL the link which introduced it, KILL the
* youngest of the two links. -avalon
*
* I think that we should exit the link itself, not the introducer,
* and we should always exit the most recently received(i.e. the
* one we are receiving this SERVER for. -A1kmm
*
* You *cant* do this, if you link somewhere, it bursts you a server
* that already exists, then sends you a client burst, you squit the
* server, but you keep getting the burst of clients on a server that
* doesnt exist, although ircd can handle it, its not a realistic
* solution.. --fl_
*/
/* It is behind a host-masked server. Completely ignore the
* server message(don't propagate or we will delink from whoever
* we propagate to). -A1kmm */
if (irccmp(target_p->name, name) && target_p->from==client_p)
return;
sendto_one(client_p, "ERROR :Server %s already exists", name);
sendto_realops_flags(FLAGS_ALL, L_ADMIN,
"Link %s cancelled, server %s already exists",
get_client_name(client_p, SHOW_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Link %s cancelled, server %s already exists",
client_p->name, name);
exit_client(client_p, client_p, &me, "Server Exists");
return;
}
/*
* User nicks never have '.' in them and server names
* must always have '.' in them.
*/
if (strchr(name,'.') == NULL)
{
/*
* Server trying to use the same name as a person. Would
* cause a fair bit of confusion. Enough to make it hellish
* for a while and servers to send stuff to the wrong place.
*/
sendto_one(client_p,"ERROR :Nickname %s already exists!", name);
sendto_realops_flags(FLAGS_ALL, L_ADMIN,
"Link %s cancelled: Server/nick collision on %s",
/* inpath */ get_client_name(client_p, HIDE_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Link %s cancelled: Server/nick collision on %s",
get_client_name(client_p, MASK_IP), name);
exit_client(client_p, client_p, client_p, "Nick as Server");
return;
}
/*
* Server is informing about a new server behind
* this link. Create REMOTE server structure,
* add it to list and propagate word to my other
* server links...
*/
if (parc == 1 || info[0] == '\0')
{
sendto_one(client_p, "ERROR :No server info specified for %s", name);
return;
}
/*
* See if the newly found server is behind a guaranteed
* leaf. If so, close the link.
*
*/
for (aconf = ConfigItemList; aconf; aconf=aconf->next)
{
if ((aconf->status & (CONF_LEAF|CONF_HUB)) == 0)
continue;
if (match(aconf->name, client_p->name))
{
if (aconf->status == CONF_HUB)
{
if(match(aconf->host, name))
hlined++;
}
else if (aconf->status == CONF_LEAF)
{
if(match(aconf->host, name))
llined++;
}
}
}
/* Ok, this way this works is
*
* A server can have a CONF_HUB allowing it to introduce servers
* behind it.
*
* connect {
* name = "irc.bighub.net";
* hub_mask="*";
* ...
*
* That would allow "irc.bighub.net" to introduce anything it wanted..
*
* However
*
* connect {
* name = "irc.somehub.fi";
* hub_mask="*";
* leaf_mask="*.edu";
*...
* Would allow this server in finland to hub anything but
* .edu's
*/
/* Ok, check client_p can hub the new server, and make sure it's not a LL */
if (!hlined || (IsCapable(client_p, CAP_LL) && !IsCapable(client_p, CAP_HUB)))
{
/* OOOPs nope can't HUB */
sendto_realops_flags(FLAGS_ALL, L_ADMIN, "Non-Hub link %s introduced %s.",
get_client_name(client_p, HIDE_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Non-Hub link %s introduced %s.",
get_client_name(client_p, MASK_IP), name);
exit_client(NULL, source_p, &me, "No matching hub_mask.");
return;
}
/* Check for the new server being leafed behind this HUB */
if (llined)
{
/* OOOPs nope can't HUB this leaf */
sendto_realops_flags(FLAGS_ALL, L_ADMIN,
"Link %s introduced leafed server %s.",
get_client_name(client_p, HIDE_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Link %s introduced leafed server %s.",
client_p->name, name);
/* If it is new, we are probably misconfigured, so split the
* non-hub server introducing this. Otherwise, split the new
* server. -A1kmm.
*/
/* wastes too much bandwidth, generates too many errors on
* larger networks, dont bother. --fl_
*/
#if 0
if ((CurrentTime - source_p->firsttime) < 20)
{
exit_client(NULL, source_p, &me, "Leafed Server.");
return;
}
else
{
sendto_one(source_p, ":%s SQUIT %s :Sorry, Leafed server.",
me.name, name);
return;
}
#endif
exit_client(NULL, client_p, &me, "Leafed Server.");
return;
}
if(strlen(name) > HOSTLEN)
{
sendto_realops_flags(FLAGS_ALL, L_ADMIN,
"Link %s introduced server with invalid servername %s",
get_client_name(client_p, HIDE_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Link %s introduced server with invalid servername %s",
client_p->name, name);
exit_client(NULL, client_p, &me, "Invalid servername introduced.");
return;
}
target_p = make_client(client_p);
make_server(target_p);
target_p->hopcount = hop;
strlcpy(target_p->name, name, HOSTLEN+1);
set_server_gecos(target_p, info);
target_p->serv->up = find_or_add(parv[0]);
target_p->servptr = source_p;
SetServer(target_p);
Count.server++;
add_client_to_list(target_p);
add_server_to_list(target_p);
add_to_client_hash_table(target_p->name, target_p);
add_client_to_llist(&(target_p->servptr->serv->servers), target_p);
/*
* Old sendto_serv_but_one() call removed because we now
* need to send different names to different servers
* (domain name matching)
*/
for (ptr = serv_list.head; ptr; ptr = ptr->next)
{
bclient_p = ptr->data;
if (bclient_p == client_p)
continue;
if (!(aconf = bclient_p->serv->sconf))
{
sendto_realops_flags(FLAGS_ALL, L_ADMIN,
"Lost N-line for %s on %s. Closing",
get_client_name(client_p, HIDE_IP), name);
sendto_realops_flags(FLAGS_ALL, L_OPER,
"Lost N-line for %s on %s. Closing",
get_client_name(client_p, MASK_IP), name);
exit_client(client_p, client_p, client_p, "Lost N line");
return;
}
if (match(my_name_for_link(me.name, aconf), target_p->name))
continue;
sendto_one(bclient_p, ":%s SERVER %s %d :%s%s",
parv[0], target_p->name, hop + 1,
target_p->hidden_server ? "(H) " : "",
target_p->info);
}
if (!IsRelay(target_p))
sendto_realops_flags(FLAGS_EXTERNAL, L_ALL,
"Server %s being introduced by %s",
target_p->name, source_p->name);
}
/** Start a connection to another server.
* @param aconf Connect block data for target server.
* @param by Client who requested the connection (if any).
* @return Non-zero on success; zero on failure.
*/
int connect_server(struct ConfItem* aconf, struct Client* by)
{
struct Client* cptr = 0;
assert(0 != aconf);
if (aconf->dns_pending) {
sendto_opmask_butone(0, SNO_OLDSNO, "Server %s connect DNS pending",
aconf->name);
return 0;
}
Debug((DEBUG_NOTICE, "Connect to %s[@%s]", aconf->name,
ircd_ntoa(&aconf->address.addr)));
if ((cptr = FindClient(aconf->name))) {
if (IsServer(cptr) || IsMe(cptr)) {
sendto_opmask_butone(0, SNO_OLDSNO, "Server %s already present from %s",
aconf->name, cli_name(cli_from(cptr)));
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Server %s already present "
"from %s", by, aconf->name, cli_name(cli_from(cptr)));
}
return 0;
}
else if (IsHandshake(cptr) || IsConnecting(cptr)) {
if (by && IsUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connection to %s already in "
"progress", by, cli_name(cptr));
}
return 0;
}
}
/*
* If we don't know the IP# for this host and it is a hostname and
* not a ip# string, then try and find the appropriate host record.
*/
if (!irc_in_addr_valid(&aconf->address.addr)
&& !ircd_aton(&aconf->address.addr, aconf->host)) {
char buf[HOSTLEN + 1];
host_from_uh(buf, aconf->host, HOSTLEN);
gethost_byname(buf, connect_dns_callback, aconf);
aconf->dns_pending = 1;
return 0;
}
cptr = make_client(NULL, STAT_UNKNOWN_SERVER);
/*
* Copy these in so we have something for error detection.
*/
ircd_strncpy(cli_name(cptr), aconf->name, HOSTLEN);
ircd_strncpy(cli_sockhost(cptr), aconf->host, HOSTLEN);
/*
* Attach config entries to client here rather than in
* completed_connection. This to avoid null pointer references
*/
attach_confs_byhost(cptr, aconf->host, CONF_SERVER);
if (!find_conf_byhost(cli_confs(cptr), aconf->host, CONF_SERVER)) {
sendto_opmask_butone(0, SNO_OLDSNO, "Host %s is not enabled for "
"connecting: no Connect block", aconf->name);
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connect to host %s failed: no "
"Connect block", by, aconf->name);
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* attempt to connect to the server in the conf line
*/
if (!connect_inet(aconf, cptr)) {
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Couldn't connect to %s", by,
cli_name(cptr));
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* NOTE: if we're here we have a valid C:Line and the client should
* have started the connection and stored the remote address/port and
* ip address name in itself
*
* The socket has been connected or connect is in progress.
*/
make_server(cptr);
if (by && IsUser(by)) {
ircd_snprintf(0, cli_serv(cptr)->by, sizeof(cli_serv(cptr)->by), "%s%s",
NumNick(by));
assert(0 == cli_serv(cptr)->user);
cli_serv(cptr)->user = cli_user(by);
cli_user(by)->refcnt++;
}
else {
*(cli_serv(cptr))->by = '\0';
/* strcpy(cptr->serv->by, "Auto"); */
}
cli_serv(cptr)->up = &me;
SetConnecting(cptr);
if (cli_fd(cptr) > HighestFd)
HighestFd = cli_fd(cptr);
LocalClientArray[cli_fd(cptr)] = cptr;
Count_newunknown(UserStats);
/* Actually we lie, the connect hasn't succeeded yet, but we have a valid
* cptr, so we register it now.
* Maybe these two calls should be merged.
*/
add_client_to_list(cptr);
hAddClient(cptr);
/* nextping = CurrentTime; */
return (s_state(&cli_socket(cptr)) == SS_CONNECTED) ?
completed_connection(cptr) : 1;
}
/** Handle a SERVER message from an unregistered connection.
*
* \a parv has the following elements:
* \li \a parv[1] is the server name
* \li \a parv[2] is the hop count to the server
* \li \a parv[3] is the start timestamp for the server
* \li \a parv[4] is the link timestamp
* \li \a parv[5] is the protocol version (P10 or J10)
* \li \a parv[6] is the numnick mask for the server
* \li \a parv[7] is a string of flags like +hs to mark hubs and services
* \li \a parv[\a parc - 1] is the server description
*
* See @ref m_functions for discussion of the arguments.
* @param[in] cptr Client that sent us the message.
* @param[in] sptr Original source of message.
* @param[in] parc Number of arguments.
* @param[in] parv Argument vector.
*/
int mr_server(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
char* host;
struct ConfItem* aconf;
struct Jupe* ajupe;
unsigned int hop;
int ret;
unsigned short prot;
time_t start_timestamp;
time_t timestamp;
time_t recv_time;
time_t ghost;
if (IsUserPort(cptr))
return exit_client_msg(cptr, cptr, &me,
"Cannot connect a server to a user port");
if (parc < 8)
{
need_more_params(sptr, "SERVER");
return exit_client(cptr, cptr, &me, "Need more parameters");
}
host = clean_servername(parv[1]);
if (!host)
{
sendto_opmask(0, SNO_OLDSNO, "Bogus server name (%s) from %s",
host, cli_name(cptr));
return exit_client_msg(cptr, cptr, &me, "Bogus server name (%s)", host);
}
if ((ajupe = jupe_find(host)) && JupeIsActive(ajupe))
return exit_client_msg(cptr, sptr, &me, "Juped: %s", JupeReason(ajupe));
/* check connection rules */
if (0 != conf_eval_crule(host, CRULE_ALL)) {
ServerStats->is_ref++;
sendto_opmask(0, SNO_OLDSNO, "Refused connection from %s.", cli_name(cptr));
return exit_client(cptr, cptr, &me, "Disallowed by connection rule");
}
log_write(LS_NETWORK, L_NOTICE, LOG_NOSNOTICE, "SERVER: %s %s[%s]", host,
cli_sockhost(cptr), cli_sock_ip(cptr));
/*
* Detect protocol
*/
hop = atoi(parv[2]);
start_timestamp = atoi(parv[3]);
timestamp = atoi(parv[4]);
prot = parse_protocol(parv[5]);
if (!prot)
return exit_client_msg(cptr, sptr, &me, "Bogus protocol (%s)", parv[5]);
else if (prot < atoi(MINOR_PROTOCOL))
return exit_new_server(cptr, sptr, host, timestamp,
"Incompatible protocol: %s", parv[5]);
Debug((DEBUG_INFO, "Got SERVER %s with timestamp [%s] age %Tu (%Tu)",
host, parv[4], start_timestamp, cli_serv(&me)->timestamp));
if (timestamp < OLDEST_TS || start_timestamp < OLDEST_TS)
return exit_client_msg(cptr, sptr, &me,
"Bogus timestamps (%s %s)", parv[3], parv[4]);
/* If the server had a different name before, change it. */
if (!EmptyString(cli_name(cptr)) &&
(IsUnknown(cptr) || IsHandshake(cptr)) &&
0 != ircd_strcmp(cli_name(cptr), host))
hChangeClient(cptr, host);
ircd_strncpy(cli_name(cptr), host, HOSTLEN);
ircd_strncpy(cli_info(cptr), parv[parc-1][0] ? parv[parc-1] : cli_name(&me), REALLEN);
cli_hopcount(cptr) = hop;
if (conf_check_server(cptr)) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Received unauthorized connection from %s",
cli_name(cptr));
log_write(LS_NETWORK, L_NOTICE, LOG_NOSNOTICE, "Received unauthorized "
"connection from %C [%s]", cptr,
ircd_ntoa(&cli_ip(cptr)));
return exit_client(cptr, cptr, &me, "No Connect block");
}
host = cli_name(cptr);
update_load();
if (!(aconf = find_conf_byname(cli_confs(cptr), host, CONF_SERVER))) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied. No conf line for server %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"Access denied. No conf line for server %s", cli_name(cptr));
}
#if defined(USE_SSL)
if (!verify_sslclifp(cptr, aconf)) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied (SSL fingerprint mismatch) %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"No Access (SSL fingerprint mismatch) %s", cli_name(cptr));
}
#endif
if (*aconf->passwd && !!strcmp(aconf->passwd, cli_passwd(cptr))) {
++ServerStats->is_ref;
sendto_opmask(0, SNO_OLDSNO, "Access denied (passwd mismatch) %s",
cli_name(cptr));
return exit_client_msg(cptr, cptr, &me,
"No Access (passwd mismatch) %s", cli_name(cptr));
}
memset(cli_passwd(cptr), 0, sizeof(cli_passwd(cptr)));
ret = check_loop_and_lh(cptr, sptr, &ghost, host, (parc > 7 ? parv[6] : NULL), timestamp, hop, 1);
if (ret != 1)
return ret;
make_server(cptr);
cli_serv(cptr)->timestamp = timestamp;
cli_serv(cptr)->prot = prot;
cli_serv(cptr)->ghost = ghost;
memset(cli_privs(cptr), 255, sizeof(struct Privs));
ClrPriv(cptr, PRIV_SET);
SetServerYXX(cptr, cptr, parv[6]);
update_uworld_flags(cptr);
if (*parv[7] == '+')
set_server_flags(cptr, parv[7] + 1);
recv_time = TStime();
check_start_timestamp(cptr, timestamp, start_timestamp, recv_time);
ret = server_estab(cptr, aconf);
if (feature_bool(FEAT_RELIABLE_CLOCK) &&
abs(cli_serv(cptr)->timestamp - recv_time) > 30) {
sendto_opmask(0, SNO_OLDSNO, "Connected to a net with a "
"timestamp-clock difference of %Td seconds! "
"Used SETTIME to correct this.",
timestamp - recv_time);
sendcmdto_prio_one(&me, CMD_SETTIME, cptr, "%Tu :%s", TStime(),
cli_name(&me));
}
return ret;
}
u_entity *u_entity_from_server(u_entity *e, u_server *sv)
{
e->v.sv = sv;
make_server(e);
return e;
}
int main(int argc, char *argv[])
{
time_t delay = 0;
aConfItem* aconf;
if(geteuid() == 0)
{
fprintf(stderr, "ERROR: Don't run ircd as root!\n");
return -1;
}
/*
* save server boot time right away, so getrusage works correctly
*/
if ((CurrentTime = time(0)) == -1)
{
fprintf(stderr, "ERROR: Clock Failure: %s\n", strerror(errno));
exit(errno);
}
/*
* Setup corefile size immediately after boot
*/
setup_corefile();
/*
* set initialVMTop before we allocate any memory
*/
initialVMTop = get_vm_top();
/*
* Initialize the Blockheap allocator
*/
initBlockHeap();
ServerRunning = 0;
memset(&me, 0, sizeof(me));
GlobalClientList = &me; /* Pointer to beginning of Client list */
cold_start = YES; /* set when server first starts up */
memset(&Count, 0, sizeof(Count));
Count.server = 1; /* us */
initialize_global_set_options();
#ifdef REJECT_HOLD
reject_held_fds = 0;
#endif
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
#ifdef KPATH
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
#else
ConfigFileEntry.klinefile = CPATH;
#endif /* KPATH */
#ifdef DLPATH
ConfigFileEntry.dlinefile = DLPATH;
#else
ConfigFileEntry.dlinefile = CPATH;
#endif /* DLPATH */
#ifdef GLINES
ConfigFileEntry.glinefile = GLINEFILE;
#endif
#ifdef ZIP_LINKS
/* Make sure the include files match the library version number. */
/* configure takes care of looking for zlib and zlibVersion(). */
if (strcmp(zlibVersion(), ZLIB_VERSION) != 0)
{
fprintf(stderr, "WARNING: zlib include files differ from library.\n");
fprintf(stderr, "WARNING: ZIPLINKS may fail!\n");
fprintf(stderr, "WARNING: library %s, include files %s\n",
zlibVersion(), ZLIB_VERSION);
}
#endif
myargv = argv;
umask(077); /* better safe than sorry --SRB */
parse_command_line(argc, argv);
if (chdir(ConfigFileEntry.dpath))
{
perror("chdir");
exit(-1);
}
/*
* Check if daemon is already running
*/
check_pidfile();
init_sys(bootDaemon);
init_log(logFileName);
setup_signals();
initialize_message_files();
isupport = make_isupport();
dbuf_init(); /* set up some dbuf stuff to control paging */
init_hash();
clear_scache_hash_table(); /* server cache name table */
clear_ip_hash_table(); /* client host ip hash table */
clear_Dline_table(); /* d line tree */
initlists();
initclass();
initwhowas();
init_stats();
init_tree_parse(msgtab); /* tree parse code (orabidoo) */
fdlist_init();
init_netio();
read_conf_files(YES); /* cold start init conf files */
aconf = find_me();
if (EmptyString(me.name))
strncpy_irc(me.name, aconf->host, HOSTLEN);
strncpy_irc(me.host, aconf->host, HOSTLEN);
me.fd = -1;
me.from = &me;
me.servptr = &me;
SetMe(&me);
make_server(&me);
me.serv->up = me.name;
me.lasttime = me.since = me.firsttime = CurrentTime;
add_to_client_hash_table(me.name, &me);
check_class();
write_pidfile();
log(L_NOTICE, "Server Ready");
ServerRunning = 1;
while (ServerRunning) {
usleep(100000);
do_adns_io();
delay = io_loop(delay);
do_adns_io();
}
return 0;
}
/** Read a 'packet' of data from a connection and process it. Read in
* 8k chunks to give a better performance rating (for server
* connections). Do some tricky stuff for client connections to make
* sure they don't do any flooding >:-) -avalon
* @param cptr Client from which to read data.
* @param socket_ready If non-zero, more data can be read from the client's socket.
* @return Positive number on success, zero on connection-fatal failure, negative
* if user is killed.
*/
static int read_packet(struct Client *cptr, int socket_ready)
{
unsigned int dolen = 0;
unsigned int length = 0;
if (socket_ready &&
!(IsUser(cptr) &&
DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD))) {
#if defined(USE_SSL)
switch (client_recv(cptr, readbuf, sizeof(readbuf), &length)) {
#else
switch (os_recv_nonb(cli_fd(cptr), readbuf, sizeof(readbuf), &length)) {
#endif
case IO_SUCCESS:
if (length)
{
cli_lasttime(cptr) = CurrentTime;
ClearPingSent(cptr);
ClrFlag(cptr, FLAG_NONL);
if (cli_lasttime(cptr) > cli_since(cptr))
cli_since(cptr) = cli_lasttime(cptr);
}
break;
case IO_BLOCKED:
break;
case IO_FAILURE:
cli_error(cptr) = errno;
/* SetFlag(cptr, FLAG_DEADSOCKET); */
return 0;
}
}
/*
* For server connections, we process as many as we can without
* worrying about the time of day or anything :)
*/
if (length > 0 && IsServer(cptr))
return server_dopacket(cptr, readbuf, length);
else if (length > 0 && (IsHandshake(cptr) || IsConnecting(cptr)))
return connect_dopacket(cptr, readbuf, length);
else
{
/*
* Before we even think of parsing what we just read, stick
* it on the end of the receive queue and do it when its
* turn comes around.
*/
if (length > 0 && dbuf_put(cptr, &(cli_recvQ(cptr)), readbuf, length) == 0)
return exit_client(cptr, cptr, &me, "dbuf_put fail");
if ((DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD))
&& !IsChannelService(cptr))
return exit_client(cptr, cptr, &me, "Excess Flood");
while (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) &&
(IsTrusted(cptr) || IsChannelService(cptr) || cli_since(cptr) - CurrentTime < 10))
{
dolen = dbuf_getmsg(&(cli_recvQ(cptr)), cli_buffer(cptr), BUFSIZE);
/*
* Devious looking...whats it do ? well..if a client
* sends a *long* message without any CR or LF, then
* dbuf_getmsg fails and we pull it out using this
* loop which just gets the next 512 bytes and then
* deletes the rest of the buffer contents.
* -avalon
*/
if (dolen == 0)
{
if (DBufLength(&(cli_recvQ(cptr))) < 510)
SetFlag(cptr, FLAG_NONL);
else
{
/* More than 512 bytes in the line - drop the input and yell
* at the client.
*/
DBufClear(&(cli_recvQ(cptr)));
send_reply(cptr, ERR_INPUTTOOLONG);
}
}
else if (client_dopacket(cptr, dolen) == CPTR_KILLED)
return CPTR_KILLED;
/*
* If it has become registered as a Server
* then skip the per-message parsing below.
*/
if (IsHandshake(cptr) || IsServer(cptr))
{
while (-1)
{
dolen = dbuf_get(&(cli_recvQ(cptr)), readbuf, sizeof(readbuf));
if (dolen <= 0)
return 1;
else if (dolen == 0)
{
if (DBufLength(&(cli_recvQ(cptr))) < 510)
SetFlag(cptr, FLAG_NONL);
else {
DBufClear(&(cli_recvQ(cptr)));
/* send_reply(cptr, ERR_INPUTTOOLONG); */
}
}
else if ((IsServer(cptr) &&
server_dopacket(cptr, readbuf, dolen) == CPTR_KILLED) ||
(!IsServer(cptr) &&
connect_dopacket(cptr, readbuf, dolen) == CPTR_KILLED))
return CPTR_KILLED;
}
}
}
/* If there's still data to process, wait 2 seconds first */
if (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) &&
!t_onqueue(&(cli_proc(cptr))))
{
Debug((DEBUG_LIST, "Adding client process timer for %C", cptr));
cli_freeflag(cptr) |= FREEFLAG_TIMER;
timer_add(&(cli_proc(cptr)), client_timer_callback, cli_connect(cptr),
TT_RELATIVE, 2);
}
}
return 1;
}
/** Start a connection to another server.
* @param aconf Connect block data for target server.
* @param by Client who requested the connection (if any).
* @return Non-zero on success; zero on failure.
*/
int connect_server(struct ConfItem* aconf, struct Client* by)
{
struct Client* cptr = 0;
assert(0 != aconf);
if (aconf->dns_pending) {
sendto_opmask(0, SNO_OLDSNO, "Server %s connect DNS pending",
aconf->name);
return 0;
}
Debug((DEBUG_NOTICE, "Connect to %s[@%s]", aconf->name,
ircd_ntoa(&aconf->address.addr)));
if ((cptr = FindClient(aconf->name))) {
if (IsServer(cptr) || IsMe(cptr)) {
sendto_opmask(0, SNO_OLDSNO, "Server %s already present from %s",
aconf->name, cli_name(cli_from(cptr)));
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Server %s already present "
"from %s", by, aconf->name, cli_name(cli_from(cptr)));
}
return 0;
}
else if (IsHandshake(cptr) || IsConnecting(cptr)) {
if (by && IsUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connection to %s already in "
"progress", by, cli_name(cptr));
}
return 0;
}
}
/*
* If we don't know the IP# for this host and it is a hostname and
* not a ip# string, then try and find the appropriate host record.
*/
if (!irc_in_addr_valid(&aconf->address.addr)
&& !ircd_aton(&aconf->address.addr, aconf->host)) {
char buf[HOSTLEN + 1];
host_from_uh(buf, aconf->host, HOSTLEN);
gethost_byname(buf, connect_dns_callback, aconf);
aconf->dns_pending = 1;
return 0;
}
cptr = make_client(NULL, STAT_UNKNOWN_SERVER);
/*
* Copy these in so we have something for error detection.
*/
ircd_strncpy(cli_name(cptr), aconf->name, HOSTLEN);
ircd_strncpy(cli_sockhost(cptr), aconf->host, HOSTLEN);
/*
* Attach config entries to client here rather than in
* completed_connection. This to avoid null pointer references
*/
attach_confs_byhost(cptr, aconf->host, CONF_SERVER);
if (!find_conf_byhost(cli_confs(cptr), aconf->host, CONF_SERVER)) {
sendto_opmask(0, SNO_OLDSNO, "Host %s is not enabled for "
"connecting: no Connect block", aconf->name);
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connect to host %s failed: no "
"Connect block", by, aconf->name);
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* attempt to connect to the server in the conf line
*/
if (!connect_inet(aconf, cptr)) {
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Couldn't connect to %s", by,
cli_name(cptr));
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* NOTE: if we're here we have a valid C:Line and the client should
* have started the connection and stored the remote address/port and
* ip address name in itself
*
* The socket has been connected or connect is in progress.
*/
make_server(cptr);
if (by && IsUser(by)) {
ircd_snprintf(0, cli_serv(cptr)->by, sizeof(cli_serv(cptr)->by), "%s%s",
NumNick(by));
assert(0 == cli_serv(cptr)->user);
cli_serv(cptr)->user = cli_user(by);
cli_user(by)->refcnt++;
}
else {
*(cli_serv(cptr))->by = '\0';
/* strcpy(cptr->serv->by, "Auto"); */
}
cli_serv(cptr)->up = &me;
SetConnecting(cptr);
if (cli_fd(cptr) > HighestFd)
HighestFd = cli_fd(cptr);
LocalClientArray[cli_fd(cptr)] = cptr;
Count_newunknown(UserStats);
/* Actually we lie, the connect hasn't succeeded yet, but we have a valid
* cptr, so we register it now.
* Maybe these two calls should be merged.
*/
add_client_to_list(cptr);
hAddClient(cptr);
/* nextping = CurrentTime; */
return (s_state(&cli_socket(cptr)) == SS_CONNECTED) ?
completed_connection(cptr) : 1;
}
/** Find the real hostname for the host running the server (or one which
* matches the server's name) and its primary IP#. Hostname is stored
* in the client structure passed as a pointer.
*/
void init_server_identity(void)
{
const struct LocalConf* conf = conf_get_local();
assert(0 != conf);
ircd_strncpy(cli_name(&me), conf->name, HOSTLEN);
SetYXXServerName(&me, conf->numeric);
}
/** Process events on a client socket.
* @param ev Socket event structure that has a struct Connection as
* its associated data.
*/
static void client_sock_callback(struct Event* ev)
{
struct Client* cptr;
struct Connection* con;
char *fmt = "%s";
char *fallback = 0;
assert(0 != ev_socket(ev));
assert(0 != s_data(ev_socket(ev)));
con = (struct Connection*) s_data(ev_socket(ev));
assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY);
cptr = con_client(con);
assert(0 == cptr || con == cli_connect(cptr));
switch (ev_type(ev)) {
case ET_DESTROY:
con_freeflag(con) &= ~FREEFLAG_SOCKET;
if (!con_freeflag(con) && !cptr)
free_connection(con);
#if defined(USE_SSL)
ssl_free(ev_socket(ev));
#endif
break;
case ET_CONNECT: /* socket connection completed */
if (!completed_connection(cptr) || IsDead(cptr))
fallback = cli_info(cptr);
break;
case ET_ERROR: /* an error occurred */
fallback = cli_info(cptr);
cli_error(cptr) = ev_data(ev);
/* If the OS told us we have a bad file descriptor, we should
* record that for future reference.
*/
if (cli_error(cptr) == EBADF)
cli_fd(cptr) = -1;
if (s_state(&(con_socket(con))) == SS_CONNECTING) {
completed_connection(cptr);
/* for some reason, the os_get_sockerr() in completed_connection()
* can return 0 even when ev_data(ev) indicates a real error, so
* re-assign the client error here.
*/
cli_error(cptr) = ev_data(ev);
break;
}
/*FALLTHROUGH*/
case ET_EOF: /* end of file on socket */
Debug((DEBUG_ERROR, "READ ERROR: fd = %d %d", cli_fd(cptr),
cli_error(cptr)));
SetFlag(cptr, FLAG_DEADSOCKET);
if ((IsServer(cptr) || IsHandshake(cptr)) && cli_error(cptr) == 0) {
exit_client_msg(cptr, cptr, &me, "Server %s closed the connection (%s)",
cli_name(cptr), cli_serv(cptr)->last_error_msg);
return;
} else {
fmt = "Read error: %s";
fallback = "EOF from client";
}
break;
case ET_WRITE: /* socket is writable */
ClrFlag(cptr, FLAG_BLOCKED);
if (cli_listing(cptr) && MsgQLength(&(cli_sendQ(cptr))) < 2048)
list_next_channels(cptr);
Debug((DEBUG_SEND, "Sending queued data to %C", cptr));
send_queued(cptr);
break;
case ET_READ: /* socket is readable */
if (!IsDead(cptr)) {
Debug((DEBUG_DEBUG, "Reading data from %C", cptr));
if (read_packet(cptr, 1) == 0) /* error while reading packet */
fallback = "EOF from client";
}
break;
default:
assert(0 && "Unrecognized socket event in client_sock_callback()");
break;
}
assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr));
if (fallback) {
const char* msg = (cli_error(cptr)) ? strerror(cli_error(cptr)) : fallback;
if (!msg)
msg = "Unknown error";
exit_client_msg(cptr, cptr, &me, fmt, msg);
}
}
/** Process a timer on client socket.
* @param ev Timer event that has a struct Connection as its
* associated data.
*/
static void client_timer_callback(struct Event* ev)
{
struct Client* cptr;
struct Connection* con;
assert(0 != ev_timer(ev));
assert(0 != t_data(ev_timer(ev)));
assert(ET_DESTROY == ev_type(ev) || ET_EXPIRE == ev_type(ev));
con = (struct Connection*) t_data(ev_timer(ev));
assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY);
cptr = con_client(con);
assert(0 == cptr || con == cli_connect(cptr));
if (ev_type(ev)== ET_DESTROY) {
con_freeflag(con) &= ~FREEFLAG_TIMER; /* timer has expired... */
if (!con_freeflag(con) && !cptr)
free_connection(con); /* client is being destroyed */
} else {
Debug((DEBUG_LIST, "Client process timer for %C expired; processing",
cptr));
read_packet(cptr, 0); /* read_packet will re-add timer if needed */
}
assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr));
}
int main(int argc, char *argv[])
{
uid_t uid, euid;
sbrk0 = (char *)sbrk((size_t)0);
uid = getuid();
euid = geteuid();
#ifdef CHROOTDIR
ircd_res_init();
if (chdir(ROOT_PATH)!=0)
{
perror("chdir");
(void)fprintf(stderr,"%s: Cannot chdir: %s.\n", IRCD_PATH,
ROOT_PATH);
exit(5);
}
if (chroot(ROOT_PATH)!=0)
{
perror("chroot");
(void)fprintf(stderr,"%s: Cannot chroot: %s.\n", IRCD_PATH,
ROOT_PATH);
exit(5);
}
#endif /*CHROOTDIR*/
#ifdef ZIP_LINKS
if (zlib_version[0] == '0')
{
fprintf(stderr, "zlib version 1.0 or higher required\n");
exit(1);
}
if (zlib_version[0] != ZLIB_VERSION[0])
{
fprintf(stderr, "incompatible zlib version\n");
exit(1);
}
if (strcmp(zlib_version, ZLIB_VERSION) != 0)
{
fprintf(stderr, "warning: different zlib version\n");
}
#endif
myargv = argv;
(void)umask(077); /* better safe than sorry --SRB */
bzero((char *)&me, sizeof(me));
make_server(&me);
register_server(&me);
version = make_version(); /* Generate readable version string */
/*
** All command line parameters have the syntax "-fstring"
** or "-f string" (e.g. the space is optional). String may
** be empty. Flag characters cannot be concatenated (like
** "-fxyz"), it would conflict with the form "-fstring".
*/
while (--argc > 0 && (*++argv)[0] == '-')
{
char *p = argv[0]+1;
int flag = *p++;
if (flag == '\0' || *p == '\0')
{
if (argc > 1 && argv[1][0] != '-')
{
p = *++argv;
argc -= 1;
}
else
{
p = "";
}
}
switch (flag)
{
case 'a':
bootopt |= BOOT_AUTODIE;
break;
case 'b':
bootopt |= BOOT_BADTUNE;
break;
case 'c':
bootopt |= BOOT_CONSOLE;
break;
case 'q':
bootopt |= BOOT_QUICK;
break;
#ifdef CMDLINE_CONFIG
case 'f':
(void)setuid((uid_t)uid);
configfile = p;
break;
#endif
case 'h':
if (*p == '\0')
bad_command();
strncpyzt(me.serv->namebuf, p, sizeof(me.serv->namebuf));
break;
case 'i':
bootopt |= BOOT_INETD|BOOT_AUTODIE;
break;
case 'p':
if (!strcmp(p, "strict"))
bootopt |= BOOT_PROT|BOOT_STRICTPROT;
else if (!strcmp(p, "on"))
bootopt |= BOOT_PROT;
else if (!strcmp(p, "off"))
bootopt &= ~(BOOT_PROT|BOOT_STRICTPROT);
else if (!strcmp(p, "standalone"))
bootopt |= BOOT_STANDALONE;
else
bad_command();
break;
case 's':
bootopt |= BOOT_NOIAUTH;
break;
case 't':
#ifdef DEBUGMODE
(void)setuid((uid_t)uid);
#endif
bootopt |= BOOT_TTY;
break;
case 'T':
tunefile = p;
break;
case 'v':
(void)printf("ircd %s %s\n\tzlib %s\n\tircd.conf delimiter %c\n\t%s #%s\n",
version, serveropts,
#ifndef ZIP_LINKS
"not used",
#else
zlib_version,
#endif
IRCDCONF_DELIMITER,
creation, generation);
exit(0);
case 'x':
#ifdef DEBUGMODE
(void)setuid((uid_t)uid);
debuglevel = atoi(p);
debugmode = *p ? p : "0";
bootopt |= BOOT_DEBUG;
break;
#else
(void)fprintf(stderr,
"%s: DEBUGMODE must be defined for -x y\n",
myargv[0]);
exit(0);
#endif
default:
bad_command();
}
}
if (strlen(tunefile) > 1023 || strlen(mybasename(tunefile)) > 42)
{
fprintf(stderr, "Too long tune filename\n");
exit(-1);
}
if (argc > 0)
bad_command(); /* This exits out */
#ifndef IRC_UID
if ((uid != euid) && !euid)
{
(void)fprintf(stderr,
"ERROR: do not run ircd setuid root. Make it setuid a\
normal user.\n");
exit(-1);
}
int
main (int argc, char *argv[])
{
/* Check to see if the user is running
* us as root, which is a nono
*/
if (geteuid () == 0)
{
fprintf (stderr, "Don't run ircd as root!!!\n");
return (-1);
}
/* save server boot time right away, so getrusage works correctly */
set_time ();
/* Setup corefile size immediately after boot -kre */
setup_corefile ();
/* set initialVMTop before we allocate any memory */
initialVMTop = get_vm_top ();
ServerRunning = 0;
/* It ain't random, but it ought to be a little harder to guess */
srand (SystemTime.tv_sec ^ (SystemTime.tv_usec | (getpid () << 20)));
memset (&me, 0, sizeof (me));
memset (&meLocalUser, 0, sizeof (meLocalUser));
me.localClient = &meLocalUser;
dlinkAdd (&me, &me.node, &global_client_list); /* Pointer to beginning
of Client list */
memset (&ServerInfo, 0, sizeof (ServerInfo));
/* Initialise the channel capability usage counts... */
init_chcap_usage_counts ();
ConfigFileEntry.dpath = DPATH;
ConfigFileEntry.configfile = CPATH; /* Server configuration file */
ConfigFileEntry.klinefile = KPATH; /* Server kline file */
ConfigFileEntry.xlinefile = XPATH; /* Server xline file */
ConfigFileEntry.dlinefile = DLPATH; /* dline file */
ConfigFileEntry.cresvfile = CRESVPATH; /* channel resv file */
ConfigFileEntry.nresvfile = NRESVPATH; /* nick resv file */
myargv = argv;
umask (077); /* better safe than sorry --SRB */
parseargs (&argc, &argv, myopts);
build_version ();
if (printVersion)
{
printf ("ircd: version %s\n", ircd_version);
exit (EXIT_SUCCESS);
}
if (chdir (ConfigFileEntry.dpath))
{
perror ("chdir");
exit (EXIT_FAILURE);
}
if (!server_state.foreground)
make_daemon ();
else
print_startup (getpid ());
#ifdef HAVE_LIBCRYPTO
dh_init();
fprintf(stderr, "SSL: Initialize\n");
SSL_load_error_strings();
SSLeay_add_ssl_algorithms();
ServerInfo.ctx = SSL_CTX_new(SSLv23_server_method());
if (!ServerInfo.ctx) {
ERR_print_errors_fp(stderr);
return 0;
}
fprintf(stderr, "SSL: Client based SSL connections are enabled.\n");
#endif
setup_signals ();
/* We need this to initialise the fd array before anything else */
fdlist_init ();
if (!server_state.foreground)
close_all_connections (); /* this needs to be before init_netio()! */
else
check_can_use_v6 (); /* Done in close_all_connections normally */
init_log (logFileName);
init_netio (); /* This needs to be setup early ! -- adrian */
/* Check if there is pidfile and daemon already running */
check_pidfile (pidFileName);
/* Init the event subsystem */
eventInit ();
init_sys ();
#ifndef NOBALLOC
initBlockHeap ();
#endif
init_dlink_nodes ();
init_slink_nodes ();
initialize_message_files ();
dbuf_init ();
init_hash ();
init_ip_hash_table (); /* client host ip hash table */
init_host_hash (); /* Host-hashtable. */
clear_hash_parse ();
init_client ();
init_user ();
init_channels ();
init_class ();
init_whowas ();
init_stats ();
init_hooks ();
read_conf_files (1); /* cold start init conf files */
initServerMask ();
init_uid ();
init_auth (); /* Initialise the auth code */
init_resolver (); /* Needs to be setup before the io loop */
init_reject (); /* Set up the reject code. */
init_umodes (); /* Set up the usermode system. */
initialize_foundation_signals(); /* register things that modules need */
#ifdef HAVE_LIBCRYPTO
bio_spare_fd = save_spare_fd ("SSL private key validation");
#endif /* HAVE_LIBCRYPTO */
initialize_server_capabs (); /* Set up default_server_capabs */
initialize_global_set_options ();
if (ServerInfo.name == NULL)
{
fprintf (stderr,
"ERROR: No server name specified in serverinfo block.\n");
ilog (L_CRIT, "No server name specified in serverinfo block.");
exit (EXIT_FAILURE);
}
strlcpy (me.name, ServerInfo.name, sizeof (me.name));
/* serverinfo{} description must exist. If not, error out. */
if (ServerInfo.description == NULL)
{
fprintf (stderr,
"ERROR: No server description specified in serverinfo block.\n");
ilog (L_CRIT,
"ERROR: No server description specified in serverinfo block.");
exit (EXIT_FAILURE);
}
strlcpy (me.info, ServerInfo.description, sizeof (me.info));
me.from = &me;
me.servptr = &me;
SetMe (&me);
make_server (&me);
strlcpy (me.serv->up, me.name, sizeof (me.serv->up));
me.lasttime = me.since = me.firsttime = CurrentTime;
hash_add_client (&me);
/* add ourselves to global_serv_list */
dlinkAdd (&me, make_dlink_node (), &global_serv_list);
check_class ();
#ifndef STATIC_MODULES
if (chdir (MODPATH))
{
ilog (L_CRIT, "Could not load core modules. Terminating!");
exit (EXIT_FAILURE);
}
mod_set_base ();
load_all_modules (1);
load_core_modules (1);
/* Go back to DPATH after checking to see if we can chdir to MODPATH */
chdir (ConfigFileEntry.dpath);
#else
load_all_modules (1);
#endif
write_pidfile (pidFileName);
ilog (L_NOTICE, "Server Ready");
eventAddIsh ("cleanup_tklines", cleanup_tklines, NULL,
CLEANUP_TKLINES_TIME);
/* We want try_connections to be called as soon as possible now! -- adrian */
/* No, 'cause after a restart it would cause all sorts of nick collides */
eventAddIsh ("try_connections", try_connections, NULL,
STARTUP_CONNECTIONS_TIME);
eventAddIsh ("collect_zipstats", collect_zipstats, NULL, ZIPSTATS_TIME);
/* Setup the timeout check. I'll shift it later :) -- adrian */
eventAddIsh ("comm_checktimeouts", comm_checktimeouts, NULL, 1);
if (splitmode)
eventAddIsh ("check_splitmode", check_splitmode, NULL, 60);
ServerRunning = 1;
io_loop ();
return (0);
}