void do_events(int sig)
{
set_crash();
set_date_time();
check_reboot_shutdown();
check_idle_and_timeout();
#ifdef NETLINKS
check_nethangs_send_keepalives();
#endif
check_messages(NULL,0);
reset_alarm();
transport();
plugin_triggers(NULL, "");
check_alarm();
if (syspp->auto_save!=(-1))
check_autosave();
check_credit_updates();
check_lynx();
check_pings();
}
static time_t io_loop(time_t delay)
{
static char to_send[200];
static time_t lasttime = 0;
static long lastrecvK = 0;
static int lrv = 0;
time_t lasttimeofday;
lasttimeofday = CurrentTime;
if (CurrentTime < lasttimeofday)
{
ircsprintf(to_send, "System clock is running backwards - (%d < %d)",
CurrentTime, lasttimeofday);
report_error(to_send, me.name, 0);
}
if(!next_gc)
{
next_gc = CurrentTime + 600;
}
/*
* This chunk of code determines whether or not
* "life sucks", that is to say if the traffic
* level is so high that standard server
* commands should be restricted
*
* Changed by Taner so that it tells you what's going on
* as well as allows forced on (long LCF), etc...
*/
if ((CurrentTime - lasttime) >= LCF)
{
lrv = LRV * LCF;
lasttime = CurrentTime;
currlife = (float)((long)me.receiveK - lastrecvK)/(float)LCF;
if (((long)me.receiveK - lrv) > lastrecvK )
{
if (!LIFESUX)
{
LIFESUX = 1;
if (NOISYHTM)
{
sprintf(to_send,
"Entering high-traffic mode - (%.1fk/s > %dk/s)",
(float)currlife, LRV);
sendto_ops("%s", to_send);
}
}
else
{
LIFESUX++; /* Ok, life really sucks! */
LCF += 2; /* Wait even longer */
if (NOISYHTM)
{
sprintf(to_send,
"Still high-traffic mode %d%s (%d delay): %.1fk/s",
LIFESUX,
(LIFESUX & 0x04) ? " (TURBO)" : "",
(int)LCF, (float)currlife);
sendto_ops("%s", to_send);
}
}
}
else
{
LCF = LOADCFREQ;
if (LIFESUX)
{
LIFESUX = 0;
if (NOISYHTM)
sendto_ops("Resuming standard operation . . . .");
}
}
lastrecvK = (long)me.receiveK;
}
/*
** We only want to connect if a connection is due,
** not every time through. Note, if there are no
** active C lines, this call to Tryconnections is
** made once only; it will return 0. - avalon
*/
if (nextconnect && CurrentTime >= nextconnect)
nextconnect = try_connections(CurrentTime);
/*
** take the smaller of the two 'timed' event times as
** the time of next event (stops us being late :) - avalon
** WARNING - nextconnect can return 0!
*/
if (nextconnect)
delay = IRCD_MIN(nextping, nextconnect);
delay -= CurrentTime;
/*
** Adjust delay to something reasonable [ad hoc values]
** (one might think something more clever here... --msa)
** We don't really need to check that often and as long
** as we don't delay too long, everything should be ok.
** waiting too long can cause things to timeout...
** i.e. PINGS -> a disconnection :(
** - avalon
*/
if (delay < 1)
delay = 1;
else
delay = IRCD_MIN(delay, TIMESEC);
/*
* We want to read servers on every io_loop, as well
* as "busy" clients (which again, includes servers.
* If "lifesux", then we read servers AGAIN, and then
* flush any data to servers.
* -Taner
*/
#ifndef NO_PRIORITY
read_message(0, FDL_SERVER);
read_message(0, FDL_BUSY);
if (LIFESUX)
{
read_message(0, FDL_SERVER);
if (LIFESUX & 0x4)
{ /* life really sucks */
read_message(0, FDL_BUSY);
read_message(0, FDL_SERVER);
}
flush_server_connections();
}
/*
* CLIENT_SERVER = TRUE:
* If we're in normal mode, or if "lifesux" and a few
* seconds have passed, then read everything.
* CLIENT_SERVER = FALSE:
* If it's been more than lifesux*2 seconds (that is,
* at most 1 second, or at least 2s when lifesux is
* != 0) check everything.
* -Taner
*/
{
static time_t lslasttime=0;
#ifdef CLIENT_SERVER
if (!LIFESUX || (lslasttime + LIFESUX) < CurrentTime)
{
#else
if ((lslasttime + (LIFESUX + 1)) < CurrentTime)
{
#endif
read_message(0, FDL_ALL); /* check everything! */
lslasttime = CurrentTime;
}
}
#else
read_message(0, FDL_ALL); /* check everything! */
flush_server_connections();
#endif
/*
** ...perhaps should not do these loops every time,
** but only if there is some chance of something
** happening (but, note that conf->hold times may
** be changed elsewhere--so precomputed next event
** time might be too far away... (similarly with
** ping times) --msa
*/
if (CurrentTime >= nextping) {
nextping = check_pings(CurrentTime);
timeout_auth_queries(CurrentTime);
}
if (dorehash && !LIFESUX)
{
rehash(&me, &me, 1);
dorehash = 0;
}
/*
** Flush output buffers on all connections now if they
** have data in them (or at least try to flush)
** -avalon
*/
flush_connections(0);
#ifndef NO_PRIORITY
fdlist_check(CurrentTime);
#endif
if(CurrentTime >= next_gc)
{
block_garbage_collect();
next_gc = CurrentTime + 600;
}
return delay;
}
/*
* initalialize_global_set_options
*
* inputs - none
* output - none
* side effects - This sets all global set options needed
*/
static void initialize_global_set_options(void)
{
memset( &GlobalSetOptions, 0, sizeof(GlobalSetOptions));
MAXCLIENTS = MAX_CLIENTS;
NOISYHTM = NOISY_HTM;
GlobalSetOptions.autoconn = 1;
#ifdef FLUD
FLUDNUM = FLUD_NUM;
FLUDTIME = FLUD_TIME;
FLUDBLOCK = FLUD_BLOCK;
#endif
#ifdef IDLE_CHECK
IDLETIME = MIN_IDLETIME;
#endif
#ifdef ANTI_SPAMBOT
SPAMTIME = MIN_JOIN_LEAVE_TIME;
SPAMNUM = MAX_JOIN_LEAVE_COUNT;
#endif
#ifdef ANTI_DRONE_FLOOD
DRONETIME = DEFAULT_DRONE_TIME;
DRONECOUNT = DEFAULT_DRONE_COUNT;
#endif
#ifdef NEED_SPLITCODE
SPLITDELAY = (DEFAULT_SERVER_SPLIT_RECOVERY_TIME * 60);
SPLITNUM = SPLIT_SMALLNET_SIZE;
SPLITUSERS = SPLIT_SMALLNET_USER_SIZE;
server_split_time = CurrentTime;
#endif
/* End of global set options */
}
void io_loop()
{
char to_send[200];
time_t lasttime = 0;
long lastrecvK = 0;
int lrv = 0;
time_t lasttimeofday;
int delay = 0;
while(1)
{
lasttimeofday = timeofday;
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);
}
if (timeofday < lasttimeofday)
{
ircsprintf(to_send, "System clock is running backwards - (%d < %d)",
timeofday, lasttimeofday);
report_error(to_send, &me);
}
NOW = timeofday;
/*
* This chunk of code determines whether or not "life sucks", that
* is to say if the traffic level is so high that standard server
* commands should be restricted
*
* Changed by Taner so that it tells you what's going on as well as
* allows forced on (long LCF), etc...
*/
if ((timeofday - lasttime) >= LCF)
{
lrv = LRV * LCF;
lasttime = timeofday;
currlife = (me.receiveK - lastrecvK) / LCF;
if ((me.receiveK - lrv) > lastrecvK || HTMLOCK == YES)
{
if (!lifesux)
{
/*
* In the original +th code Taner had
*
* LCF << 1; / * add hysteresis * /
*
* which does nothing... so, the hybrid team changed it to
*
* LCF <<= 1; / * add hysteresis * /
*
* suddenly, there were reports of clients mysteriously just
* dropping off... Neither rodder or I can see why it makes
* a difference, but lets try it this way...
*
* The original dog3 code, does not have an LCF variable
*
* -Dianora
*
*/
lifesux = 1;
if (noisy_htm)
sendto_ops("Entering high-traffic mode - (%dk/s > %dk/s)", currlife, LRV);
}
else
{
lifesux++; /* Ok, life really sucks! */
LCF += 2; /* Wait even longer */
if (noisy_htm)
sendto_ops("Still high-traffic mode %d%s (%d delay): %dk/s",
lifesux, (lifesux > 9) ? " (TURBO)" : "", (int) LCF, currlife);
/* Reset htm here, because its been on a little too long.
* Bad Things(tm) tend to happen with HTM on too long -epi */
if (lifesux>15)
{
if (noisy_htm)
sendto_ops("Resetting HTM and raising limit to: %dk/s\n", LRV + 5);
LCF=LOADCFREQ;
lifesux=0;
LRV+=5;
}
}
}
else
{
LCF = LOADCFREQ;
if (lifesux)
{
lifesux = 0;
if (noisy_htm)
sendto_ops("Resuming standard operation . . . .");
}
}
lastrecvK = me.receiveK;
}
/*
* * We only want to connect if a connection is due, not every
* time through. Note, if there are no active C lines, this call
* to Tryconnections is made once only; it will return 0. - avalon
*/
if (nextconnect && timeofday >= nextconnect)
nextconnect = try_connections(timeofday);
/* DNS checks. One to timeout queries, one for cache expiries.*/
if (timeofday >= nextdnscheck)
nextdnscheck = timeout_query_list(timeofday);
if (timeofday >= nextexpire)
nextexpire = expire_cache(timeofday);
/*
* * take the smaller of the two 'timed' event times as the time
* of next event (stops us being late :) - avalon WARNING -
* nextconnect can return 0!
*/
if (nextconnect)
delay = MIN(nextping, nextconnect);
else
delay = nextping;
delay = MIN(nextdnscheck, delay);
delay = MIN(nextexpire, delay);
delay -= timeofday;
/*
* * Adjust delay to something reasonable [ad hoc values] (one
* might think something more clever here... --msa)
* We don't really need to check that often and as long
* as we don't delay too long, everything should be ok.
* waiting too long can cause things to timeout...
* i.e. PINGS -> a disconnection :(
* - avalon
*/
if (delay < 1)
delay = 1;
else
delay = MIN(delay, TIMESEC);
/*
* We want to read servers on every io_loop, as well as "busy"
* clients (which again, includes servers. If "lifesux", then we
* read servers AGAIN, and then flush any data to servers. -Taner
*/
#ifndef NO_PRIORITY
read_message(0, &serv_fdlist);
read_message(1, &busycli_fdlist);
if (lifesux)
{
(void) read_message(1, &serv_fdlist);
if (lifesux > 9) /* life really sucks */
{
(void) read_message(1, &busycli_fdlist);
(void) read_message(1, &serv_fdlist);
}
flush_fdlist_connections(&serv_fdlist);
}
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);
}
/*
* CLIENT_SERVER = TRUE: If we're in normal mode, or if "lifesux"
* and a few seconds have passed, then read everything.
* CLIENT_SERVER = FALSE: If it's been more than lifesux*2 seconds
* (that is, at most 1 second, or at least 2s when lifesux is != 0)
* check everything. -Taner
*/
{
static time_t lasttime = 0;
# ifdef CLIENT_SERVER
if (!lifesux || (lasttime + lifesux) < timeofday) {
# else
if ((lasttime + (lifesux + 1)) < timeofday) {
# endif
(void) read_message(delay ? delay : 1, NULL); /* check everything! */
lasttime = timeofday;
}
}
#else
(void) read_message(delay, NULL); /* check everything! */
#endif
/*
* * ...perhaps should not do these loops every time, but only if
* there is some chance of something happening (but, note that
* conf->hold times may be changed elsewhere--so precomputed next
* event time might be too far away... (similarly with ping
* times) --msa
*/
if ((timeofday >= nextping))
nextping = check_pings(timeofday);
if (dorehash && !lifesux)
{
(void) rehash(&me, &me, 1);
dorehash = 0;
}
/*
*
* Flush output buffers on all connections now if they
* have data in them (or at least try to flush) -avalon
*
* flush_connections(me.fd);
*
* avalon, what kind of crack have you been smoking? why
* on earth would we flush_connections blindly when
* we already check to see if we can write (and do)
* in read_message? There is no point, as this causes
* lots and lots of unnecessary sendto's which
* 99% of the time will fail because if we couldn't
* empty them in read_message we can't empty them here.
* one effect: during htm, output to normal lusers
* will lag.
*/
/* Now we've made this call a bit smarter. */
/* Only flush non-blocked sockets. */
flush_connections(me.fd);
#ifndef NO_PRIORITY
check_fdlists();
#endif
#ifdef LOCKFILE
/*
* * If we have pending klines and CHECK_PENDING_KLINES minutes
* have passed, try writing them out. -ThemBones
*/
if ((pending_klines) && ((timeofday - pending_kline_time)
>= (CHECK_PENDING_KLINES * 60)))
do_pending_klines();
#endif
}
}
/*
* open_debugfile
*
* If the -t option is not given on the command line when the server is
* started, all debugging output is sent to the file set by LPATH in
* config.h Here we just open that file and make sure it is opened to
* fd 2 so that any fprintf's to stderr also goto the logfile. If the
* debuglevel is not set from the command line by -x, use /dev/null as
* the dummy logfile as long as DEBUGMODE has been defined, else dont
* waste the fd.
*/
static void
open_debugfile()
{
#ifdef DEBUGMODE
int fd;
aClient *cptr;
if (debuglevel >= 0)
{
cptr = make_client(NULL, NULL);
cptr->fd = 2;
SetLog(cptr);
cptr->port = debuglevel;
cptr->flags = 0;
cptr->acpt = cptr;
local[2] = cptr;
(void) strcpy(cptr->sockhost, me.sockhost);
(void) printf("isatty = %d ttyname = %#x\n",
isatty(2), (u_int) ttyname(2));
if (!(bootopt & BOOT_TTY)) /*) leave debugging output on fd */
{
(void) truncate(LOGFILE, 0);
if ((fd = open(LOGFILE, O_WRONLY | O_CREAT, 0600)) < 0)
if ((fd = open("/dev/null", O_WRONLY)) < 0)
exit(-1);
if (fd != 2)
{
(void) dup2(fd, 2);
(void) close(fd);
}
strncpyzt(cptr->name, LOGFILE, sizeof(cptr->name));
}
else if (isatty(2) && ttyname(2))
strncpyzt(cptr->name, ttyname(2), sizeof(cptr->name));
else
(void) strcpy(cptr->name, "FD2-Pipe");
Debug((DEBUG_FATAL, "Debug: File <%s> Level: %d at %s",
cptr->name, cptr->port, myctime(time(NULL))));
}
else
local[2] = NULL;
#endif
return;
}
