/* try to identify at Nickserv */
void identify_needed(unsigned int force)
{
char *pwd;
pwd = get_nickserv_pass();
if (pwd == NULL)
return;
if (force == 0) {
if ((gnetwork->next_identify > 0) && (gnetwork->next_identify >= gdata.curtime))
return;
}
/* wait 1 sec before idetify again */
gnetwork->next_identify = gdata.curtime + 1;
if (gnetwork->auth_name != NULL) {
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :AUTH %s %s", /* NOTRANSLATE */
gnetwork->auth_name, save_nick(gnetwork->user_nick), pwd);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"AUTH send to %s on %s.", gnetwork->auth_name, gnetwork->name);
return;
}
if (gnetwork->login_name != NULL) {
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :LOGIN %s %s", /* NOTRANSLATE */
gnetwork->login_name, save_nick(gnetwork->user_nick), pwd);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"LOGIN send to %s on %s.", gnetwork->login_name, gnetwork->name);
return;
}
writeserver(WRITESERVER_NORMAL, "PRIVMSG %s :IDENTIFY %s", "nickserv", pwd); /* NOTRANSLATE */
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"IDENTIFY send to nickserv on %s.", gnetwork->name);
}
static VALUE cie_mode(VALUE UNUSED(module), VALUE rname, VALUE rmsg)
{
char *name;
char *msg;
channel_t *ch;
if (NIL_P(rname) || NIL_P(rmsg))
return Qnil;
name = rb_obj_as_string_protected(rname);
msg = rb_obj_as_string_protected(rmsg);
if (!name || !msg)
return Qnil;
if (gnetwork->serverstatus != SERVERSTATUS_CONNECTED)
return Qfalse;
if (gnetwork->botstatus != BOTSTATUS_JOINED)
return Qfalse;
if (name[0] != '#')
return Qfalse;
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcasecmp(ch->name, name) == 0) {
writeserver(WRITESERVER_NORMAL, "MODE %s %s", name, msg); /* NOTRANSLATE */
return Qtrue;
}
}
return Qfalse;
}
static void irc_001(ir_parseline_t *ipl)
{
char *tptr;
ioutput(OUT_S|OUT_L, COLOR_NO_COLOR, "Server welcome: %s", ipl->line);
update_server_welcome(ipl->line);
/* update server name */
mydelete(gnetwork->curserveractualname);
gnetwork->curserveractualname = getpart(ipl->line + 1, 1);
/* update nick */
mydelete(gnetwork->user_nick);
mydelete(gnetwork->caps_nick);
gnetwork->user_nick = mystrdup(ipl->part[2]);
gnetwork->caps_nick = mystrdup(ipl->part[2]);
caps(gnetwork->caps_nick);
gnetwork->nick_number = 0;
gnetwork->next_restrict = gdata.curtime + gdata.restrictsend_delay;
++(gdata.needsclear);
tptr = get_user_modes();
if (tptr && tptr[0]) {
writeserver(WRITESERVER_NOW, "MODE %s %s",
gnetwork->user_nick, tptr);
}
/* server connected raw command */
for (tptr = irlist_get_head(&(gnetwork->server_connected_raw));
tptr;
tptr = irlist_get_next(tptr)) {
writeserver(WRITESERVER_NORMAL, "%s", tptr);
}
/* nickserv */
identify_needed(0);
}
PROTO int passcmd(char *command, char *args, CMDINFO *cmd)
{
int i = 1;
char chkbuf[5];
ssize_t bread = 0;
int ret;
CLEARBUF
if ( ! writeserver(client, "%s %s\r\n", command, args) ) goto sdown;
if ( (readserverline(client->bbuf, cfg.BufSize)) == NULL ) goto sdown;
/* logic to retry command if article not found */
int j=0;
while ( ( cmd->num == cmd_body || cmd->num == cmd_article )
&& ( atoi(client->bbuf) == 423 || atoi(client->bbuf) == 430 )
&& j++ < cfg.NoSuchArticleRetries)
{
if ( ! writeserver(client, "%s %s\r\n", command, args) ) goto sdown;
if ( (readserverline(client->bbuf, cfg.BufSize)) == NULL ) goto sdown;
if ( atoi(client->bbuf) < 400 )
{
if ( client->group == NULL )
syslog(LOG_ERR, "No such article, found in %d retries on server %s msgid %s",
j,
client->groupserver->Name,
args);
else
syslog(LOG_ERR, "No such article, found in %d retries on server %s group %s msgid %s",
j,
client->groupserver->Name,
client->group->newsgroup,
args);
}
}
if ( swriteclient(client, client->bbuf) ) goto sdown;
ret = atoi(client->bbuf);
if ( ret == 0 ) {
syslog(LOG_ERR, "ret==0 cmd=%s args=%s server=%s", command, args, client->currserver->Name);
}
if ( ret > 399 ) i=0;
if ( ret == 430 && cfg.LogMissing )
syslog(LOG_ERR, "missing_article: %s %s", client->hostname, args);
if ( ret == 423 && cfg.LogMissing )
syslog(LOG_ERR, "missing_article: %s %s:%s", client->hostname, client->group->newsgroup, args);
checkbuf_init(chkbuf);
while (i && ! client->error)
{
if ( (bread = nreadserver(client, client->bbuf, cfg.BufSize)) == 0 )
goto sdown;
if ( checkbuf_isend(chkbuf, client->bbuf, bread) )
i = 0;
if ( slwriteclient(client, client->bbuf, bread, cmd->limit) )
return -1;
if ( cmd->acct == 1 ) {
client->bytes += (ulong64)bread;
client->rbytes += (ulong64)bread;
}
if ( cmd->acct == 1 && client->user->bytesleft > 0 )
client->user->bytesleft -= (ulong64)bread;
client->groupbytes += (ulong64)bread;
}
return 0;
sdown:
syslog(LOG_ERR, "Server down during passcmd, sending MSG_SERVER_DOWN");
swriteclient(client, MSG_SERVER_DOWN);
disconnect_server(client);
return 0;
}
/*
* Check header permissions.
* Does newsgroup checks if ReadPat is specified
* Does Retention check if retention > 0
*/
static int check_headperm(char *msgid)
{
char *ng;
time_t msgdate;
HLIST *hdr = NULL, *allhdrs = NULL;
char header[MAX_HEADER];
char value[MAX_HEADER];
char *hval;
CLEARBUF
if ( cfg.LocalDreader == 1 &&
strcmp(client->user->readpat, "all") == 0 &&
client->profile->Retention == 0)
return CHECK_ARTICLE_OK;
if ( writeserver(client, "HEAD %s\r\n", msgid) == false )
return CHECK_ARTICLE_FAIL;
if ( (readserverline(client->bbuf, cfg.BufSize)) == NULL )
return CHECK_ARTICLE_FAIL;
if ( atoi(client->bbuf) > 399 )
return CHECK_ARTICLE_FAIL;
/* read headers from server */
while( readserverline(client->bbuf, cfg.BufSize) != NULL )
{
if ((sscanf(client->bbuf, "%63[^\t ] %1023[^\r\n]", header, value)) == 0)
strncpy(value, client->bbuf, MAX_HEADER-1);
hdr = insert_hlist(hdr, header, value);
if ( allhdrs == NULL ) allhdrs = hdr;
if ( header[0] == '.' )
break;
}
hdr = allhdrs;
/* check retention time first */
if ( client->profile->Retention > 0 )
{
msgdate = 0;
if ( (hval=hlist_get_value(hdr, "NNTP-Posting-Date:")) != NULL )
msgdate = parsedate(hval);
else
if ( (hval=hlist_get_value(hdr, "Date:")) != NULL )
msgdate = parsedate(hval);
if ( msgdate < (time(NULL) - (client->profile->Retention * 86400)) )
{
free_hlist(hdr);
return CHECK_ARTICLE_NOPERM;
}
}
/* check newsgroup permission */
if ( (ng=hlist_get_value(hdr, "Newsgroups:")) != NULL )
{
free_hlist(hdr);
/* now we've found the article and have the newsgroups header */
if ( match_expression((unsigned char *)ng
, (unsigned char *)getwildmat(client->user->readpat)
, 0) )
return CHECK_ARTICLE_OK;
else
return CHECK_ARTICLE_NOPERM;
}
/* If we reach this, the article wouldn't have a newsgroups header. */
free_hlist(hdr);
return CHECK_ARTICLE_FAIL;
}
PROTO int group(const char *group, char nogroupecho)
{
char b[MAX_SERVERRSP];
ACTIVE *newgroup;
SERVER *svr;
CLEARBUF
if ( nullstr(group) )
{
swriteclient(client,"500 You must select a group\r\n");
return 1;
}
/* only change group if it has changed */
if ( client->group == NULL || strcmp(client->group->newsgroup, group) != 0 )
{
/* check for read permission */
if ( ! match_expression((unsigned char *)group
, (unsigned char *)getwildmat(client->user->readpat)
, 0) )
{
if ( ! nogroupecho )
swriteclient(client, MSG_NOSUCHGROUP);
return 1;
}
/* find and load our new group */
if ( (newgroup = getgroup(group)) == NULL )
{
if ( ! nogroupecho )
swriteclient(client, MSG_NOSUCHGROUP);
return 1;
}
if ( (svr=getserver(newgroup->server)) == NULL )
return swriteclient(client, "500 Cant find server for group\r\n");
/* disconnect first if we have to change server */
if ( client->groupserver != NULL &&
client->connected == 1 &&
strcmp(svr->Groups, client->groupserver->Groups) != 0 )
{
disconnect_server(client);
}
/* close group and reconnect */
closegroup();
client->group = newgroup;
switch ( connect_groupserver(client, svr->Name) )
{
case CONNECT_ERR:
return swriteclient(client, "500 Error selecting server\r\n");
case CONNECT_DOWN:
sleep(cfg.DownDelay);
return writeclient(client, MSG_SERVER_DOWN);
default:
break;
}
/* reset by connect_groupserver (via disconnect_server FIXME) */
client->group = newgroup;
client->groups++;
}
if ( ! writeserver(client, "GROUP %s\r\n", group) ) return -1;
if ( ! readserver(client, b, MAX_SERVERRSP-1) ) return -1;
syslog(LOG_NOTICE, "%s: group %s", client->hostname, group);
if ( ! nogroupecho ) return swriteclient(client,b);
return 0;
}
static void mainloop (void) {
/* data is persistant across calls */
static struct timeval timestruct;
static int changequartersec, changesec, changemin, changehour;
static time_t lasttime, lastmin, lasthour, last4sec, last5sec, last20sec;
static time_t lastautoadd;
static time_t last3min, last2min, lastignoredec;
static int first_loop = 1;
static ir_uint64 last250ms;
userinput *pubplist;
userinput *urehash;
ir_uint64 xdccsent;
unsigned int i;
int highests;
unsigned int ss;
upload *ul;
transfer *tr;
channel_t *ch;
xdcc *xd;
dccchat_t *chat;
updatecontext();
gnetwork = NULL;
if (first_loop)
{
/* init if first time called */
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
changehour=changemin=changesec=changequartersec=0;
gettimeofday(×truct, NULL);
last250ms = gdata.curtimems;
gdata.curtimems = timeval_to_ms(×truct);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR, "Startup"
" running: %ld ms", (long)(gdata.curtimems - last250ms));
gdata.curtime = timestruct.tv_sec;
lasttime=gdata.curtime;
last250ms = gdata.curtimems;
lastmin=(lasttime/60)-1;
lasthour=(lasttime/60/60)-1;
last4sec = last5sec = last20sec = last2min = last3min = lasttime;
lastignoredec = lasttime;
for (ss=0; ss<gdata.networks_online; ss++)
{
gdata.networks[ss].lastnotify = lasttime;
gdata.networks[ss].lastslow = lasttime;
gdata.networks[ss].server_input_line[0] = '\0';
}
gdata.cursendptr = 0;
lastautoadd = gdata.curtime + 60;
first_loop = 0;
}
updatecontext();
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
FD_ZERO(&gdata.execset);
highests = 0;
#ifdef USE_CURL
fetch_multi_fdset(&gdata.readset, &gdata.writeset, &gdata.execset, &highests);
#endif /* USE_CURL */
highests = irc_select(highests);
if (!gdata.background)
{
FD_SET(fileno(stdin), &gdata.readset);
highests = max2(highests, fileno(stdin));
}
highests = chat_select_fdset(highests);
highests = t_select_fdset(highests, changequartersec);
highests = l_select_fdset(highests, changequartersec);
#ifndef WITHOUT_TELNET
highests = telnet_select_fdset(highests);
#endif /* WITHOUT_TELNET */
#ifndef WITHOUT_HTTP
highests = h_select_fdset(highests, changequartersec);
#endif /* WITHOUT_HTTP */
if (gdata.md5build.file_fd != FD_UNUSED)
{
assert(gdata.md5build.xpack);
FD_SET(gdata.md5build.file_fd, &gdata.readset);
highests = max2(highests, gdata.md5build.file_fd);
}
updatecontext();
if (gdata.debug > 81)
{
select_dump("try", highests);
}
if (gdata.attop) gotobot();
tostdout_write();
gettimeofday(×truct, NULL);
gdata.selecttimems = timeval_to_ms(×truct);
if (ir_kqueue_select(highests+1, &gdata.readset, &gdata.writeset, &gdata.execset) < 0)
{
if (errno != EINTR)
{
outerror(OUTERROR_TYPE_WARN,"Select returned an error: %s",strerror(errno));
usleep(10000); /* prevent fast spinning */
}
/* data is undefined on error, zero and continue */
FD_ZERO(&gdata.readset);
FD_ZERO(&gdata.writeset);
FD_ZERO(&gdata.execset);
}
if (gdata.debug > 81)
{
select_dump("got", highests);
}
/*----- one second check ----- */
updatecontext();
if (gettimeofday(×truct, NULL) < 0)
{
outerror(OUTERROR_TYPE_CRASH,"gettimeofday() failed! %s\n",strerror(errno));
}
gdata.curtimems = timeval_to_ms(×truct);
gdata.curtime = timestruct.tv_sec;
if (gdata.curtimems > gdata.selecttimems + 1000)
outerror(OUTERROR_TYPE_WARN, "Iroffer was blocked for %lims",
(long)(gdata.curtimems - gdata.selecttimems));
/* adjust for drift and cpu usage */
if ((gdata.curtimems > (last250ms+1000)) ||
(gdata.curtimems < last250ms))
{
/* skipped forward or backwards, correct */
last250ms = gdata.curtimems-250;
}
if (gdata.curtimems >= (last250ms+250))
{
changequartersec = 1;
/* note bandwidth limiting requires no drift! */
last250ms += 250;
}
else
{
changequartersec = 0;
}
changesec = 0;
if (gdata.curtime != lasttime) {
if (gdata.curtime < lasttime - MAX_WAKEUP_WARN) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Backwards %lim %lis!!\n",
(long)(lasttime-gdata.curtime)/60, (long)(lasttime-gdata.curtime)%60);
}
if (gdata.curtime > lasttime + MAX_WAKEUP_WARN) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Forward or Mainloop Skipped %lim %lis!!\n",
(long)(gdata.curtime-lasttime)/60, (long)(gdata.curtime-lasttime)%60);
if (gdata.debug > 0) {
dump_slow_context();
}
}
if (gdata.curtime > lasttime + MAX_WAKEUP_ERR) {
outerror(OUTERROR_TYPE_WARN, "System Time Changed Forward or Mainloop Skipped %lim %lis!!\n",
(long)(gdata.curtime-lasttime)/60, (long)(gdata.curtime-lasttime)%60);
if (gdata.debug > 0)
{
dumpcontext();
}
}
lasttime = gdata.curtime;
changesec = 1;
}
if (changesec && lasttime/60/60 != lasthour) {
lasthour = lasttime/60/60;
changehour = 1;
}
if (changesec && lasttime/60 != lastmin) {
lastmin = lasttime/60;
changemin = 1;
}
if (gdata.needsshutdown)
{
gdata.needsshutdown = 0;
shutdowniroffer();
}
if (gdata.needsreap)
{
gdata.needsreap = 0;
irc_resolved();
}
#ifdef USE_CURL
fetch_perform();
#endif /* USE_CURL */
updatecontext();
if (changesec) {
gdata.totaluptime++;
gdata.xdccsent[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
gdata.xdccrecv[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
xdccsent = 0;
for (i=0; i<XDCC_SENT_SIZE; i++)
xdccsent += (ir_uint64)gdata.xdccsum[i];
if (((float)xdccsent)/XDCC_SENT_SIZE/1024.0 > gdata.sentrecord)
gdata.sentrecord = ((float)xdccsent)/XDCC_SENT_SIZE/1024.0;
gdata.xdccsum[(gdata.curtime+1)%XDCC_SENT_SIZE] = 0;
run_delayed_jobs();
}
updatecontext();
/*----- see if anything waiting on console ----- */
gdata.needsclear = 0;
if (!gdata.background && FD_ISSET(fileno(stdin), &gdata.readset))
parseconsole();
irc_perform(changesec);
l_perform(changesec);
chat_perform();
t_perform(changesec, changequartersec);
#ifndef WITHOUT_TELNET
telnet_perform();
#endif /* WITHOUT_TELNET */
#ifndef WITHOUT_HTTP
h_perform(changesec, changequartersec);
#endif /* WITHOUT_HTTP */
/*----- time for a delayed shutdown? ----- */
if (changesec && gdata.delayedshutdown)
{
if (!irlist_size(&gdata.trans))
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Delayed Shutdown Activated, No Transfers Remaining");
shutdowniroffer();
}
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- send server stuff ----- */
if (changesec) {
sendserver();
if (gdata.curtime%INAMNT_SIZE == (INAMNT_SIZE-1))
gnetwork->inamnt[0] = 0;
else
gnetwork->inamnt[gdata.curtime%INAMNT_SIZE+1] = 0;
}
/*----- see if we can send out some xdcc lists */
if (changesec && gnetwork->serverstatus == SERVERSTATUS_CONNECTED) {
if (!irlist_size((&gnetwork->serverq_normal)) && !irlist_size(&(gnetwork->serverq_slow)))
sendxdlqueue();
}
}
gnetwork = NULL;
/*----- see if its time to change maxb */
if (changehour) {
gdata.maxb = gdata.overallmaxspeed;
if (gdata.overallmaxspeeddayspeed != gdata.overallmaxspeed) {
struct tm *localt;
localt = localtime(&gdata.curtime);
if ((unsigned int)localt->tm_hour >= gdata.overallmaxspeeddaytimestart
&& (unsigned int)localt->tm_hour < gdata.overallmaxspeeddaytimeend
&& ( gdata.overallmaxspeeddaydays & (1 << (unsigned int)localt->tm_wday)) )
gdata.maxb = gdata.overallmaxspeeddayspeed;
}
isrotatelog();
expire_options();
}
/*----- see if we've hit a transferlimit or need to reset counters */
if (changesec)
{
unsigned int ii;
unsigned int transferlimits_over = 0;
for (ii=0; ii<NUMBER_TRANSFERLIMITS; ii++)
{
/* reset counters? */
if ((!gdata.transferlimits[ii].ends) ||
(gdata.transferlimits[ii].ends < gdata.curtime))
{
struct tm *localt;
if (gdata.transferlimits[ii].limit && gdata.transferlimits[ii].ends)
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Resetting %s transfer limit, used %" LLPRINTFMT "uMB of the %" LLPRINTFMT "uMB limit",
transferlimit_type_to_string(ii),
gdata.transferlimits[ii].used / 1024 / 1024,
gdata.transferlimits[ii].limit / 1024 / 1024);
}
/* find our next end time */
localt = localtime(&gdata.curtime);
localt->tm_sec = localt->tm_min = localt->tm_hour = 0; /* midnight */
switch (ii)
{
case TRANSFERLIMIT_DAILY:
/* tomorrow */
localt->tm_mday++;
break;
case TRANSFERLIMIT_WEEKLY:
/* next sunday morning */
localt->tm_mday += 7 - localt->tm_wday;
break;
case TRANSFERLIMIT_MONTHLY:
/* next month */
localt->tm_mday = gdata.start_of_month;
localt->tm_mon++;
break;
default:
outerror(OUTERROR_TYPE_CRASH, "unknown type %u", ii);
}
/* tm_wday and tm_yday are ignored in mktime() */
gdata.transferlimits[ii].ends = mktime(localt);
gdata.transferlimits[ii].used = 0;
if ( ii == TRANSFERLIMIT_DAILY )
reset_download_limits();
}
if (!transferlimits_over &&
gdata.transferlimits[ii].limit &&
(gdata.transferlimits[ii].used >= gdata.transferlimits[ii].limit))
{
transferlimits_over = 1 + ii;
if (!gdata.transferlimits_over)
{
char *tempstr = transfer_limit_exceeded_msg(ii);
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"All %" LLPRINTFMT "uMB of the %s transfer limit used. Stopping transfers.",
gdata.transferlimits[ii].limit / 1024 / 1024,
transferlimit_type_to_string(ii));
/* remove queued users */
queue_all_remove(&gdata.mainqueue, tempstr);
queue_all_remove(&gdata.idlequeue, tempstr);
/* stop transfers */
for (tr = irlist_get_head(&gdata.trans); tr; tr = irlist_get_next(tr))
{
if (tr->tr_status != TRANSFER_STATUS_DONE)
{
gnetwork = &(gdata.networks[tr->net]);
t_closeconn(tr,tempstr,0);
}
}
gnetwork = NULL;
mydelete(tempstr);
}
}
}
if (gdata.transferlimits_over != transferlimits_over)
{
if (!transferlimits_over)
{
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"No longer over any transfer limits. Transfers are now allowed.");
}
gdata.transferlimits_over = transferlimits_over;
}
}
/*----- gdata.autoignore_threshold seconds ----- */
if (changesec && ((unsigned)gdata.curtime > (lastignoredec + gdata.autoignore_threshold)))
{
igninfo *ignore;
lastignoredec += gdata.autoignore_threshold;
ignore = irlist_get_head(&gdata.ignorelist);
while(ignore)
{
ignore->bucket--;
if ((ignore->flags & IGN_IGNORING) && (ignore->bucket == 0))
{
ignore->flags &= ~IGN_IGNORING;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Ignore removed for %s",ignore->hostmask);
write_statefile();
}
if (ignore->bucket == 0)
{
mydelete(ignore->hostmask);
ignore = irlist_delete(&gdata.ignorelist, ignore);
}
else
{
ignore = irlist_get_next(ignore);
}
}
}
/*----- periodicmsg_time seconds ----- */
if (changesec) {
send_periodicmsg();
}
updatecontext();
/*----- 5 seconds ----- */
if (changesec && (gdata.curtime - last5sec > 4)) {
last5sec = gdata.curtime;
updatecontext();
/*----- server timeout ----- */
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
if (gdata.needsshutdown)
continue;
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
(gdata.curtime > gnetwork->lastservercontact + SRVRTOUT)) {
if (gnetwork->servertime < 3)
{
const char *servname = gnetwork->curserveractualname ? gnetwork->curserveractualname : gnetwork->curserver.hostname;
size_t len = 6 + strlen(servname);
char *tempstr3 = mymalloc(len + 1);
snprintf(tempstr3, len + 1, "PING %s\n", servname);
writeserver_ssl(tempstr3, len);
if (gdata.debug > 0)
{
tempstr3[len-1] = '\0';
len--;
ioutput(OUT_S, COLOR_MAGENTA, "<NORES<: %s", tempstr3);
}
mydelete(tempstr3);
gnetwork->servertime++;
}
else if (gnetwork->servertime == 3) {
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Closing Server Connection on %s: No Response for %u minutes.",
gnetwork->name, SRVRTOUT/60);
close_server();
gnetwork->servertime = 0;
}
}
/*----- ping server ----- */
if (gnetwork->recentsent) {
pingserver();
gnetwork->recentsent--;
}
}
} /* networks */
gnetwork = NULL;
/*----- 4 seconds ----- */
if (changesec && (gdata.curtime - last4sec > 3))
{
/*----- update lastspeed, check minspeed ----- */
tr = irlist_get_head(&gdata.trans);
while(tr)
{
if ( tr->con.connecttime+(MIN_TL/2) > gdata.curtime ) /* initial */
{
tr->lastspeed =
(tr->lastspeed)*DCL_SPDW_I +
(((float)(tr->bytessent-tr->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_I)/((float)(gdata.curtime-last4sec)*1.0);
}
else /* ongoing */
{
tr->lastspeed =
(tr->lastspeed)*DCL_SPDW_O +
(((float)(tr->bytessent-tr->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_O)/((float)(gdata.curtime-last4sec)*1.0);
}
tr->lastspeedamt = tr->bytessent;
t_checkminspeed(tr);
tr = irlist_get_next(tr);
}
ul = irlist_get_head(&gdata.uploads);
while(ul)
{
if ( ul->con.connecttime+(MIN_TL/2) > gdata.curtime ) /* initial */
{
ul->lastspeed =
(ul->lastspeed)*DCL_SPDW_I +
(((float)(ul->bytesgot-ul->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_I)/((float)(gdata.curtime-last4sec)*1.0);
}
else /* ongoing */
{
ul->lastspeed =
(ul->lastspeed)*DCL_SPDW_O +
(((float)(ul->bytesgot-ul->lastspeedamt))/1024.0)*(1.0-DCL_SPDW_O)/((float)(gdata.curtime-last4sec)*1.0);
}
ul->lastspeedamt = ul->bytesgot;
ul = irlist_get_next(ul);
}
last4sec = gdata.curtime;
}
updatecontext();
/*----- check for size change ----- */
if (changesec)
checktermsize();
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- plist stuff ----- */
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
changemin &&
irlist_size(&gdata.xdccs) &&
!gdata.transferlimits_over &&
(irlist_size(&(gnetwork->serverq_channel)) < irlist_size(&gdata.xdccs)) &&
(!gdata.queuesize || irlist_size(&gdata.mainqueue) < gdata.queuesize) &&
(gdata.nolisting <= gdata.curtime))
{
char *tchanf = NULL, *tchanm = NULL, *tchans = NULL;
for(ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch))
{
if ((ch->flags & CHAN_ONCHAN) &&
(ch->nextann < gdata.curtime) &&
ch->plisttime &&
(((gdata.curtime / 60) % ch->plisttime) == ch->plistoffset))
{
ch->nextmsg = gdata.curtime + ch->delay;
if (ch->pgroup != NULL)
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (pgroup)", ch->name);
pubplist = mycalloc(sizeof(userinput));
pubplist->method = method_xdl_channel;
pubplist->net = gnetwork->net;
pubplist->level = ADMIN_LEVEL_PUBLIC;
a_fillwith_plist(pubplist, ch->name, ch);
u_parseit(pubplist);
mydelete(pubplist);
continue;
}
if (ch->flags & CHAN_MINIMAL)
{
if (tchanm)
{
strncat(tchanm,",",maxtextlength-strlen(tchanm)-1);
strncat(tchanm,ch->name,maxtextlength-strlen(tchanm)-1);
}
else
{
tchanm = mymalloc(maxtextlength);
strncpy(tchanm,ch->name,maxtextlength-1);
}
}
else if (ch->flags & CHAN_SUMMARY)
{
if (tchans)
{
strncat(tchans,",",maxtextlength-strlen(tchans)-1);
strncat(tchans,ch->name,maxtextlength-strlen(tchans)-1);
}
else
{
tchans = mymalloc(maxtextlength);
strncpy(tchans,ch->name,maxtextlength-1);
}
}
else
{
if (tchanf)
{
strncat(tchanf,",",maxtextlength-strlen(tchanf)-1);
strncat(tchanf,ch->name,maxtextlength-strlen(tchanf)-1);
}
else
{
tchanf = mymalloc(maxtextlength);
strncpy(tchanf,ch->name,maxtextlength-1);
}
}
}
}
if (tchans)
{
if (gdata.restrictprivlist && !gdata.creditline && !irlist_size(&gdata.headline))
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR,
"Can't send Summary Plist to %s (restrictprivlist is set and no creditline or headline, summary makes no sense!)", tchans);
}
else
{
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (summary)", tchans);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_msg2(pubplist, tchans, "XDL");
pubplist->method = method_xdl_channel_sum;
u_parseit(pubplist);
mydelete(pubplist);
}
mydelete(tchans);
}
if (tchanf) {
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (full)", tchanf);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_plist(pubplist, tchanf, NULL);
pubplist->method = method_xdl_channel;
u_parseit(pubplist);
mydelete(pubplist);
mydelete(tchanf);
}
if (tchanm) {
ioutput(OUT_S|OUT_D, COLOR_NO_COLOR, "Plist sent to %s (minimal)", tchanm);
pubplist = mycalloc(sizeof(userinput));
a_fillwith_msg2(pubplist, tchanm, "XDL");
pubplist->method = method_xdl_channel_min;
u_parseit(pubplist);
mydelete(pubplist);
mydelete(tchanm);
}
}
} /* networks */
gnetwork = NULL;
updatecontext();
/*----- low bandwidth send, save state file ----- */
if (changesec && (gdata.curtime - last3min > 180)) {
last3min = gdata.curtime;
xdccsent = 0;
for (i=0; i<XDCC_SENT_SIZE; i++)
xdccsent += (ir_uint64)gdata.xdccsent[i];
xdccsent /= XDCC_SENT_SIZE*1024;
if ((xdccsent < (unsigned)gdata.lowbdwth) &&
!gdata.exiting &&
irlist_size(&gdata.mainqueue) &&
(irlist_size(&gdata.trans) < gdata.maxtrans))
{
check_idle_queue(0);
send_from_queue(1, 0, NULL);
}
write_files();
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/*----- queue notify ----- */
if (changesec && gdata.notifytime && (!gdata.quietmode) &&
((unsigned)gdata.curtime > (gnetwork->lastnotify + (gdata.notifytime*60))))
{
gnetwork->lastnotify = gdata.curtime;
if (gnetwork->serverstatus == SERVERSTATUS_CONNECTED)
{
if ((irlist_size(&(gnetwork->serverq_fast)) >= 10) ||
(irlist_size(&(gnetwork->serverq_normal)) >= 10) ||
(irlist_size(&(gnetwork->serverq_slow)) >= 50))
{
ioutput(OUT_S|OUT_D|OUT_L, COLOR_NO_COLOR,
"notifications skipped on %s, server queue is rather large",
gnetwork->name);
}
else
{
notifyqueued();
notifybandwidth();
notifybandwidthtrans();
}
}
}
} /* networks */
gnetwork = NULL;
updatecontext();
/*----- log stats / remote admin stats ----- */
if ( changesec &&
((unsigned)gdata.curtime >= (last2min + gdata.status_time_dcc_chat)))
{
last2min = gdata.curtime;
if (gdata.logstats)
{
logstat();
chat_writestatus();
}
}
updatecontext();
/* look to see if any files changed */
if (changesec)
look_for_file_remove();
updatecontext();
/*----- 20 seconds ----- */
if (changesec && (gdata.curtime - last20sec > 19)) {
expire_badip();
if (gdata.logfd != FD_UNUSED)
{
/* cycle */
close(gdata.logfd);
gdata.logfd = FD_UNUSED;
}
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/* try rejoining channels not on */
ch = irlist_get_head(&(gnetwork->channels));
while(ch)
{
if ((gnetwork->serverstatus == SERVERSTATUS_CONNECTED) &&
!(ch->flags & CHAN_ONCHAN))
{
joinchannel(ch);
}
ch = irlist_get_next(ch);
}
} /* networks */
gnetwork = NULL;
last20sec = gdata.curtime;
updatecontext();
for (ss=0; ss<gdata.networks_online; ss++) {
gnetwork = &(gdata.networks[ss]);
/* try to regain nick */
if (!gnetwork->user_nick || strcmp(get_config_nick(), gnetwork->user_nick))
{
writeserver(WRITESERVER_NORMAL, "NICK %s", get_config_nick());
}
} /* networks */
gnetwork = NULL;
updatecontext();
/* update status line */
if (!gdata.background && !gdata.noscreen) {
char tempstr[maxtextlength];
char tempstr2[maxtextlengthshort];
if (gdata.attop) gotobot();
tostdout(IRVT_SAVE_CURSOR);
getstatusline(tempstr,maxtextlength);
tempstr[min2(maxtextlength-2,gdata.termcols-4)] = '\0';
snprintf(tempstr2, maxtextlengthshort, IRVT_CURSOR_HOME1 "[ %%-%us ]", gdata.termlines - 1, gdata.termcols - 4);
tostdout(tempstr2,tempstr);
tostdout(IRVT_CURSOR_HOME2 IRVT_UNSAVE_CURSOR, gdata.termlines, gdata.termcols);
}
admin_jobs();
#ifdef USE_RUBY
rehash_myruby(1);
#endif /* USE_RUBY */
delayed_announce();
}
updatecontext();
if (changemin)
{
reverify_restrictsend();
update_hour_dinoex(lastmin);
check_idle_queue(0);
clean_uploadhost();
auto_rehash();
}
updatecontext();
if ((gdata.md5build.file_fd != FD_UNUSED) &&
FD_ISSET(gdata.md5build.file_fd, &gdata.readset))
{
ssize_t howmuch;
#if defined(_OS_CYGWIN)
int reads_per_loop = 32;
#else /* _OS_CYGWIN */
int reads_per_loop = 64;
#endif /* _OS_CYGWIN */
assert(gdata.md5build.xpack);
while (reads_per_loop--)
{
howmuch = read(gdata.md5build.file_fd, gdata.sendbuff, BUFFERSIZE);
if (gdata.debug >30)
{
ioutput(OUT_S, COLOR_YELLOW, "MD5: [Pack %u] read %ld",
number_of_pack(gdata.md5build.xpack), (long)howmuch);
}
if ((howmuch < 0) && (errno != EAGAIN))
{
outerror(OUTERROR_TYPE_WARN, "MD5: [Pack %u] Can't read data from file '%s': %s",
number_of_pack(gdata.md5build.xpack),
gdata.md5build.xpack->file, strerror(errno));
event_close(gdata.md5build.file_fd);
gdata.md5build.file_fd = FD_UNUSED;
gdata.md5build.xpack = NULL;
break;
}
else if (howmuch < 0)
{
break;
}
else if (howmuch == 0)
{
/* EOF */
outerror(OUTERROR_TYPE_WARN, "MD5: [Pack %u] Can't read data from file '%s': %s",
number_of_pack(gdata.md5build.xpack),
gdata.md5build.xpack->file, "truncated");
start_md5_hash(gdata.md5build.xpack, number_of_pack(gdata.md5build.xpack));
break;
}
/* else got data */
MD5Update(&gdata.md5build.md5sum, gdata.sendbuff, howmuch);
if (!gdata.nocrc32)
crc32_update((char *)gdata.sendbuff, howmuch);
gdata.md5build.bytes += howmuch;
if (gdata.md5build.bytes == gdata.md5build.xpack->st_size)
{
complete_md5_hash();
break;
}
}
}
if (!gdata.nomd5sum && changesec && (!gdata.md5build.xpack))
{
unsigned int packnum = 1;
/* see if any pack needs a md5sum calculated */
if (gdata.nomd5_start <= gdata.curtime)
for (xd = irlist_get_head(&gdata.xdccs); xd; xd = irlist_get_next(xd), packnum++)
{
if (!gdata.nocrc32)
{
if (!xd->has_crc32)
xd->has_md5sum = 0; /* force recheck with crc */
}
if (!xd->has_md5sum)
{
if (verifyshell(&gdata.md5sum_exclude, xd->file))
continue;
if (!gdata.attop) gototop();
start_md5_hash(xd, packnum);
break;
}
}
}
updatecontext();
if (gdata.exiting && has_closed_servers()) {
for (chat = irlist_get_head(&gdata.dccchats);
chat;
chat = irlist_delete(&gdata.dccchats,chat))
{
writedccchat(chat, 0, "iroffer exited, Closing DCC Chat\n");
shutdowndccchat(chat,1);
}
mylog("iroffer exited\n\n");
exit_iroffer(0);
}
updatecontext();
if (gdata.needsrehash) {
gdata.needsrehash = 0;
urehash = mycalloc(sizeof(userinput));
a_fillwith_msg2(urehash, NULL, "REHASH");
urehash->method = method_out_all; /* just OUT_S|OUT_L|OUT_D it */
urehash->net = 0;
urehash->level = ADMIN_LEVEL_FULL;
u_parseit(urehash);
mydelete(urehash);
}
updatecontext();
chat = irlist_get_head(&gdata.dccchats);
while (chat)
{
if (chat->status == DCCCHAT_UNUSED)
{
chat = irlist_delete(&gdata.dccchats,chat);
}
else
{
flushdccchat(chat);
chat = irlist_get_next(chat);
}
}
if (gdata.autoadd_time > 0)
{
if (changesec && ((unsigned)gdata.curtime > (lastautoadd + gdata.autoadd_time)))
{
lastautoadd = gdata.curtime;
autoadd_all();
}
}
/* END */
updatecontext();
if (gdata.needsclear) drawbot();
changehour=changemin=0;
}
static void ir_parseline2(ir_parseline_t *ipl)
{
channel_t *ch;
char *nick;
char *part3a;
char *t;
unsigned int i;
caps(ipl->part[1]);
/* NOTICE nick */
if (!strcmp(ipl->part[1], "NOTICE")) {
if (gnetwork->caps_nick && ipl->part[2]) {
if (!strcmp(caps(ipl->part[2]), gnetwork->caps_nick)) {
/* nickserv */
identify_check(ipl->line);
#ifdef USE_RUBY
if (do_myruby_notice(ipl->line) == 0)
#endif /* USE_RUBY */
privmsgparse(0, 0, ipl->line);
}
}
}
/* PRIVMSG */
if (!strcmp(ipl->part[1], "PRIVMSG")) {
#ifndef WITHOUT_BLOWFISH
char *line2;
line2 = test_fish_message(ipl->line, ipl->part[2], ipl->part[3], ipl->part[4]);
if (line2) {
#ifdef USE_RUBY
if (do_myruby_privmsg(line2) == 0)
#endif /* USE_RUBY */
privmsgparse(1, 1, line2);
mydelete(line2);
} else {
#endif /* WITHOUT_BLOWFISH */
#ifdef USE_RUBY
if (do_myruby_privmsg(ipl->line) == 0)
#endif /* USE_RUBY */
privmsgparse(1, 0, ipl->line);
#ifndef WITHOUT_BLOWFISH
}
#endif /* WITHOUT_BLOWFISH */
}
/* :server 001 xxxx :welcome.... */
if ( !strcmp(ipl->part[1], "001") ) {
irc_001(ipl);
return;
}
/* :server 005 xxxx aaa bbb=x ccc=y :are supported... */
if ( !strcmp(ipl->part[1], "005") ) {
irc_005(ipl);
return;
}
/* :server 401 botnick usernick :No such nick/channel */
if ( !strcmp(ipl->part[1], "401") ) {
if (ipl->part[2] && ipl->part[3]) {
if (!strcmp(ipl->part[2], "*")) {
lost_nick(ipl->part[3]);
}
}
return;
}
/* :server 433 old new :Nickname is already in use. */
if ( !strcmp(ipl->part[1], "433") ) {
if (ipl->part[2] && ipl->part[3]) {
if (!strcmp(ipl->part[2], "*")) {
ioutput(OUT_S|OUT_L, COLOR_NO_COLOR,
"Nickname %s already in use on %s, trying %s%u",
ipl->part[3],
gnetwork->name,
get_config_nick(),
gnetwork->nick_number);
/* generate new nick and retry */
writeserver(WRITESERVER_NORMAL, "NICK %s%u",
get_config_nick(),
(gnetwork->nick_number)++);
}
}
return;
}
/* :server 470 botnick #channel :(you are banned) transfering you to #newchannel */
if ( !strcmp(ipl->part[1], "470") ) {
if (ipl->part[2] && ipl->part[3]) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"channel on %s: %s", gnetwork->name, strstr(ipl->line, "470"));
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(caps(ipl->part[2]), gnetwork->caps_nick))
continue;
if (strcmp(caps(ipl->part[3]), ch->name))
continue;
ch->flags |= CHAN_KICKED;
}
}
return;
}
/* names list for a channel */
/* :server 353 our_nick = #channel :nick @nick +nick nick */
if ( !strcmp(ipl->part[1], "353") ) {
if (ipl->part[2] && ipl->part[3] && ipl->part[5]) {
caps(ipl->part[4]);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(ipl->part[4], ch->name) != 0)
continue;
for (i=0; (t = getpart(ipl->line, 6+i)); ++i) {
addtomemberlist(ch, i == 0 ? t+1 : t);
mydelete(t);
}
return;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Got name data for %s which is not a known channel on %s!",
ipl->part[4], gnetwork->name);
writeserver(WRITESERVER_NORMAL, "PART %s", ipl->part[4]);
}
return;
}
if (gnetwork->lastping != 0) {
if (strcmp(ipl->part[1], "PONG") == 0) {
lag_message();
return;
}
}
#if PING_SRVR
/* server ping */
if (strncmp(ipl->line, "PING :", 6) == 0) {
if (gdata.debug > 0)
ioutput(OUT_S, COLOR_NO_COLOR,
"Server Ping on %s: %s",
gnetwork->name, ipl->line);
writeserver(WRITESERVER_NOW, "PO%s", ipl->line+2);
return;
}
#endif
/* QUIT */
if (strcmp(ipl->part[1], "QUIT") == 0) {
if (gnetwork->caps_nick) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we quit? */
outerror(OUTERROR_TYPE_WARN_LOUD,
"Forced quit on %s: %s", gnetwork->name, ipl->line);
close_server();
clean_send_buffers();
/* do not reconnect */
gnetwork->serverstatus = SERVERSTATUS_EXIT;
} else {
/* someone else quit */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
removefrommemberlist(ch, nick);
}
reverify_restrictsend();
}
mydelete(nick);
}
return;
}
/* MODE #channel +x ... */
if (strcmp(ipl->part[1], "MODE") == 0) {
if (ipl->part[2] && ipl->part[3]) {
/* find channel */
for (ch = irlist_get_head(&(gnetwork->channels)); ch; ch = irlist_get_next(ch)) {
char *ptr;
unsigned int plus;
unsigned int part;
unsigned int ii;
if (strcasecmp(ch->name, ipl->part[2]) != 0)
continue;
plus = 0;
part = 4;
for (ptr = ipl->part[3]; *ptr; ++ptr) {
if (*ptr == '+') {
plus = 1;
} else if (*ptr == '-') {
plus = 0;
} else {
for (ii = 0; (ii < MAX_PREFIX && gnetwork->prefixes[ii].p_mode); ++ii) {
if (*ptr == gnetwork->prefixes[ii].p_mode) {
/* found a nick mode */
nick = getpart(ipl->line, ++part);
if (nick) {
if (nick[strlen(nick)-1] == IRCCTCP) {
nick[strlen(nick)-1] = '\0';
}
if (plus == 0) {
if (strcasecmp(nick, get_config_nick()) == 0) {
identify_needed(0);
}
}
changeinmemberlist_mode(ch, nick,
gnetwork->prefixes[ii].p_symbol,
plus);
mydelete(nick);
}
break;
}
}
for (ii = 0; (ii < MAX_CHANMODES && gnetwork->chanmodes[ii]); ++ii) {
if (*ptr == gnetwork->chanmodes[ii]) {
/* found a channel mode that has an argument */
++part;
break;
}
}
}
}
return;
}
if (strcasecmp(ipl->part[2], get_config_nick()) == 0) {
if (ipl->part[3][0] == '-') {
identify_needed(0);
}
}
}
return;
}
if (ipl->part[2] && ipl->part[2][0] == ':') {
part3a = ipl->part[2] + 1;
} else {
part3a = ipl->part[2];
}
/* JOIN */
if (strcmp(ipl->part[1], "JOIN") == 0) {
if (gnetwork->caps_nick && part3a) {
caps(part3a);
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we joined */
/* clear now, we have succesfully logged in */
gnetwork->serverconnectbackoff = 0;
ioutput(OUT_S|OUT_L|OUT_D, COLOR_NO_COLOR,
"Joined %s on %s", part3a, gnetwork->name);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
ch->flags |= CHAN_ONCHAN;
ch->lastjoin = gdata.curtime;
ch->nextann = gdata.curtime + gdata.waitafterjoin;
ch->nextmsg = gdata.curtime + gdata.waitafterjoin;
if (ch->joinmsg) {
writeserver(WRITESERVER_NOW, "PRIVMSG %s :%s", ch->name, ch->joinmsg);
}
gnetwork->botstatus = BOTSTATUS_JOINED;
start_sends();
mydelete(nick);
return;
}
} else {
/* someone else joined */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
addtomemberlist(ch, nick);
mydelete(nick);
return;
}
}
ir_unknown_channel(part3a);
mydelete(nick);
}
return;
}
/* PART */
if (strcmp(ipl->part[1], "PART") == 0) {
if (gnetwork->caps_nick && part3a) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we left? */
mydelete(nick);
return;
} else {
/* someone else left */
caps(part3a);
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
removefrommemberlist(ch, nick);
mydelete(nick);
reverify_restrictsend();
return;
}
}
ir_unknown_channel(part3a);
mydelete(nick);
}
return;
}
/* NICK */
if (strcmp(ipl->part[1], "NICK") == 0) {
if (gnetwork->caps_nick && part3a) {
nick = ir_get_nickarg(ipl->line);
if (!strcmp(caps(nick), gnetwork->caps_nick)) {
/* we changed, update nick */
mydelete(gnetwork->user_nick);
mydelete(gnetwork->caps_nick);
gnetwork->user_nick = mystrdup(part3a);
gnetwork->caps_nick = mystrdup(part3a);
caps(gnetwork->caps_nick);
gnetwork->nick_number = 0;
++(gdata.needsclear);
identify_needed(0);
} else {
/* someone else has a new nick */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
changeinmemberlist_nick(ch, nick, part3a);
}
user_changed_nick(nick, part3a);
}
mydelete(nick);
}
return;
}
/* KICK */
if (strcmp(ipl->part[1], "KICK") == 0) {
if (gnetwork->caps_nick && part3a && ipl->part[3]) {
caps(part3a);
if (!strcmp(caps(ipl->part[3]), gnetwork->caps_nick)) {
/* we were kicked */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
if (gdata.noautorejoin) {
outerror(OUTERROR_TYPE_WARN_LOUD,
"Kicked on %s: %s", gnetwork->name, ipl->line);
ch->flags |= CHAN_KICKED;
clearmemberlist(ch);
reverify_restrictsend();
} else {
outerror(OUTERROR_TYPE_WARN_LOUD,
"Kicked on %s, Rejoining: %s", gnetwork->name, ipl->line);
ch->flags &= ~CHAN_ONCHAN;
joinchannel(ch);
}
}
} else {
/* someone else was kicked */
for (ch = irlist_get_head(&(gnetwork->channels));
ch;
ch = irlist_get_next(ch)) {
if (strcmp(part3a, ch->name) != 0)
continue;
removefrommemberlist(ch, ipl->part[3]);
reverify_restrictsend();
return;
}
}
}
return;
}
/* ERROR :Closing Link */
if (strncmp(ipl->line, "ERROR :Closing Link", strlen("ERROR :Closing Link")) == 0) {
if (gdata.exiting) {
gnetwork->recentsent = 0;
return;
}
ioutput(OUT_S|OUT_L|OUT_D, COLOR_RED,
"Server Closed Connection on %s: %s",
gnetwork->name, ipl->line);
close_server();
return;
}
}
