/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * Inspire is copyright (C) 2002-2003 ChatSpike-Dev. * E-mail: * * * * Written by Craig Edwards, Craig McLure, and others. * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- $Log$ Revision 1.4 2003/01/26 20:15:03 brain Added server classes for linking Revision 1.3 2003/01/25 20:17:53 brain Fixed WHOWAS memory leak Revision 1.2 2003/01/25 20:00:45 brain Added /WHOWAS Revision 1.1.1.1 2003/01/23 19:45:58 brain InspIRCd second source tree Revision 1.56 2003/01/22 20:49:16 brain Added FileReader file-caching class Changed m_randquote to use FileReader class Revision 1.55 2003/01/21 16:56:19 brain Fixed a few minor bugs Revision 1.54 2003/01/21 02:07:10 brain optimisations galore! Revision 1.53 2003/01/21 00:18:40 brain fixed random crash on kill_link (AGAIN) - was /stats improved speed 10x (because i can...) Revision 1.52 2003/01/19 20:12:24 brain Fixed ident max length to 10 Revision 1.51 2003/01/18 22:02:11 brain fixed multiple /MODE +l bugs (thanks to akky and BOFH bugging meh!) Revision 1.50 2003/01/18 01:19:14 brain Added code to tidy up bans (e.g. max nick length) - i blame mIRC! Revision 1.49 2003/01/17 22:03:57 brain Fixed dodgy mode glitches (the ones Craig loves to play with, awww) Revision 1.48 2003/01/17 21:20:43 brain Implemented usermode +s Revision 1.47 2003/01/17 21:13:40 brain Added channel modes, +k, +l, +i, +m etc Added user and channel modes +i, +p, +s Revision 1.46 2003/01/17 18:44:27 brain Implemented channel mode +m Revision 1.45 2003/01/17 18:26:42 brain added /TRACE command Revision 1.44 2003/01/17 15:21:03 brain Fixed: /LUSERS cant count :P Revision 1.43 2003/01/17 13:21:38 brain Added CONNECT ALLOW and CONNECT DENY config tags Added PASS command Revision 1.42 2003/01/17 10:37:55 brain Added /INVITE command and relevent structures Revision 1.41 2003/01/16 20:11:55 brain fixed some ugly pointer bugs (thanks dblack and a|KK|y!) Revision 1.40 2003/01/16 08:31:44 brain Fixed parameter error in QUIT code (was showing junk chars on BSD) Revision 1.39 2003/01/15 22:47:44 brain Changed user and channel structs to classes (finally) Revision 1.38 2003/01/15 20:56:58 brain Added wildcard support Added channel bans Revision 1.37 2003/01/15 16:08:42 brain Attempted to fix closed client sessions not being detected Revision 1.36 2003/01/15 09:36:13 brain added pause= value to /die and /restart in config Revision 1.35 2003/01/14 22:08:31 brain attemted to fix weird crash on /kill Revision 1.34 2003/01/14 21:44:25 brain Added /USERS stub Added /SUMMON stub Changed optimisation to -O3 (much faster!) Revision 1.33 2003/01/14 21:14:30 brain added /ISON command (for mIRC etc basic notify) Revision 1.32 2003/01/14 20:55:02 brain Fixed more param crunching bugs Added /AWAY Revision 1.31 2003/01/14 00:46:02 brain Added m_cloaking.so module, provides host masking Revision 1.30 2003/01/13 22:30:50 brain Added Admin class (holds /admin info for modules) Added methods to Server class Revision 1.29 2003/01/13 00:43:29 brain Added Server class Added more code to example module demonstrating use of Server class Revision 1.28 2003/01/12 17:40:44 brain ./configure improved by Craig (better prompts, dir creation) '/stats z' added detail Revision 1.27 2003/01/12 16:49:53 brain Added '/stats z' Revision 1.26 2003/01/12 15:01:18 brain Added hostname/ip caching to speed up connects Revision 1.25 2003/01/11 21:39:57 brain Made ircd cache message of the day in a vector (faster!) Added support for multiple lines of /NAMES on large channels Revision 1.24 2003/01/11 19:00:10 brain Added /USERHOST command Revision 1.23 2003/01/11 17:57:28 brain Added '/STATS O' Added more module error checking Revision 1.22 2003/01/11 00:48:44 brain removed random debug output Revision 1.21 2003/01/11 00:06:46 brain Fixed random crash on nickchange Fine tuned ability to handle >300 users Revision 1.20 2003/01/09 22:24:59 brain added '/stats L' (connect-info) Revision 1.19 2003/01/09 21:38:51 brain '/stats u' support added (server uptime) Revision 1.18 2003/01/09 21:09:50 brain added '/stats M' command Revision 1.17 2003/01/08 22:11:38 brain Added extra dynamic module support, new methods to Module class Revision 1.16 2003/01/08 17:48:48 brain fixed "user lingering" problem in kill_link Revision 1.15 2003/01/07 23:17:51 brain Fixed wallops and command parameter counting bugs Revision 1.14 2003/01/07 20:47:34 brain Fixes random crash on nickchange (must keep classfactory pointers!) Revision 1.13 2003/01/07 19:57:56 brain Dynamix module support, preliminary release Revision 1.12 2003/01/07 01:01:30 brain Changed command table to a vector of command_t types Revision 1.11 2003/01/06 23:43:30 brain extra debug output Revision 1.10 2003/01/06 23:38:29 brain just playing with header tags * --------------------------------------------------- */ /* Now with added unF! ;) */ #include "inspircd.h" #include "inspircd_io.h" #include "inspircd_util.h" #include "inspircd_config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "users.h" #include "servers.h" #include "ctables.h" #include "globals.h" #include "modules.h" #include "dynamic.h" #include "wildcard.h" using namespace std; char ServerName[MAXBUF]; char Network[MAXBUF]; char ServerDesc[MAXBUF]; char AdminName[MAXBUF]; char AdminEmail[MAXBUF]; char AdminNick[MAXBUF]; char diepass[MAXBUF]; char restartpass[MAXBUF]; char motd[MAXBUF]; char rules[MAXBUF]; char list[MAXBUF]; char PrefixQuit[MAXBUF]; char DieValue[MAXBUF]; int debugging = 0; int MODCOUNT = -1; int WHOWAS_STALE = 48; // default WHOWAS Entries last 2 days before they go 'stale' int WHOWAS_MAX = 100; // default 100 people maximum in the WHOWAS list int DieDelay = 5; time_t startup_time = time(NULL); template<> struct hash { size_t operator()(const struct in_addr &a) const { size_t q; memcpy(&q,&a,sizeof(size_t)); return q; } }; template<> struct hash { size_t operator()(const string &s) const { char a[MAXBUF]; static struct hash strhash; strcpy(a,s.c_str()); strlower(a); return strhash(a); } }; struct StrHashComp { bool operator()(const string& s1, const string& s2) const { char a[MAXBUF],b[MAXBUF]; strcpy(a,s1.c_str()); strcpy(b,s2.c_str()); return (strcasecmp(a,b) == 0); } }; struct InAddr_HashComp { bool operator()(const in_addr &s1, const in_addr &s2) const { size_t q; size_t p; memcpy(&q,&s1,sizeof(size_t)); memcpy(&p,&s2,sizeof(size_t)); return (q == p); } }; typedef hash_map, StrHashComp> user_hash; typedef hash_map, StrHashComp> chan_hash; typedef hash_map, InAddr_HashComp> address_cache; typedef deque command_table; typedef DLLFactory ircd_module; user_hash clientlist; chan_hash chanlist; user_hash whowas; server_list servers; command_table cmdlist; file_cache MOTD; file_cache RULES; address_cache IP; vector modules(255); vector factory(255); ClassVector Classes; struct linger linger = { 0 }; char bannerBuffer[MAXBUF]; int boundPortCount = 0; /* prototypes */ int has_channel(userrec *u, chanrec *c); int usercount(chanrec *c); int usercount_i(chanrec *c); void update_stats_l(int fd,int data_out); char* Passwd(userrec *user); bool IsDenied(userrec *user); void AddWhoWas(userrec* u); void safedelete(userrec *p) { if (p) { debug("deleting %s %s %s %s",p->nick,p->ident,p->dhost,p->fullname); debug("safedelete(userrec*): pointer is safe to delete"); delete p; } else { debug("safedelete(userrec*): unsafe pointer operation squished"); } } void safedelete(chanrec *p) { if (p) { delete p; debug("safedelete(chanrec*): pointer is safe to delete"); } else { debug("safedelete(chanrec*): unsafe pointer operation squished"); } } /* chop a string down to 512 characters and preserve linefeed (irc max * line length) */ void chop(char* str) { if (strlen(str) > 512) { str[510] = '\r'; str[511] = '\n'; str[512] = '\0'; } } string getservername() { return ServerName; } string getnetworkname() { return Network; } string getadminname() { return AdminName; } string getadminemail() { return AdminEmail; } string getadminnick() { return AdminNick; } void debug(char *text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; FILE *f; time_t rawtime; struct tm * timeinfo; time(&rawtime); timeinfo = localtime (&rawtime); if (debugging) { f = fopen("ircd.log","a+"); if (f) { char b[MAXBUF]; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); strcpy(b,asctime(timeinfo)); b[strlen(b)-1] = ':'; fprintf(f,"%s %s\n",b,textbuffer); fclose(f); } else { printf("Can't write log file, bailing!!!"); Exit(ERROR); } } } void readfile(file_cache &F, const char* fname) { FILE* file; char linebuf[MAXBUF]; debug("readfile: loading %s",fname); F.clear(); file = fopen(fname,"r"); if (file) { while (!feof(file)) { fgets(linebuf,sizeof(linebuf),file); linebuf[strlen(linebuf)-1]='\0'; if (!strcmp(linebuf,"")) { strcpy(linebuf," "); } if (!feof(file)) { F.push_back(linebuf); } } fclose(file); } else { debug("readfile: failed to load file: %s",fname); } debug("readfile: loaded %s, %d lines",fname,F.size()); } void ReadConfig(void) { char dbg[MAXBUF],pauseval[MAXBUF],Value[MAXBUF]; ConnectClass c; ConfValue("server","name",0,ServerName); ConfValue("server","description",0,ServerDesc); ConfValue("server","network",0,Network); ConfValue("admin","name",0,AdminName); ConfValue("admin","email",0,AdminEmail); ConfValue("admin","nick",0,AdminNick); ConfValue("files","motd",0,motd); ConfValue("files","rules",0,rules); ConfValue("power","diepass",0,diepass); ConfValue("power","pause",0,pauseval); ConfValue("power","restartpass",0,restartpass); ConfValue("options","prefixquit",0,PrefixQuit); ConfValue("die","value",0,DieValue); ConfValue("options","debug",0,dbg); debugging = 0; if (!strcmp(dbg,"on")) { debugging = 1; } DieDelay = atoi(pauseval); readfile(MOTD,motd); readfile(RULES,rules); debug("Reading connect classes"); Classes.clear(); for (int i = 0; i < ConfValueEnum("connect"); i++) { strcpy(Value,""); ConfValue("connect","allow",i,Value); if (strcmp(Value,"")) { strcpy(c.host,Value); c.type = CC_ALLOW; strcpy(Value,""); ConfValue("connect","password",i,Value); strcpy(c.pass,Value); Classes.push_back(c); debug("Read connect class type ALLOW, host=%s password=%s",c.host,c.pass); } else { ConfValue("connect","deny",i,Value); strcpy(c.host,Value); c.type = CC_DENY; Classes.push_back(c); debug("Read connect class type DENY, host=%s",c.host); } } } void Blocking(int s) { int flags; debug("Blocking: %d",s); flags = fcntl(s, F_GETFL, 0); fcntl(s, F_SETFL, flags ^ O_NONBLOCK); } void NonBlocking(int s) { int flags; debug("NonBlocking: %d",s); flags = fcntl(s, F_GETFL, 0); fcntl(s, F_SETFL, flags | O_NONBLOCK); } int CleanAndResolve (char *resolvedHost, const char *unresolvedHost) { struct hostent *hostPtr = NULL; struct in_addr addr; memset (resolvedHost, '\0',MAXBUF); if(unresolvedHost == NULL) return(ERROR); if ((inet_aton(unresolvedHost,&addr)) == 0) return(ERROR); hostPtr = gethostbyaddr ((char *)&addr.s_addr,sizeof(addr.s_addr),AF_INET); if (hostPtr != NULL) snprintf(resolvedHost,MAXBUF,"%s",hostPtr->h_name); else snprintf(resolvedHost,MAXBUF,"%s",unresolvedHost); return (TRUE); } /* write formatted text to a socket, in same format as printf */ void Write(int sock,char *text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; char tb[MAXBUF]; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); sprintf(tb,"%s\r\n",textbuffer); chop(tb); write(sock,tb,strlen(tb)); update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */ } /* write a server formatted numeric response to a single socket */ void WriteServ(int sock, char* text, ...) { char textbuffer[MAXBUF],tb[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); sprintf(tb,":%s %s\r\n",ServerName,textbuffer); chop(tb); write(sock,tb,strlen(tb)); update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */ } /* write text from an originating user to originating user */ void WriteFrom(int sock, userrec *user,char* text, ...) { char textbuffer[MAXBUF],tb[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); sprintf(tb,":%s!%s@%s %s\r\n",user->nick,user->ident,user->dhost,textbuffer); chop(tb); write(sock,tb,strlen(tb)); update_stats_l(sock,strlen(tb)); /* add one line-out to stats L for this fd */ } /* write text to an destination user from a source user (e.g. user privmsg) */ void WriteTo(userrec *source, userrec *dest,char *data, ...) { char textbuffer[MAXBUF],tb[MAXBUF]; va_list argsPtr; va_start (argsPtr, data); if ((!dest) || (!source)) { return; } vsnprintf(textbuffer, MAXBUF, data, argsPtr); va_end(argsPtr); chop(tb); WriteFrom(dest->fd,source,"%s",textbuffer); } /* write formatted text from a source user to all users on a channel * including the sender (NOT for privmsg, notice etc!) */ void WriteChannel(chanrec* Ptr, userrec* user, char* text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (has_channel(i->second,Ptr)) { WriteTo(user,i->second,"%s",textbuffer); } } } /* write formatted text from a source user to all users on a channel except * for the sender (for privmsg etc) */ void ChanExceptSender(chanrec* Ptr, userrec* user, char* text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (has_channel(i->second,Ptr) && (user != i->second)) { WriteTo(user,i->second,"%s",textbuffer); } } } int c_count(userrec* u) { int z = 0; for (int i =0; i != MAXCHANS; i++) if (u->chans[i].channel) z++; return z; } /* return 0 or 1 depending if users u and u2 share one or more common channels * (used by QUIT, NICK etc which arent channel specific notices) */ int common_channels(userrec *u, userrec *u2) { int i = 0; int z = 0; if ((!u) || (!u2)) { return 0; } for (i = 0; i != MAXCHANS; i++) { for (z = 0; z != MAXCHANS; z++) { if ((u->chans[i].channel == u2->chans[z].channel) && (u->chans[i].channel) && (u2->chans[z].channel) && (u->registered == 7) && (u2->registered == 7)) { if ((c_count(u)) && (c_count(u2))) { return 1; } } } } return 0; } /* write a formatted string to all users who share at least one common * channel, including the source user e.g. for use in NICK */ void WriteCommon(userrec *u, char* text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); WriteFrom(u->fd,u,"%s",textbuffer); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (common_channels(u,i->second) && (i->second != u)) { WriteFrom(i->second->fd,u,"%s",textbuffer); } } } /* write a formatted string to all users who share at least one common * channel, NOT including the source user e.g. for use in QUIT */ void WriteCommonExcept(userrec *u, char* text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((common_channels(u,i->second)) && (u != i->second)) { WriteFrom(i->second->fd,u,"%s",textbuffer); } } } void WriteOpers(char* text, ...) { char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (strchr(i->second->modes,'o')) { if (strchr(i->second->modes,'s')) { // send server notices to all with +s // (TODO: needs SNOMASKs) WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,textbuffer); } } } } void WriteWallOps(userrec *source, char* text, ...) { int i = 0; char textbuffer[MAXBUF]; va_list argsPtr; va_start (argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (strchr(i->second->modes,'w')) { WriteTo(source,i->second,"WALLOPS %s",textbuffer); } } } /* convert a string to lowercase. Note following special circumstances * taken from RFC 1459. Many "official" server branches still hold to this * rule so i will too; * * Because of IRC's scandanavian origin, the characters {}| are * considered to be the lower case equivalents of the characters []\, * respectively. This is a critical issue when determining the * equivalence of two nicknames. */ void strlower(char *n) { if (!n) { return; } for (int i = 0; i != strlen(n); i++) { n[i] = tolower(n[i]); if (n[i] == '[') n[i] = '{'; if (n[i] == ']') n[i] = '}'; if (n[i] == '\\') n[i] = '|'; } } /* verify that a user's nickname is valid */ int isnick(const char* n) { int i = 0; char v[MAXBUF]; if (!n) { return 0; } if (!strcmp(n,"")) { return 0; } if (strlen(n) > NICKMAX-1) { return 0; } for (i = 0; i != strlen(n); i++) { if ((n[i] < 33) || (n[i] > 125)) { return 0; } /* can't occur ANYWHERE in a nickname! */ if (strchr("<>,./?:;@'~#=+()*&%$£ \"!",n[i])) { return 0; } /* can't occur as the first char of a nickname... */ if ((strchr("0123456789",n[i])) && (!i)) { return 0; } } return 1; } /* Find a user record by nickname and return a pointer to it */ userrec* Find(string nick) { user_hash::iterator iter = clientlist.find(nick); if (iter == clientlist.end()) /* Couldn't find it */ return NULL; return iter->second; } void update_stats_l(int fd,int data_out) /* add one line-out to stats L for this fd */ { for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (i->second->fd == fd) { i->second->bytes_out+=data_out; i->second->cmds_out++; } } } /* find a channel record by channel name and return a pointer to it */ chanrec* FindChan(const char* chan) { chan_hash::iterator iter = chanlist.find(chan); if (iter == chanlist.end()) /* Couldn't find it */ return NULL; return iter->second; } void purge_empty_chans(void) { int go_again = 1, purge = 0; while (go_again) { go_again = 0; for (chan_hash::iterator i = chanlist.begin(); i != chanlist.end(); i++) { if (i->second) { if (!usercount(i->second)) { /* kill the record */ if (i != chanlist.end()) { debug("del_channel: destroyed: %s",i->second->name); delete i->second; chanlist.erase(i); go_again = 1; purge++; break; } } } } } debug("completed channel purge, killed %d",purge); } /* returns the status character for a given user on a channel, e.g. @ for op, * % for halfop etc. If the user has several modes set, the highest mode * the user has must be returned. */ char* cmode(userrec *user, chanrec *chan) { int i; for (i = 0; i != MAXCHANS; i++) { if ((user->chans[i].channel == chan) && (chan != NULL)) { if ((user->chans[i].uc_modes & UCMODE_OP) > 0) { return "@"; } if ((user->chans[i].uc_modes & UCMODE_HOP) > 0) { return "%"; } if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0) { return "+"; } return ""; } } } char scratch[MAXMODES]; char* chanmodes(chanrec *chan) { strcpy(scratch,""); if (chan->noexternal) { strcat(scratch,"n"); } if (chan->topiclock) { strcat(scratch,"t"); } if (strcmp(chan->key,"")) { strcat(scratch,"k"); } if (chan->limit) { strcat(scratch,"l"); } if (chan->inviteonly) { strcat(scratch,"i"); } if (chan->moderated) { strcat(scratch,"m"); } if (chan->secret) { strcat(scratch,"s"); } if (chan->c_private) { strcat(scratch,"p"); } if (strcmp(chan->key,"")) { strcat(scratch," "); strcat(scratch,chan->key); } if (chan->limit) { char foo[24]; sprintf(foo," %d",chan->limit); strcat(scratch,foo); } debug("chanmodes: %s %s",chan->name,scratch); return scratch; } /* returns the status value for a given user on a channel, e.g. STATUS_OP for * op, STATUS_VOICE for voice etc. If the user has several modes set, the * highest mode the user has must be returned. */ int cstatus(userrec *user, chanrec *chan) { int i; for (i = 0; i != MAXCHANS; i++) { if ((user->chans[i].channel == chan) && (chan != NULL)) { if ((user->chans[i].uc_modes & UCMODE_OP) > 0) { return STATUS_OP; } if ((user->chans[i].uc_modes & UCMODE_HOP) > 0) { return STATUS_HOP; } if ((user->chans[i].uc_modes & UCMODE_VOICE) > 0) { return STATUS_VOICE; } return STATUS_NORMAL; } } } /* compile a userlist of a channel into a string, each nick seperated by * spaces and op, voice etc status shown as @ and + */ void userlist(userrec *user,chanrec *c) { sprintf(list,"353 %s = %s :", user->nick, c->name); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (has_channel(i->second,c)) { if (isnick(i->second->nick)) { if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i'))) { /* user is +i, and source not on the channel, does not show * nick in NAMES list */ continue; } strcat(list,cmode(i->second,c)); strcat(list,i->second->nick); strcat(list," "); if (strlen(list)>(480-NICKMAX)) { /* list overflowed into * multiple numerics */ WriteServ(user->fd,list); sprintf(list,"353 %s = %s :", user->nick, c->name); } } } } /* if whats left in the list isnt empty, send it */ if (list[strlen(list)-1] != ':') { WriteServ(user->fd,list); } } /* return a count of the users on a specific channel accounting for * invisible users who won't increase the count. e.g. for /LIST */ int usercount_i(chanrec *c) { int i = 0; int count = 0; strcpy(list,""); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (has_channel(i->second,c)) { if (isnick(i->second->nick)) { if ((!has_channel(i->second,c)) && (strchr(i->second->modes,'i'))) { /* user is +i, and source not on the channel, does not show * nick in NAMES list */ continue; } count++; } } } debug("usercount_i: %s %d",c->name,count); return count; } int usercount(chanrec *c) { int i = 0; int count = 0; strcpy(list,""); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (has_channel(i->second,c)) { if (isnick(i->second->nick)) { count++; } } } debug("usercount: %s %d",c->name,count); return count; } /* add a channel to a user, creating the record for it if needed and linking * it to the user record */ chanrec* add_channel(userrec *user, char* cname, char* key) { int i = 0; chanrec* Ptr; int created = 0; if ((!cname) || (!user)) { return NULL; } if (strlen(cname) > CHANMAX-1) { cname[CHANMAX-1] = '\0'; } debug("add_channel: %s %s",user->nick,cname); if ((has_channel(user,FindChan(cname))) && (FindChan(cname))) { return NULL; // already on the channel! } if (!FindChan(cname)) { /* create a new one */ debug("add_channel: creating: %s",cname); { chanlist[cname] = new chanrec(); strcpy(chanlist[cname]->name, cname); chanlist[cname]->topiclock = 1; chanlist[cname]->noexternal = 1; chanlist[cname]->created = time(NULL); strcpy(chanlist[cname]->topic, ""); strncpy(chanlist[cname]->setby, user->nick,NICKMAX); chanlist[cname]->topicset = 0; Ptr = chanlist[cname]; debug("add_channel: created: %s",cname); /* set created to 2 to indicate user * is the first in the channel * and should be given ops */ created = 2; } } else { /* channel exists, just fish out a pointer to its struct */ Ptr = FindChan(cname); if (Ptr) { debug("add_channel: joining to: %s",Ptr->name); if (strcmp(Ptr->key,"")) { debug("add_channel: %s has key %s",Ptr->name,Ptr->key); if (!key) { debug("add_channel: no key given in JOIN"); WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name); return NULL; } else { debug("key at %p is %s",key,key); if (strcasecmp(key,Ptr->key)) { debug("add_channel: bad key given in JOIN"); WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name); return NULL; } } } if (Ptr->inviteonly) { if (user->IsInvited(Ptr->name)) { /* user was invited to channel */ /* there may be an optional channel NOTICE here */ } else { WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name); return NULL; } } if (Ptr->limit) { if (usercount(Ptr) == Ptr->limit) { WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name); return NULL; } } /* check user against the channel banlist */ for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++) { if (match(user->GetFullHost(),i->data)) { WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name); return NULL; } } user->RemoveInvite(Ptr->name); } created = 1; } for (i =0; i != MAXCHANS; i++) { if (user->chans[i].channel == NULL) { if (created == 2) { /* first user in is given ops */ user->chans[i].uc_modes = UCMODE_OP; } else { user->chans[i].uc_modes = 0; } user->chans[i].channel = Ptr; WriteChannel(Ptr,user,"JOIN :%s",Ptr->name); if (Ptr->topicset) { WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic); WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset); } userlist(user,Ptr); WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name); WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name,chanmodes(Ptr)); WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created); FOREACH_MOD OnUserJoin(user,Ptr); return Ptr; } } debug("add_channel: user channel max exceeded: %s %s",user->nick,cname); WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname); return NULL; } /* remove a channel from a users record, and remove the record from memory * if the channel has become empty */ chanrec* del_channel(userrec *user, char* cname, char* reason) { int i = 0; chanrec* Ptr; int created = 0; if ((!cname) || (!user)) { return NULL; } Ptr = FindChan(cname); if (!Ptr) { return NULL; } FOREACH_MOD OnUserPart(user,Ptr); debug("del_channel: removing: %s %s",user->nick,Ptr->name); for (i =0; i != MAXCHANS; i++) { /* zap it from the channel list of the user */ if (user->chans[i].channel == Ptr) { if (reason) { WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason); } else { WriteChannel(Ptr,user,"PART :%s",Ptr->name); } user->chans[i].uc_modes = 0; user->chans[i].channel = NULL; debug("del_channel: unlinked: %s %s",user->nick,Ptr->name); break; } } /* if there are no users left on the channel */ if (!usercount(Ptr)) { chan_hash::iterator iter = chanlist.find(Ptr->name); debug("del_channel: destroying channel: %s",Ptr->name); /* kill the record */ if (iter != chanlist.end()) { debug("del_channel: destroyed: %s",Ptr->name); delete iter->second; chanlist.erase(iter); } } } void kick_channel(userrec *src,userrec *user, chanrec *Ptr, char* reason) { int i = 0; int created = 0; if ((!Ptr) || (!user) || (!src)) { return; } debug("kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick); if (!has_channel(user,Ptr)) { WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name); return; } if ((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr))) { if (cstatus(src,Ptr) == STATUS_HOP) { WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name); } else { WriteServ(src->fd,"482 %s %s :You must be at least a half-operator",src->nick, Ptr->name); } return; } for (i =0; i != MAXCHANS; i++) { /* zap it from the channel list of the user */ if (user->chans[i].channel == Ptr) { WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason); user->chans[i].uc_modes = 0; user->chans[i].channel = NULL; debug("del_channel: unlinked: %s %s",user->nick,Ptr->name); break; } } /* if there are no users left on the channel */ if (!usercount(Ptr)) { chan_hash::iterator iter = chanlist.find(Ptr->name); debug("del_channel: destroying channel: %s",Ptr->name); /* kill the record */ if (iter != chanlist.end()) { debug("del_channel: destroyed: %s",Ptr->name); delete iter->second; chanlist.erase(iter); } } } /* returns 1 if user u has channel c in their record, 0 if not */ int has_channel(userrec *u, chanrec *c) { int i = 0; if (!u) { return 0; } for (i =0; i != MAXCHANS; i++) { if (u->chans[i].channel == c) { return 1; } } return 0; } int give_ops(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status != STATUS_OP) { WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name); return 0; } else { if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } d = Find(dest); if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if (d->chans[i].uc_modes & UCMODE_OP) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_OP; debug("gave ops: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } int give_hops(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status != STATUS_OP) { WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name); return 0; } else { d = Find(dest); if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if (d->chans[i].uc_modes & UCMODE_HOP) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_HOP; debug("gave h-ops: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } int give_voice(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status < STATUS_HOP) { WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, chan->name); return 0; } else { d = Find(dest); if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if (d->chans[i].uc_modes & UCMODE_VOICE) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes = d->chans[i].uc_modes | UCMODE_VOICE; debug("gave voice: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } int take_ops(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status != STATUS_OP) { WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name); return 0; } else { d = Find(dest); if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if ((d->chans[i].uc_modes & UCMODE_OP) == 0) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes ^= UCMODE_OP; debug("took ops: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } int take_hops(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status != STATUS_OP) { WriteServ(user->fd,"482 %s %s :You're not a channel operator",user->nick, chan->name); return 0; } else { d = Find(dest); if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if ((d->chans[i].uc_modes & UCMODE_HOP) == 0) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes ^= UCMODE_HOP; debug("took h-ops: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } int take_voice(userrec *user,char *dest,chanrec *chan,int status) { userrec *d; int i; if ((!user) || (!dest) || (!chan)) { return 0; } if (status < STATUS_HOP) { WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, chan->name); return 0; } else { d = Find(dest); if (!isnick(dest)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } if (!d) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, dest); return 0; } else { for (i = 0; i != MAXCHANS; i++) { if ((d->chans[i].channel == chan) && (chan != NULL)) { if ((d->chans[i].uc_modes & UCMODE_VOICE) == 0) { /* mode already set on user, dont allow multiple */ return 0; } d->chans[i].uc_modes ^= UCMODE_VOICE; debug("took voice: %s %s",d->chans[i].channel->name,d->nick); } } } } return 1; } void TidyBan(char *ban) { char temp[MAXBUF],NICK[MAXBUF],IDENT[MAXBUF],HOST[MAXBUF]; strcpy(temp,ban); char* pos_of_pling = strchr(temp,'!'); char* pos_of_at = strchr(temp,'@'); pos_of_pling[0] = '\0'; pos_of_at[0] = '\0'; pos_of_pling++; pos_of_at++; strncpy(NICK,temp,NICKMAX); strncpy(IDENT,pos_of_pling,IDENTMAX+1); strncpy(HOST,pos_of_at,160); sprintf(ban,"%s!%s@%s",NICK,IDENT,HOST); } int add_ban(userrec *user,char *dest,chanrec *chan,int status) { BanItem b; if ((!user) || (!dest) || (!chan)) return 0; if (strchr(dest,'!')==0) return 0; if (strchr(dest,'@')==0) return 0; for (int i = 0; i < strlen(dest); i++) if (dest[i] < 32) return 0; for (int i = 0; i < strlen(dest); i++) if (dest[i] > 126) return 0; int c = 0; for (int i = 0; i < strlen(dest); i++) if (dest[i] == '!') c++; if (c>1) return 0; c = 0; for (int i = 0; i < strlen(dest); i++) if (dest[i] == '@') c++; if (c>1) return 0; debug("add_ban: %s %s",chan->name,user->nick); TidyBan(dest); for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++) { if (!strcasecmp(i->data,dest)) { // dont allow a user to set the same ban twice return 0; } } b.set_time = time(NULL); strncpy(b.data,dest,MAXBUF); strncpy(b.set_by,user->nick,NICKMAX); chan->bans.push_back(b); return 1; } int take_ban(userrec *user,char *dest,chanrec *chan,int status) { if ((!user) || (!dest) || (!chan)) { return 0; } debug("del_ban: %s %s",chan->name,user->nick); for (BanList::iterator i = chan->bans.begin(); i != chan->bans.end(); i++) { if (!strcasecmp(i->data,dest)) { chan->bans.erase(i); return 1; } } return 0; } void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int pcnt) { char modelist[MAXBUF]; char outlist[MAXBUF]; char outstr[MAXBUF]; char outpars[32][MAXBUF]; int param = 2; int pc = 0; int ptr = 0; int mdir = 1; int r = 0; bool k_set = false, l_set = false; if (pcnt < 2) { return; } debug("process_modes: start"); strcpy(modelist,parameters[1]); /* mode list, e.g. +oo-o */ /* parameters[2] onwards are parameters for * modes that require them :) */ strcpy(outlist,"+"); mdir = 1; debug("process_modes: modelist: %s",modelist); for (ptr = 0; ptr < strlen(modelist); ptr++) { r = 0; { debug("process_modes: modechar: %c",modelist[ptr]); switch (modelist[ptr]) { case '-': if (mdir != 0) { if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-')) { outlist[strlen(outlist)-1] = '-'; } else { strcat(outlist,"-"); } } mdir = 0; break; case '+': if (mdir != 1) { if ((outlist[strlen(outlist)-1] == '+') || (outlist[strlen(outlist)-1] == '-')) { outlist[strlen(outlist)-1] = '+'; } else { strcat(outlist,"+"); } } mdir = 1; break; case 'o': if ((param >= pcnt)) break; if (mdir == 1) { r = give_ops(user,parameters[param++],chan,status); } else { r = take_ops(user,parameters[param++],chan,status); } if (r) { strcat(outlist,"o"); strcpy(outpars[pc++],parameters[param-1]); } break; case 'h': if ((param >= pcnt)) break; if (mdir == 1) { r = give_hops(user,parameters[param++],chan,status); } else { r = take_hops(user,parameters[param++],chan,status); } if (r) { strcat(outlist,"h"); strcpy(outpars[pc++],parameters[param-1]); } break; case 'v': if ((param >= pcnt)) break; if (mdir == 1) { r = give_voice(user,parameters[param++],chan,status); } else { r = take_voice(user,parameters[param++],chan,status); } if (r) { strcat(outlist,"v"); strcpy(outpars[pc++],parameters[param-1]); } break; case 'b': if ((param >= pcnt)) break; if (mdir == 1) { r = add_ban(user,parameters[param++],chan,status); } else { r = take_ban(user,parameters[param++],chan,status); } if (r) { strcat(outlist,"b"); strcpy(outpars[pc++],parameters[param-1]); } break; case 'k': if ((param >= pcnt)) break; if (mdir == 1) { if (k_set) break; if (!strcmp(chan->key,"")) { strcat(outlist,"k"); strcpy(outpars[pc++],parameters[param++]); strcpy(chan->key,parameters[param-1]); k_set = true; } } else { /* only allow -k if correct key given */ if (strcmp(chan->key,"")) { strcat(outlist,"k"); strcpy(chan->key,""); } } break; case 'l': if (mdir == 0) { if (chan->limit) { strcat(outlist,"l"); chan->limit = 0; } } if ((param >= pcnt)) break; if (mdir == 1) { if (l_set) break; bool invalid = false; for (int i = 0; i < strlen(parameters[param]); i++) { if ((parameters[param][i] < '0') || (parameters[param][i] > '9')) { invalid = true; } } if (atoi(parameters[param]) < 1) { invalid = true; } if (invalid) break; chan->limit = atoi(parameters[param]); if (chan->limit) { strcat(outlist,"l"); strcpy(outpars[pc++],parameters[param++]); l_set = true; } } break; case 'i': if (chan->inviteonly != mdir) { strcat(outlist,"i"); } chan->inviteonly = mdir; break; case 't': if (chan->topiclock != mdir) { strcat(outlist,"t"); } chan->topiclock = mdir; break; case 'n': if (chan->noexternal != mdir) { strcat(outlist,"n"); } chan->noexternal = mdir; break; case 'm': if (chan->moderated != mdir) { strcat(outlist,"m"); } chan->moderated = mdir; break; case 's': if (chan->secret != mdir) { strcat(outlist,"s"); if (chan->c_private) { chan->c_private = 0; if (mdir) { strcat(outlist,"-p+"); } else { strcat(outlist,"+p-"); } } } chan->secret = mdir; break; case 'p': if (chan->c_private != mdir) { strcat(outlist,"p"); if (chan->secret) { chan->secret = 0; if (mdir) { strcat(outlist,"-s+"); } else { strcat(outlist,"+s-"); } } } chan->c_private = mdir; break; } } } /* this ensures only the *valid* modes are sent out onto the network */ while ((outlist[strlen(outlist)-1] == '-') || (outlist[strlen(outlist)-1] == '+')) { outlist[strlen(outlist)-1] = '\0'; } if (strcmp(outlist,"")) { strcpy(outstr,outlist); for (ptr = 0; ptr < pc; ptr++) { strcat(outstr," "); strcat(outstr,outpars[ptr]); } WriteChannel(chan,user,"MODE %s %s",chan->name,outstr); } } void handle_mode(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; userrec* dest; int can_change,i; int direction = 1; char outpars[MAXBUF]; dest = Find(parameters[0]); if ((dest) && (pcnt == 1)) { WriteServ(user->fd,"221 %s :+%s",user->nick,user->modes); return; } if ((dest) && (pcnt > 1)) { can_change = 0; if (user != dest) { if (strchr(user->modes,'o')) { can_change = 1; } } else { can_change = 1; } if (!can_change) { WriteServ(user->fd,"482 %s :Can't change mode for other users",user->nick); return; } strcpy(outpars,"+"); direction = 1; if ((parameters[1][0] != '+') && (parameters[1][0] != '-')) return; for (i = 0; i < strlen(parameters[1]); i++) { if (parameters[1][i] == '+') { if (direction != 1) { if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-')) { outpars[strlen(outpars)-1] = '+'; } else { strcat(outpars,"+"); } } direction = 1; } else if (parameters[1][i] == '-') { if (direction != 0) { if ((outpars[strlen(outpars)-1] == '+') || (outpars[strlen(outpars)-1] == '-')) { outpars[strlen(outpars)-1] = '-'; } else { strcat(outpars,"-"); } } direction = 0; } else { can_change = 0; if (strchr(user->modes,'o')) { can_change = 1; } else { if ((parameters[1][i] == 'i') || (parameters[1][i] == 'w') || (parameters[1][i] == 's')) { can_change = 1; } } if (can_change) { if (direction == 1) { if (!strchr(dest->modes,parameters[1][i])) { dest->modes[strlen(dest->modes)+1]='\0'; dest->modes[strlen(dest->modes)] = parameters[1][i]; outpars[strlen(outpars)+1]='\0'; outpars[strlen(outpars)] = parameters[1][i]; } } else { int q = 0; char temp[MAXBUF]; char moo[MAXBUF]; outpars[strlen(outpars)+1]='\0'; outpars[strlen(outpars)] = parameters[1][i]; strcpy(temp,""); for (q = 0; q < strlen(user->modes); q++) { if (user->modes[q] != parameters[1][i]) { moo[0] = user->modes[q]; moo[1] = '\0'; strcat(temp,moo); } } strcpy(user->modes,temp); } } } } if (strlen(outpars)) { char b[MAXBUF]; strcpy(b,""); int z = 0; int i = 0; while (i < strlen (outpars)) { b[z++] = outpars[i++]; b[z] = '\0'; if (inick, b); } return; } Ptr = FindChan(parameters[0]); if (Ptr) { if (pcnt == 1) { /* just /modes #channel */ WriteServ(user->fd,"324 %s %s +%s",user->nick, Ptr->name, chanmodes(Ptr)); WriteServ(user->fd,"329 %s %s %d", user->nick, Ptr->name, Ptr->created); return; } else if (pcnt == 2) { if ((!strcmp(parameters[1],"+b")) || (!strcmp(parameters[1],"b"))) { for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++) { WriteServ(user->fd,"367 %s %s %s %s %d",user->nick, Ptr->name, i->data, i->set_by, i->set_time); } WriteServ(user->fd,"368 %s %s :End of channel ban list",user->nick, Ptr->name); } } if ((cstatus(user,Ptr) < STATUS_HOP) && (Ptr)) { WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, Ptr->name); return; } process_modes(parameters,user,Ptr,cstatus(user,Ptr),pcnt); } else { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } /* This function pokes and hacks at a parameter list like the following: * * PART #winbot, #darkgalaxy :m00! * * to turn it into a series of individual calls like this: * * PART #winbot :m00! * PART #darkgalaxy :m00! * * The seperate calls are sent to a callback function provided by the caller * (the caller will usually call itself recursively). The callback function * must be a command handler. Calling this function on a line with no list causes * no action to be taken. You must provide a starting and ending parameter number * where the range of the list can be found, useful if you have a terminating * parameter as above which is actually not part of the list, or parameters * before the actual list as well. This code is used by many functions which * can function as "one to list" (see the RFC) */ int loop_call(handlerfunc fn, char **parameters, int pcnt, userrec *u, int start, int end, int joins) { char plist[MAXBUF]; char *param; char *pars[32]; char blog[32][MAXBUF]; char blog2[32][MAXBUF]; int i = 0, j = 0, q = 0, total = 0, t = 0, t2 = 0, total2 = 0; char keystr[MAXBUF]; char moo[MAXBUF]; for (i = 0; i <32; i++) strcpy(blog[i],""); for (i = 0; i <32; i++) strcpy(blog2[i],""); strcpy(moo,""); for (i = 0; i <10; i++) { if (!parameters[i]) { parameters[i] = moo; } } if (joins) { if (pcnt > 1) /* we have a key to copy */ { strcpy(keystr,parameters[1]); } } if (!parameters[start]) { return 0; } if (!strchr(parameters[start],',')) { return 0; } strcpy(plist,""); for (i = start; i <= end; i++) { if (parameters[i]) { strcat(plist,parameters[i]); } } j = 0; param = plist; t = strlen(plist); for (i = 0; i < t; i++) { if (plist[i] == ',') { plist[i] = '\0'; strcpy(blog[j++],param); param = plist+i+1; } } strcpy(blog[j++],param); total = j; if ((joins) && (keystr) && (total>0)) // more than one channel and is joining { strcat(keystr,","); } if ((joins) && (keystr)) { if (strchr(keystr,',')) { j = 0; param = keystr; t2 = strlen(keystr); for (i = 0; i < t2; i++) { if (keystr[i] == ',') { keystr[i] = '\0'; strcpy(blog2[j++],param); param = keystr+i+1; } } strcpy(blog2[j++],param); total2 = j; } } for (j = 0; j < total; j++) { if (blog[j]) { pars[0] = blog[j]; } for (q = end; q < pcnt-1; q++) { if (parameters[q+1]) { pars[q-end+1] = parameters[q+1]; } } if ((joins) && (parameters[1])) { if (pcnt > 1) { pars[1] = blog2[j]; } else { pars[1] = NULL; } } /* repeatedly call the function with the hacked parameter list */ if ((joins) && (pcnt > 1)) { if (pars[1]) { // pars[1] already set up and containing key from blog2[j] fn(pars,2,u); } else { pars[1] = parameters[1]; fn(pars,2,u); } } else { fn(pars,pcnt-(end-start),u); } } return 1; } void handle_join(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; int i = 0; if (loop_call(handle_join,parameters,pcnt,user,0,0,1)) return; if (parameters[0][0] == '#') { Ptr = add_channel(user,parameters[0],parameters[1]); } } void handle_part(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; if (pcnt > 1) { if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-2,0)) return; del_channel(user,parameters[0],parameters[1]); } else { if (loop_call(handle_part,parameters,pcnt,user,0,pcnt-1,0)) return; del_channel(user,parameters[0],NULL); } } void handle_kick(char **parameters, int pcnt, userrec *user) { chanrec* Ptr = FindChan(parameters[0]); userrec* u = Find(parameters[1]); if ((!u) || (!Ptr)) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); return; } if (!has_channel(u,Ptr)) { WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, parameters[0]); return; } if (pcnt > 2) { kick_channel(user,u,Ptr,parameters[2]); } else { kick_channel(user,u,Ptr,user->nick); } } void handle_die(char **parameters, int pcnt, userrec *user) { debug("die: %s",user->nick); if (!strcmp(parameters[0],diepass)) { WriteOpers("*** DIE command from %s!%s@%s, terminating...",user->nick,user->ident,user->host); sleep(DieDelay); Exit(ERROR); } else { WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host); } } void handle_restart(char **parameters, int pcnt, userrec *user) { debug("restart: %s",user->nick); if (!strcmp(parameters[0],restartpass)) { WriteOpers("*** RESTART command from %s!%s@%s, Pretending to restart till this is finished :D",user->nick,user->ident,user->host); sleep(DieDelay); Exit(ERROR); /* Will finish this later when i can be arsed :) */ } else { WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host); } } void kill_link(userrec *user,char* reason) { user_hash::iterator iter = clientlist.find(user->nick); debug("kill_link: %s '%s'",user->nick,reason); Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason); fdatasync(user->fd); WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason); FOREACH_MOD OnUserQuit(user); debug("closing fd %d",user->fd); /* bugfix, cant close() a nonblocking socket (sux!) */ WriteCommonExcept(user,"QUIT :%s",reason); Blocking(user->fd); close(user->fd); NonBlocking(user->fd); AddWhoWas(user); if (iter != clientlist.end()) { debug("deleting user hash value %p",iter->second); delete iter->second; clientlist.erase(iter); } purge_empty_chans(); } void handle_kill(char **parameters, int pcnt, userrec *user) { userrec *u = Find(parameters[0]); char killreason[MAXBUF]; debug("kill: %s %s",parameters[0],parameters[1]); if (u) { WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)",user->nick,u->nick,u->ident,u->host,parameters[1]); sprintf(killreason,"Killed (%s (%s))",user->nick,parameters[1]); kill_link(u,killreason); } else { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } void handle_summon(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"445 %s :SUMMON has been disabled (depreciated command)",user->nick); } void handle_users(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"445 %s :USERS has been disabled (depreciated command)",user->nick); } // looks up a users password for their connection class (/ tags) char* Passwd(userrec *user) { for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++) { if (match(user->host,i->host) && (i->type == CC_ALLOW)) { return i->pass; } } return ""; } bool IsDenied(userrec *user) { for (ClassVector::iterator i = Classes.begin(); i != Classes.end(); i++) { if (match(user->host,i->host) && (i->type == CC_DENY)) { return true; } } return false; } void handle_pass(char **parameters, int pcnt, userrec *user) { if (!strcasecmp(parameters[0],Passwd(user))) { user->haspassed = true; } } void handle_invite(char **parameters, int pcnt, userrec *user) { userrec* u = Find(parameters[0]); chanrec* c = FindChan(parameters[1]); if ((!c) || (!u)) { if (!c) { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[1]); } else { if (c->inviteonly) { WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]); } } return; } if (c->inviteonly) { if (cstatus(user,c) < STATUS_HOP) { WriteServ(user->fd,"482 %s %s :You must be at least a half-operator",user->nick, c->name); return; } u->InviteTo(c->name); WriteFrom(u->fd,user,"INVITE %s :%s",u->nick,c->name); WriteServ(user->fd,"341 %s %s %s",user->nick,u->nick,c->name); } } void handle_topic(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; if (pcnt == 1) { if (strlen(parameters[0]) <= CHANMAX) { Ptr = FindChan(parameters[0]); if (Ptr) { if (Ptr->topicset) { WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic); WriteServ(user->fd,"333 %s %s %s %d", user->nick, Ptr->name, Ptr->setby, Ptr->topicset); } else { WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name); } } else { WriteServ(user->fd,"331 %s %s :No topic is set.", user->nick, Ptr->name); } } } else if (pcnt>1) { if (loop_call(handle_topic,parameters,pcnt,user,0,pcnt-2,0)) return; if (strlen(parameters[0]) <= CHANMAX) { Ptr = FindChan(parameters[0]); if (Ptr) { if ((Ptr->topiclock) && (cstatus(user,Ptr)fd,"482 %s %s :You must be at least a half-operator", user->nick, Ptr->name); return; } strcpy(Ptr->topic,parameters[1]); strcpy(Ptr->setby,user->nick); Ptr->topicset = time(NULL); WriteChannel(Ptr,user,"TOPIC %s :%s",Ptr->name, Ptr->topic); } else { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } } } /* sends out an error notice to all connected clients (not to be used * lightly!) */ void send_error(char *s) { debug("send_error: %s",s); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { WriteServ(i->second->fd,"NOTICE %s :%s",i->second->nick,s); } } void Error(int status) { signal (SIGALRM, SIG_IGN); signal (SIGPIPE, SIG_IGN); signal (SIGTERM, SIG_IGN); signal (SIGABRT, SIG_IGN); signal (SIGSEGV, SIG_IGN); signal (SIGURG, SIG_IGN); signal (SIGKILL, SIG_IGN); debug("*** fell down a pothole in the road to perfection ***"); send_error("Error! Segmentation fault! save meeeeeeeeeeeeee *splat!*"); exit(status); } int main (int argc, char *argv[]) { Start(); debug("*** InspIRCd starting up!"); if (!CheckConfig()) { debug("main: no config"); printf("ERROR: Your config file is missing, this IRCd will self destruct in 10 seconds!\n"); Exit(ERROR); } if (InspIRCd() == ERROR) { debug("main: daemon function bailed"); printf("ERROR: could not initialise. Shutting down.\n"); Exit(ERROR); } Exit(TRUE); return 0; } template inline string ConvToStr(const T &in) { stringstream tmp; if (!(tmp << in)) return string(); return tmp.str(); } /* re-allocates a nick in the user_hash after they change nicknames, * returns a pointer to the new user as it may have moved */ userrec* ReHashNick(char* Old, char* New) { user_hash::iterator newnick; user_hash::iterator oldnick = clientlist.find(Old); debug("ReHashNick: %s %s",Old,New); if (!strcasecmp(Old,New)) { debug("old nick is new nick, skipping"); return oldnick->second; } if (oldnick == clientlist.end()) return NULL; /* doesnt exist */ debug("ReHashNick: Found hashed nick %s",Old); clientlist[New] = new userrec(); clientlist[New] = oldnick->second; /*delete oldnick->second; */ clientlist.erase(oldnick); debug("ReHashNick: Nick rehashed as %s",New); return clientlist[New]; } /* adds or updates an entry in the whowas list */ void AddWhoWas(userrec* u) { user_hash::iterator iter = whowas.find(u->nick); userrec *a = new userrec(); strcpy(a->nick,u->nick); strcpy(a->ident,u->ident); strcpy(a->dhost,u->dhost); strcpy(a->host,u->host); strcpy(a->fullname,u->fullname); strcpy(a->server,u->server); a->signon = u->signon; /* MAX_WHOWAS: max number of /WHOWAS items * WHOWAS_STALE: number of hours before a WHOWAS item is marked as stale and * can be replaced by a newer one */ if (iter == whowas.end()) { if (whowas.size() == WHOWAS_MAX) { for (user_hash::iterator i = whowas.begin(); i != whowas.end(); i++) { // 3600 seconds in an hour ;) if ((i->second->signon)<(time(NULL)-(WHOWAS_STALE*3600))) { delete i->second; i->second = a; debug("added WHOWAS entry, purged an old record"); return; } } } else { debug("added fresh WHOWAS entry"); whowas[a->nick] = a; } } else { debug("updated WHOWAS entry"); delete iter->second; iter->second = a; } } /* add a client connection to the sockets list */ void AddClient(int socket, char* host, int port, bool iscached) { int i; int blocking = 1; char resolved[MAXBUF]; string tempnick; char tn2[MAXBUF]; user_hash::iterator iter; tempnick = ConvToStr(socket) + "-unknown"; sprintf(tn2,"%d-unknown",socket); iter = clientlist.find(tempnick); if (iter != clientlist.end()) return; /* * It is OK to access the value here this way since we know * it exists, we just created it above. * * At NO other time should you access a value in a map or a * hash_map this way. */ clientlist[tempnick] = new userrec(); NonBlocking(socket); debug("AddClient: %d %s %d",socket,host,port); clientlist[tempnick]->fd = socket; strncpy(clientlist[tempnick]->nick, tn2,NICKMAX); strncpy(clientlist[tempnick]->host, host,160); strncpy(clientlist[tempnick]->dhost, host,160); strncpy(clientlist[tempnick]->server, ServerName,256); clientlist[tempnick]->registered = 0; clientlist[tempnick]->signon = time(NULL); clientlist[tempnick]->nping = time(NULL)+240; clientlist[tempnick]->lastping = 1; clientlist[tempnick]->port = port; if (iscached) { WriteServ(socket,"NOTICE Auth :Found your hostname (cached)..."); } else { WriteServ(socket,"NOTICE Auth :Looking up your hostname..."); } if (clientlist.size() == MAXCLIENTS) kill_link(clientlist[tempnick],"No more connections allowed in this class"); } void handle_names(char **parameters, int pcnt, userrec *user) { chanrec* c; if (loop_call(handle_names,parameters,pcnt,user,0,pcnt-1,0)) return; c = FindChan(parameters[0]); if (c) { /*WriteServ(user->fd,"353 %s = %s :%s", user->nick, c->name,*/ userlist(user,c); WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, c->name); } else { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } void handle_privmsg(char **parameters, int pcnt, userrec *user) { userrec *dest; chanrec *chan; if (loop_call(handle_privmsg,parameters,pcnt,user,0,pcnt-2,0)) return; if (parameters[0][0] == '#') { chan = FindChan(parameters[0]); if (chan) { if ((chan->noexternal) && (!has_channel(user,chan))) { WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name); return; } if ((chan->moderated) && (cstatus(user,chan)fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name); return; } ChanExceptSender(chan, user, "PRIVMSG %s :%s", chan->name, parameters[1]); } else { /* no such nick/channel */ WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } return; } dest = Find(parameters[0]); if (dest) { if (strcmp(dest->awaymsg,"")) { /* auto respond with aweh msg */ WriteServ(user->fd,"301 %s %s :%s",user->nick,dest->nick,dest->awaymsg); } WriteTo(user, dest, "PRIVMSG %s :%s", dest->nick, parameters[1]); } else { /* no such nick/channel */ WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } void handle_notice(char **parameters, int pcnt, userrec *user) { userrec *dest; chanrec *chan; if (loop_call(handle_notice,parameters,pcnt,user,0,pcnt-2,0)) return; if (parameters[0][0] == '#') { chan = FindChan(parameters[0]); if (chan) { if ((chan->noexternal) && (!has_channel(user,chan))) { WriteServ(user->fd,"404 %s %s :Cannot send to channel (no external messages)", user->nick, chan->name); return; } if ((chan->moderated) && (cstatus(user,chan)fd,"404 %s %s :Cannot send to channel (+m)", user->nick, chan->name); return; } WriteChannel(chan, user, "NOTICE %s :%s", chan->name, parameters[1]); } else { /* no such nick/channel */ WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } return; } dest = Find(parameters[0]); if (dest) { WriteTo(user, dest, "NOTICE %s :%s", dest->nick, parameters[1]); } else { /* no such nick/channel */ WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } char lst[MAXBUF]; char* chlist(userrec *user) { int i = 0; char cmp[MAXBUF]; debug("chlist: %s",user->nick); strcpy(lst,""); if (!user) { return lst; } for (i = 0; i != MAXCHANS; i++) { if (user->chans[i].channel != NULL) { if (user->chans[i].channel->name) { strcpy(cmp,user->chans[i].channel->name); strcat(cmp," "); if (!strstr(lst,cmp)) { if ((!user->chans[i].channel->c_private) && (!user->chans[i].channel->secret)) { strcat(lst,cmode(user,user->chans[i].channel)); strcat(lst,user->chans[i].channel->name); strcat(lst," "); } } } } } return lst; } void handle_info(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"371 %s :The Inspire IRCd Project Has been brought to you by the following people..",user->nick); WriteServ(user->fd,"371 %s :Craig Edwards, Craig McLure, and Others..",user->nick); WriteServ(user->fd,"371 %s :Will finish this later when i can be arsed :p",user->nick); WriteServ(user->fd,"374 %s :End of /INFO list",user->nick); } void handle_time(char **parameters, int pcnt, userrec *user) { time_t rawtime; struct tm * timeinfo; time ( &rawtime ); timeinfo = localtime ( &rawtime ); WriteServ(user->fd,"391 %s %s :%s",user->nick,ServerName, asctime (timeinfo) ); } void handle_whois(char **parameters, int pcnt, userrec *user) { userrec *dest; char *t; if (loop_call(handle_whois,parameters,pcnt,user,0,pcnt-1,0)) return; dest = Find(parameters[0]); if (dest) { WriteServ(user->fd,"311 %s %s %s %s * :%s",user->nick, dest->nick, dest->ident, dest->dhost, dest->fullname); if ((user == dest) || (strchr(user->modes,'o'))) { WriteServ(user->fd,"378 %s %s :is connecting from *@%s",user->nick, dest->nick, dest->host); } if (strcmp(chlist(dest),"")) { WriteServ(user->fd,"319 %s %s :%s",user->nick, dest->nick, chlist(dest)); } WriteServ(user->fd,"312 %s %s %s :%s",user->nick, dest->nick, dest->server, ServerDesc); if (strcmp(dest->awaymsg,"")) { WriteServ(user->fd,"301 %s %s :%s",user->nick, dest->nick, dest->awaymsg); } if (strchr(dest->modes,'o')) { WriteServ(user->fd,"313 %s %s :is an IRC operator",user->nick, dest->nick); } //WriteServ(user->fd,"310 %s %s :is available for help.",user->nick, dest->nick); WriteServ(user->fd,"317 %s %s %d %d :seconds idle, signon time",user->nick, dest->nick, abs((dest->idle_lastmsg)-time(NULL)), dest->signon); WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, dest->nick); } else { /* no such nick/channel */ WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } void handle_quit(char **parameters, int pcnt, userrec *user) { user_hash::iterator iter = clientlist.find(user->nick); /* theres more to do here, but for now just close the socket */ if (pcnt == 1) { if (parameters[0][0] == ':') { *parameters[0]++; } Write(user->fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,parameters[0]); WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,parameters[0]); WriteCommonExcept(user,"QUIT :%s%s",PrefixQuit,parameters[0]); } else { Write(user->fd,"ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host); WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host); WriteCommonExcept(user,"QUIT :Client exited"); } FOREACH_MOD OnUserQuit(user); /* confucious say, he who close nonblocking socket, get nothing! */ Blocking(user->fd); close(user->fd); NonBlocking(user->fd); AddWhoWas(user); if (iter != clientlist.end()) { debug("deleting user hash value"); delete iter->second; clientlist.erase(iter); } purge_empty_chans(); } void handle_who(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; /* theres more to do here, but for now just close the socket */ if (pcnt == 1) { if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*"))) { Ptr = user->chans[0].channel; printf(user->chans[0].channel->name); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((common_channels(user,i->second)) && (isnick(i->second->nick))) { WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname); } } WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name); return; } if (parameters[0][0] = '#') { Ptr = FindChan(parameters[0]); if (Ptr) { for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((has_channel(i->second,Ptr)) && (isnick(i->second->nick))) { WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname); } } WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name); } else { WriteServ(user->fd,"401 %s %s :No suck nick/channel",user->nick, parameters[0]); } } } if (pcnt == 2) { if ((!strcmp(parameters[0],"0")) || (!strcmp(parameters[0],"*")) && (!strcmp(parameters[1],"o"))) { Ptr = user->chans[0].channel; printf(user->chans[0].channel->name); for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((common_channels(user,i->second)) && (isnick(i->second->nick))) { if (strchr(i->second->modes,'o')) { WriteServ(user->fd,"352 %s %s %s %s %s %s Hr@ :0 %s",user->nick, Ptr->name, i->second->ident, i->second->dhost, ServerName, i->second->nick, i->second->fullname); } } } WriteServ(user->fd,"315 %s %s :End of /WHO list.",user->nick, Ptr->name); return; } } } void handle_wallops(char **parameters, int pcnt, userrec *user) { WriteWallOps(user,"%s",parameters[0]); } void handle_list(char **parameters, int pcnt, userrec *user) { chanrec* Ptr; WriteServ(user->fd,"321 %s Channel :Users Name",user->nick); for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++) { if ((!i->second->c_private) && (!i->second->secret)) { WriteServ(user->fd,"322 %s %s %d :[+%s] %s",user->nick,i->second->name,usercount_i(i->second),chanmodes(i->second),i->second->topic); } } WriteServ(user->fd,"323 %s :End of channel list.",user->nick); } void handle_rehash(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"382 %s %s :Rehashing",user->nick,CONFIG_FILE); ReadConfig(); WriteOpers("%s is rehashing config file %s",user->nick,CONFIG_FILE); } int usercnt(void) { return clientlist.size(); } int usercount_invisible(void) { int c = 0; for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'i'))) c++; } return c; } int usercount_opers(void) { int c = 0; for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((i->second->fd) && (isnick(i->second->nick)) && (strchr(i->second->modes,'o'))) c++; } return c; } int usercount_unknown(void) { int c = 0; for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++) { if ((i->second->fd) && (i->second->registered != 7)) c++; } return c; } int chancount(void) { return chanlist.size(); } int servercount(void) { return 1; } void handle_lusers(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),servercount()); WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers()); WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown()); WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount()); WriteServ(user->fd,"254 %s :I have %d clients and 0 servers",user->nick,usercnt()); } void handle_admin(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"256 %s :Administrative info for %s",user->nick,ServerName); WriteServ(user->fd,"257 %s :Name - %s",user->nick,AdminName); WriteServ(user->fd,"258 %s :Nickname - %s",user->nick,AdminNick); WriteServ(user->fd,"258 %s :E-Mail - %s",user->nick,AdminEmail); } void ShowMOTD(userrec *user) { if (!MOTD.size()) { WriteServ(user->fd,"422 %s :Message of the day file is missing.",user->nick); return; } WriteServ(user->fd,"375 %s :- %s message of the day",user->nick,ServerName); for (int i = 0; i != MOTD.size(); i++) { WriteServ(user->fd,"372 %s :- %s",user->nick,MOTD[i].c_str()); } WriteServ(user->fd,"376 %s :End of %s message of the day.",user->nick,ServerName); } void ShowRULES(userrec *user) { if (!RULES.size()) { WriteServ(user->fd,"NOTICE %s :Rules file is missing.",user->nick); return; } WriteServ(user->fd,"NOTICE %s :%s rules",user->nick,ServerName); for (int i = 0; i != RULES.size(); i++) { WriteServ(user->fd,"NOTICE %s :%s",user->nick,RULES[i].c_str()); } WriteServ(user->fd,"NOTICE %s :End of %s rules.",user->nick,ServerName); } /* shows the message of the day, and any other on-logon stuff */ void ConnectUser(userrec *user) { user->registered = 7; user->idle_lastmsg = time(NULL); debug("ConnectUser: %s",user->nick); if (strcmp(Passwd(user),"") && (!user->haspassed)) { Write(user->fd,"ERROR :Closing link: Invalid password"); fdatasync(user->fd); kill_link(user,"Invalid password"); return; } if (IsDenied(user)) { Write(user->fd,"ERROR :Closing link: Unauthorized connection"); fdatasync(user->fd); kill_link(user,"Unauthorised connection"); } WriteServ(user->fd,"NOTICE Auth :Welcome to \002%s\002!",Network); WriteServ(user->fd,"001 %s :Welcome to the %s IRC Network %s!%s@%s",user->nick,Network,user->nick,user->ident,user->host); WriteServ(user->fd,"002 %s :Your host is %s, running version %s",user->nick,ServerName,VERSION); WriteServ(user->fd,"003 %s :This server was created %s %s",user->nick,__TIME__,__DATE__); WriteServ(user->fd,"004 %s :%s %s iowghraAsORVSxNCWqBzvdHtGI lvhopsmntikrRcaqOALQbSeKVfHGCuzN",user->nick,ServerName,VERSION); WriteServ(user->fd,"005 %s :MAP KNOCK SAFELIST HCN MAXCHANNELS=20 MAXBANS=60 NICKLEN=30 TOPICLEN=307 KICKLEN=307 MAXTARGETS=20 AWAYLEN=307 :are supported by this server",user->nick); WriteServ(user->fd,"005 %s :WALLCHOPS WATCH=128 SILENCE=5 MODES=13 CHANTYPES=# PREFIX=(ohv)@%c+ CHANMODES=ohvbeqa,kfL,l,psmntirRcOAQKVHGCuzN NETWORK=%s :are supported by this server",user->nick,'%',Network); ShowMOTD(user); FOREACH_MOD OnUserConnect(user); WriteOpers("*** Client connecting on port %d: %s!%s@%s",user->port,user->nick,user->ident,user->host); } void handle_version(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"351 %s :%s %s :%s",user->nick,VERSION,ServerName,SYSTEM); } void handle_ping(char **parameters, int pcnt, userrec *user) { WriteServ(user->fd,"PONG %s :%s",ServerName,parameters[0]); } void handle_pong(char **parameters, int pcnt, userrec *user) { // set the user as alive so they survive to next ping user->lastping = 1; } void handle_motd(char **parameters, int pcnt, userrec *user) { ShowMOTD(user); } void handle_rules(char **parameters, int pcnt, userrec *user) { ShowRULES(user); } void handle_user(char **parameters, int pcnt, userrec *user) { if (user->registered < 3) { WriteServ(user->fd,"NOTICE Auth :No ident response, ident prefixed with ~"); strcpy(user->ident,"~"); /* we arent checking ident... but these days why bother anyway? */ strncat(user->ident,parameters[0],IDENTMAX); strncpy(user->fullname,parameters[3],128); user->registered = (user->registered | 1); } else { WriteServ(user->fd,"462 %s :You may not reregister",user->nick); return; } /* parameters 2 and 3 are local and remote hosts, ignored when sent by client connection */ if (user->registered == 3) { /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */ ConnectUser(user); } } void handle_userhost(char **parameters, int pcnt, userrec *user) { char Return[MAXBUF],junk[MAXBUF]; sprintf(Return,"302 %s :",user->nick); for (int i = 0; i < pcnt; i++) { userrec *u = Find(parameters[i]); if (u) { if (strchr(u->modes,'o')) { sprintf(junk,"%s*=+%s@%s ",u->nick,u->ident,u->host); strcat(Return,junk); } else { sprintf(junk,"%s=+%s@%s ",u->nick,u->ident,u->host); strcat(Return,junk); } } } WriteServ(user->fd,Return); } void handle_ison(char **parameters, int pcnt, userrec *user) { char Return[MAXBUF]; sprintf(Return,"303 %s :",user->nick); for (int i = 0; i < pcnt; i++) { userrec *u = Find(parameters[i]); if (u) { strcat(Return,u->nick); strcat(Return," "); } } WriteServ(user->fd,Return); } void handle_away(char **parameters, int pcnt, userrec *user) { if (pcnt) { strcpy(user->awaymsg,parameters[0]); WriteServ(user->fd,"306 %s :You have been marked as being away",user->nick); } else { strcpy(user->awaymsg,""); WriteServ(user->fd,"305 %s :You are no longer marked as being away",user->nick); } } void handle_whowas(char **parameters, int pcnt, userrec* user) { user_hash::iterator i = whowas.find(parameters[0]); if (i == whowas.end()) { WriteServ(user->fd,"406 %s %s :There was no such nickname",user->nick,parameters[0]); WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]); } else { time_t rawtime = i->second->signon; tm *timeinfo; char b[MAXBUF]; timeinfo = localtime(&rawtime); strcpy(b,asctime(timeinfo)); b[strlen(b)-1] = '\0'; WriteServ(user->fd,"314 %s %s %s %s * :%s",user->nick,i->second->nick,i->second->ident,i->second->dhost,i->second->fullname); WriteServ(user->fd,"312 %s %s %s :%s",user->nick,i->second->nick,i->second->server,b); WriteServ(user->fd,"369 %s %s :End of WHOWAS",user->nick,parameters[0]); } } void handle_trace(char **parameters, int pcnt, userrec *user) { for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (i->second) { if (isnick(i->second->nick)) { if (strchr(i->second->modes,'o')) { WriteServ(user->fd,"205 %s :Oper 0 %s",user->nick,i->second->nick); } else { WriteServ(user->fd,"204 %s :User 0 %s",user->nick,i->second->nick); } } else { WriteServ(user->fd,"203 %s :???? 0 [%s]",user->nick,i->second->host); } } } } void handle_stats(char **parameters, int pcnt, userrec *user) { if (pcnt != 1) { return; } if (strlen(parameters[0])>1) { /* make the stats query 1 character long */ parameters[0][1] = '\0'; } /* stats m (list number of times each command has been used, plus bytecount) */ if (!strcasecmp(parameters[0],"m")) { for (int i = 0; i < cmdlist.size(); i++) { if (cmdlist[i].handler_function) { if (cmdlist[i].use_count) { /* RPL_STATSCOMMANDS */ WriteServ(user->fd,"212 %s %s %d %d",user->nick,cmdlist[i].command,cmdlist[i].use_count,cmdlist[i].total_bytes); } } } } /* stats z (debug and memory info) */ if (!strcasecmp(parameters[0],"z")) { WriteServ(user->fd,"249 %s :Users(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,clientlist.size(),clientlist.size()*sizeof(userrec),clientlist.bucket_count()); WriteServ(user->fd,"249 %s :Channels(HASH_MAP) %d (%d bytes, %d buckets)",user->nick,chanlist.size(),chanlist.size()*sizeof(chanrec),chanlist.bucket_count()); WriteServ(user->fd,"249 %s :Commands(VECTOR) %d (%d bytes)",user->nick,cmdlist.size(),cmdlist.size()*sizeof(command_t)); WriteServ(user->fd,"249 %s :MOTD(VECTOR) %d, RULES(VECTOR) %d",user->nick,MOTD.size(),RULES.size()); WriteServ(user->fd,"249 %s :address_cache(HASH_MAP) %d (%d buckets)",user->nick,IP.size(),IP.bucket_count()); WriteServ(user->fd,"249 %s :Modules(VECTOR) %d (%d)",user->nick,modules.size(),modules.size()*sizeof(Module)); WriteServ(user->fd,"249 %s :ClassFactories(VECTOR) %d (%d)",user->nick,factory.size(),factory.size()*sizeof(ircd_module)); WriteServ(user->fd,"249 %s :Ports(STATIC_ARRAY) %d",user->nick,boundPortCount); } /* stats o */ if (!strcasecmp(parameters[0],"o")) { for (int i = 0; i < ConfValueEnum("oper"); i++) { char LoginName[MAXBUF]; char HostName[MAXBUF]; char OperType[MAXBUF]; ConfValue("oper","name",i,LoginName); ConfValue("oper","host",i,HostName); ConfValue("oper","type",i,OperType); WriteServ(user->fd,"243 %s O %s * %s %s 0",user->nick,HostName,LoginName,OperType); } } /* stats l (show user I/O stats) */ if (!strcasecmp(parameters[0],"l")) { WriteServ(user->fd,"211 %s :server:port nick bytes_in cmds_in bytes_out cmds_out",user->nick); for (user_hash::iterator i = clientlist.begin(); i != clientlist.end(); i++) { if (isnick(i->second->nick)) { WriteServ(user->fd,"211 %s :%s:%d %s %d %d %d %d",user->nick,ServerName,i->second->port,i->second->nick,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out); } else { WriteServ(user->fd,"211 %s :%s:%d (unknown@%d) %d %d %d %d",user->nick,ServerName,i->second->port,i->second->fd,i->second->bytes_in,i->second->cmds_in,i->second->bytes_out,i->second->cmds_out); } } } /* stats u (show server uptime) */ if (!strcasecmp(parameters[0],"u")) { time_t current_time = 0; current_time = time(NULL); time_t server_uptime = current_time - startup_time; struct tm* stime; stime = gmtime(&server_uptime); /* i dont know who the hell would have an ircd running for over a year nonstop, but * Craig suggested this, and it seemed a good idea so in it went */ if (stime->tm_year > 70) { WriteServ(user->fd,"242 %s :Server up %d years, %d days, %.2d:%.2d:%.2d",user->nick,(stime->tm_year-70),stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec); } else { WriteServ(user->fd,"242 %s :Server up %d days, %.2d:%.2d:%.2d",user->nick,stime->tm_yday,stime->tm_hour,stime->tm_min,stime->tm_sec); } } WriteServ(user->fd,"219 %s %s :End of /STATS report",user->nick,parameters[0]); WriteOpers("*** Notice: Stats '%s' requested by %s (%s@%s)",parameters[0],user->nick,user->ident,user->host); } void handle_oper(char **parameters, int pcnt, userrec *user) { char LoginName[MAXBUF]; char Password[MAXBUF]; char OperType[MAXBUF]; char TypeName[MAXBUF]; char Hostname[MAXBUF]; int i,j; for (i = 0; i < ConfValueEnum("oper"); i++) { ConfValue("oper","name",i,LoginName); ConfValue("oper","password",i,Password); if ((!strcmp(LoginName,parameters[0])) && (!strcmp(Password,parameters[1]))) { /* correct oper credentials */ ConfValue("oper","type",i,OperType); WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType); WriteServ(user->fd,"381 %s :You are now an IRC operator of type %s",user->nick,OperType); WriteServ(user->fd,"MODE %s :+o",user->nick); for (j =0; j < ConfValueEnum("type"); j++) { ConfValue("type","name",j,TypeName); if (!strcmp(TypeName,OperType)) { /* found this oper's opertype */ ConfValue("type","host",j,Hostname); strncpy(user->dhost,Hostname,256); } } if (!strchr(user->modes,'o')) { strcat(user->modes,"o"); } return; } } /* no such oper */ WriteServ(user->fd,"491 %s :Invalid oper credentials",user->nick); WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host); } void handle_nick(char **parameters, int pcnt, userrec *user) { if (pcnt < 1) { debug("not enough params for handle_nick"); return; } if (!parameters[0]) { debug("invalid parameter passed to handle_nick"); return; } if (!strlen(parameters[0])) { debug("zero length new nick passed to handle_nick"); return; } if (!user) { debug("invalid user passed to handle_nick"); return; } if (!user->nick) { debug("invalid old nick passed to handle_nick"); return; } if (!strcasecmp(user->nick,parameters[0])) { debug("old nick is new nick, skipping"); return; } else { if (strlen(parameters[0]) > 1) { if (parameters[0][0] == ':') { *parameters[0]++; } } if ((Find(parameters[0])) && (Find(parameters[0]) != user)) { WriteServ(user->fd,"433 %s %s :Nickname is already in use.",user->nick,parameters[0]); return; } } if (isnick(parameters[0]) == 0) { WriteServ(user->fd,"432 %s %s :Erroneous Nickname",user->nick,parameters[0]); return; } if (user->registered == 7) { WriteCommon(user,"NICK %s",parameters[0]); } /* change the nick of the user in the users_hash */ user = ReHashNick(user->nick, parameters[0]); /* actually change the nick within the record */ if (!user) return; if (!user->nick) return; strncpy(user->nick, parameters[0],NICKMAX); debug("new nick set: %s",user->nick); if (user->registered < 3) user->registered = (user->registered | 2); if (user->registered == 3) { /* user is registered now, bit 0 = USER command, bit 1 = sent a NICK command */ ConnectUser(user); } debug("exit nickchange: %s",user->nick); } int process_parameters(char **command_p,char *parameters) { int i = 0; int j = 0; int q = 0; q = strlen(parameters); if (!q) { /* no parameters, command_p invalid! */ return 0; } if (parameters[0] == ':') { command_p[0] = parameters+1; return 1; } if (q) { if ((strchr(parameters,' ')==NULL) || (parameters[0] == ':')) { /* only one parameter */ command_p[0] = parameters; if (parameters[0] == ':') { if (strchr(parameters,' ') != NULL) { command_p[0]++; } } return 1; } } command_p[j++] = parameters; for (i = 0; i <= q; i++) { if (parameters[i] == ' ') { command_p[j++] = parameters+i+1; parameters[i] = '\0'; if (command_p[j-1][0] == ':') { *command_p[j-1]++; /* remove dodgy ":" */ break; /* parameter like this marks end of the sequence */ } } } return j; /* returns total number of items in the list */ } void process_command(userrec *user, char* cmd) { char *parameters; char *command; char *command_p[127]; char p[MAXBUF], temp[MAXBUF]; int i, j, items, cmd_found; for (int i = 0; i < 127; i++) command_p[i] = NULL; if (!user) { return; } if (!cmd) { return; } if (!strcmp(cmd,"")) { return; } strcpy(temp,cmd); if (!strchr(cmd,' ')) { /* no parameters, lets skip the formalities and not chop up * the string */ items = 0; command_p[0] = NULL; parameters = NULL; for (int i = 0; i <= strlen(cmd); i++) { cmd[i] = toupper(cmd[i]); } } else { strcpy(cmd,""); j = 0; /* strip out extraneous linefeeds through mirc's crappy pasting (thanks Craig) */ for (i = 0; i < strlen(temp); i++) { if ((temp[i] != 10) && (temp[i] != 13) && (temp[i] != 0) && (temp[i] != 7)) { cmd[j++] = temp[i]; cmd[j] = 0; } } /* split the full string into a command plus parameters */ parameters = p; strcpy(p," "); command = cmd; if (strchr(cmd,' ')) { for (i = 0; i <= strlen(cmd); i++) { /* capitalise the command ONLY, leave params intact */ cmd[i] = toupper(cmd[i]); /* are we nearly there yet?! :P */ if (cmd[i] == ' ') { command = cmd; parameters = cmd+i+1; cmd[i] = '\0'; break; } } } else { for (i = 0; i <= strlen(cmd); i++) { cmd[i] = toupper(cmd[i]); } } } cmd_found = 0; for (i = 0; i != cmdlist.size(); i++) { if (strcmp(cmdlist[i].command,"")) { if (!strcmp(command, cmdlist[i].command)) { if (parameters) { if (strcmp(parameters,"")) { items = process_parameters(command_p,parameters); } else { items = 0; command_p[0] = NULL; } } else { items = 0; command_p[0] = NULL; } if (user) { user->idle_lastmsg = time(NULL); /* activity resets the ping pending timer */ user->nping = time(NULL) + 120; if ((items) < cmdlist[i].min_params) { debug("process_command: not enough parameters: %s %s",user->nick,command); WriteServ(user->fd,"461 %s %s :Not enough parameters",user->nick,command); return; } if ((!strchr(user->modes,cmdlist[i].flags_needed)) && (cmdlist[i].flags_needed)) { debug("process_command: permission denied: %s %s",user->nick,command); WriteServ(user->fd,"481 %s :Permission Denied- You do not have the required operator privilages",user->nick); cmd_found = 1; return; } /* if the command isnt USER, PASS, or NICK, and nick is empty, * deny command! */ if ((strcmp(command,"USER")) && (strcmp(command,"NICK")) && (strcmp(command,"PASS"))) { if ((!isnick(user->nick)) || (user->registered != 7)) { debug("process_command: not registered: %s %s",user->nick,command); WriteServ(user->fd,"451 %s :You have not registered",command); return; } } if ((user->registered == 7) || (!strcmp(command,"USER")) || (!strcmp(command,"NICK")) || (!strcmp(command,"PASS"))) { debug("process_command: handler: %s %s %d",user->nick,command,items); if (cmdlist[i].handler_function) { /* ikky /stats counters */ if (temp) { if (user) { user->bytes_in += strlen(temp); user->cmds_in++; } cmdlist[i].use_count++; cmdlist[i].total_bytes+=strlen(temp); } /* WARNING: nothing may come after the * command handler call, as the handler * may free the user structure! */ cmdlist[i].handler_function(command_p,items,user); } return; } else { debug("process_command: not registered: %s %s",user->nick,command); WriteServ(user->fd,"451 %s :You have not registered",command); return; } } cmd_found = 1; } } } if ((!cmd_found) && (user)) { debug("process_command: not in table: %s %s",user->nick,command); WriteServ(user->fd,"421 %s %s :Unknown command",user->nick,command); } } void createcommand(char* cmd, handlerfunc f, char flags, int minparams) { command_t comm; /* create the command and push it onto the table */ strcpy(comm.command,cmd); comm.handler_function = f; comm.flags_needed = flags; comm.min_params = minparams; comm.use_count = 0; comm.total_bytes = 0; cmdlist.push_back(comm); } void SetupCommandTable(void) { createcommand("USER",handle_user,0,4); createcommand("NICK",handle_nick,0,1); createcommand("QUIT",handle_quit,0,1); createcommand("VERSION",handle_version,0,0); createcommand("PING",handle_ping,0,1); createcommand("PONG",handle_pong,0,1); createcommand("ADMIN",handle_admin,0,0); createcommand("PRIVMSG",handle_privmsg,0,2); createcommand("INFO",handle_info,0,0); createcommand("TIME",handle_time,0,0); createcommand("WHOIS",handle_whois,0,1); createcommand("WALLOPS",handle_wallops,'o',1); createcommand("NOTICE",handle_notice,0,2); createcommand("JOIN",handle_join,0,1); createcommand("NAMES",handle_names,0,1); createcommand("PART",handle_part,0,1); createcommand("KICK",handle_kick,0,2); createcommand("MODE",handle_mode,0,1); createcommand("TOPIC",handle_topic,0,1); createcommand("WHO",handle_who,0,1); createcommand("MOTD",handle_motd,0,0); createcommand("RULES",handle_join,0,0); createcommand("OPER",handle_oper,0,2); createcommand("LIST",handle_list,0,0); createcommand("DIE",handle_die,'o',1); createcommand("RESTART",handle_restart,'o',1); createcommand("KILL",handle_kill,'o',2); createcommand("REHASH",handle_rehash,'o',0); createcommand("LUSERS",handle_lusers,0,0); createcommand("STATS",handle_stats,0,1); createcommand("USERHOST",handle_userhost,0,1); createcommand("AWAY",handle_away,0,0); createcommand("ISON",handle_ison,0,0); createcommand("SUMMON",handle_summon,0,0); createcommand("USERS",handle_users,0,0); createcommand("INVITE",handle_invite,0,2); createcommand("PASS",handle_pass,0,1); createcommand("TRACE",handle_trace,'o',0); createcommand("WHOWAS",handle_whowas,0,1); } void process_buffer(userrec *user) { char cmd[MAXBUF]; int i; if (!user->inbuf) { return; } if (!strcmp(user->inbuf,"")) { return; } strncpy(cmd,user->inbuf,MAXBUF); if (!strcmp(cmd,"")) { return; } if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10)) { cmd[strlen(cmd)-1] = '\0'; } if ((cmd[strlen(cmd)-1] == 13) || (cmd[strlen(cmd)-1] == 10)) { cmd[strlen(cmd)-1] = '\0'; } strcpy(user->inbuf,""); if (!strcmp(cmd,"")) { return; } debug("InspIRCd: processing: %s %s",user->nick,cmd); process_command(user,cmd); } int InspIRCd(void) { struct sockaddr_in client, server; int portCount = 0, ports[MAXSOCKS]; char addrs[MAXBUF][255]; int openSockfd[MAXSOCKS], incomingSockfd, result = TRUE; socklen_t length; int count = 0, scanDetectTrigger = TRUE, showBanner = FALSE; int selectResult = 0; char *temp, configToken[MAXBUF], stuff[MAXBUF], Addr[MAXBUF]; char resolvedHost[MAXBUF]; fd_set selectFds; struct timeval tv; int count2; debug("InspIRCd: startup: begin"); debug("$Id$"); if ((geteuid()) && (getuid()) == 0) { printf("WARNING!!! You are running an irc server as ROOT!!! DO NOT DO THIS!!!\n\n"); Exit(ERROR); debug("InspIRCd: startup: not starting with UID 0!"); } SetupCommandTable(); debug("InspIRCd: startup: default command table set up"); ReadConfig(); if (strcmp(DieValue,"")) { printf("WARNING: %s\n\n",DieValue); exit(0); } debug("InspIRCd: startup: read config"); for (count = 0; count < ConfValueEnum("bind"); count++) { ConfValue("bind","port",count,configToken); ConfValue("bind","address",count,Addr); ports[count] = atoi(configToken); strcpy(addrs[count],Addr); debug("InspIRCd: startup: read binding %s:%d from config",addrs[count],ports[count]); } portCount = ConfValueEnum("bind"); debug("InspIRCd: startup: read %d total ports",portCount); debug("InspIRCd: startup: InspIRCd is now running!"); printf("\n"); for (count = 0; count < ConfValueEnum("module"); count++) { char modfile[MAXBUF]; ConfValue("module","name",count,configToken); sprintf(modfile,"%s/%s",MOD_PATH,configToken); printf("Loading module... \033[1;37m%s\033[0;37m\n",modfile); debug("InspIRCd: startup: Loading module: %s",modfile); factory[count] = new ircd_module(modfile); if (factory[count]->LastError()) { debug("Unable to load %s: %s",modfile,factory[count]->LastError()); sprintf("Unable to load %s: %s\nExiting...\n",modfile,factory[count]->LastError()); Exit(ERROR); } if (factory[count]->factory) { modules[count] = factory[count]->factory->CreateModule(); /* save the module and the module's classfactory, if * this isnt done, random crashes can occur :/ */ } else { debug("Unable to load %s",modfile); sprintf("Unable to load %s\nExiting...\n",modfile); Exit(ERROR); } } MODCOUNT = count - 1; debug("Total loaded modules: %d",MODCOUNT+1); printf("\nInspIRCd is now running!\n"); startup_time = time(NULL); if (DaemonSeed() == ERROR) { debug("InspIRCd: startup: can't daemonise"); printf("ERROR: could not go into daemon mode. Shutting down.\n"); Exit(ERROR); } /* setup select call */ FD_ZERO(&selectFds); debug("InspIRCd: startup: zero selects"); for (count = 0; count < portCount; count++) { if ((openSockfd[boundPortCount] = OpenTCPSocket()) == ERROR) { debug("InspIRCd: startup: bad fd %d",openSockfd[boundPortCount]); return(ERROR); } if (BindSocket(openSockfd[boundPortCount],client,server,ports[count],addrs[count]) == ERROR) { debug("InspIRCd: startup: failed to bind port %d",ports[count]); } else /* well we at least bound to one socket so we'll continue */ { boundPortCount++; } } debug("InspIRCd: startup: total bound ports %d",boundPortCount); /* if we didn't bind to anything then abort */ if (boundPortCount == 0) { debug("InspIRCd: startup: no ports bound, bailing!"); return (ERROR); } length = sizeof (client); int flip_flop = 0; /* main loop for multiplexing/resetting */ for (;;) { /* set up select call */ for (count = 0; count < boundPortCount; count++) { FD_SET (openSockfd[count], &selectFds); } /* added timeout! select was waiting forever... wank... :/ */ tv.tv_usec = 0; flip_flop++; if (flip_flop > 20) { tv.tv_usec = 1; flip_flop = 0; } tv.tv_sec = 0; selectResult = select(MAXSOCKS, &selectFds, NULL, NULL, &tv); for (user_hash::iterator count2 = clientlist.begin(); count2 != clientlist.end(); count2++) { char data[MAXBUF]; if (!count2->second) break; if (count2->second) if (count2->second->fd) { if (((time(NULL)) > count2->second->nping) && (isnick(count2->second->nick)) && (count2->second->registered == 7)) { if (!count2->second->lastping) { debug("InspIRCd: ping timeout: %s",count2->second->nick); kill_link(count2->second,"Ping timeout"); break; } Write(count2->second->fd,"PING :%s",ServerName); debug("InspIRCd: pinging: %s",count2->second->nick); count2->second->lastping = 0; count2->second->nping = time(NULL)+120; } result = read(count2->second->fd, data, 1); // result EAGAIN means nothing read if (result == EAGAIN) { } else if (result == 0) { debug("InspIRCd: Exited: %s",count2->second->nick); kill_link(count2->second,"Client exited"); } else if (result > 0) { strncat(count2->second->inbuf, data, result); if (strchr(count2->second->inbuf, '\n') || strchr(count2->second->inbuf, '\r')) { /* at least one complete line is waiting to be processed */ if (!count2->second->fd) break; else { process_buffer(count2->second); break; } } } } } /* select is reporting a waiting socket. Poll them all to find out which */ if (selectResult > 0) { char target[MAXBUF], resolved[MAXBUF]; for (count = 0; count < boundPortCount; count++) { if (FD_ISSET (openSockfd[count], &selectFds)) { incomingSockfd = accept (openSockfd[count], (struct sockaddr *) &client, &length); address_cache::iterator iter = IP.find(client.sin_addr); bool iscached = false; if (iter == IP.end()) { /* ip isn't in cache, add it */ strncpy (target, (char *) inet_ntoa (client.sin_addr), MAXBUF); if(CleanAndResolve(resolved, target) != TRUE) { strncpy(resolved,target,MAXBUF); } /* hostname now in 'target' */ IP[client.sin_addr] = new string(resolved); /* hostname in cache */ } else { /* found ip (cached) */ strncpy(resolved, iter->second->c_str(), MAXBUF); iscached = true; } if (incomingSockfd < 0) { WriteOpers("*** WARNING: Accept failed on port %d (%s)", ports[count],target); debug("InspIRCd: accept failed: %d",ports[count]); break; } AddClient(incomingSockfd, resolved, ports[count], iscached); debug("InspIRCd: adding client on port %d fd=%d",ports[count],incomingSockfd); break; } } } } /* not reached */ close (incomingSockfd); }