* ---------------------------------------------------
*/
+using namespace std;
+
#include "inspircd.h"
#include "inspircd_io.h"
#include "inspircd_util.h"
#include "inspircd_config.h"
#include <unistd.h>
-#include <fcntl.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
+
#ifdef USE_KQUEUE
#include <sys/types.h>
#include <sys/event.h>
#include <sys/time.h>
#endif
+
+#ifdef USE_EPOLL
+#include <sys/epoll.h>
+#endif
+
#include <cstdio>
#include <time.h>
#include <string>
#include <map>
#include <sstream>
#include <vector>
-#include <errno.h>
#include <deque>
-#include <errno.h>
-#include <unistd.h>
-#include <sched.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "xline.h"
#include "inspstring.h"
#include "dnsqueue.h"
-
-#ifdef GCC3
-#define nspace __gnu_cxx
-#else
-#define nspace std
-#endif
-
-using namespace std;
+#include "helperfuncs.h"
+#include "hashcomp.h"
#ifdef USE_KQUEUE
extern int kq;
#endif
+#ifdef USE_EPOLL
+int ep;
+#endif
+
extern int MODCOUNT;
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
const long duration_w = duration_d * 7;
const long duration_y = duration_w * 52;
-namespace nspace
-{
-#ifdef GCC34
- template<> struct hash<in_addr>
-#else
- template<> struct nspace::hash<in_addr>
-#endif
- {
- size_t operator()(const struct in_addr &a) const
- {
- size_t q;
- memcpy(&q,&a,sizeof(size_t));
- return q;
- }
- };
-#ifdef GCC34
- template<> struct hash<string>
-#else
- template<> struct nspace::hash<string>
-#endif
- {
- size_t operator()(const string &s) const
- {
- char a[MAXBUF];
- static struct hash<const char *> strhash;
- strlcpy(a,s.c_str(),MAXBUF);
- strlower(a);
- return strhash(a);
- }
- };
-}
-
-
-struct StrHashComp
-{
-
- bool operator()(const string& s1, const string& s2) const
- {
- char a[MAXBUF],b[MAXBUF];
- strlcpy(a,s1.c_str(),MAXBUF);
- strlcpy(b,s2.c_str(),MAXBUF);
- strlower(a);
- strlower(b);
- 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 nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
-typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
-typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
+typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
+typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
+typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache;
+typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash;
typedef std::deque<command_t> command_table;
extern user_hash clientlist;
extern chan_hash chanlist;
-extern user_hash whowas;
+extern whowas_hash whowas;
extern command_table cmdlist;
extern file_cache MOTD;
extern file_cache RULES;
}
}
+void handle_commands(char **parameters, int pcnt, userrec *user)
+{
+ for (int i = 0; i < command_table.size(); i++)
+ {
+ WriteServ(user->fd,"902 %s :%s %s",user->nick,command_table[i].command,command_table[i].source);
+ }
+ WriteServ(user->fd,"903 %s :End of COMMANDS list");
+}
+
void handle_kick(char **parameters, int pcnt, userrec *user)
{
chanrec* Ptr = FindChan(parameters[0]);
void handle_invite(char **parameters, int pcnt, userrec *user)
{
- userrec* u = Find(parameters[0]);
- chanrec* c = FindChan(parameters[1]);
-
- if ((!c) || (!u))
+ if (pcnt == 2)
{
- if (!c)
+ userrec* u = Find(parameters[0]);
+ chanrec* c = FindChan(parameters[1]);
+
+ if ((!c) || (!u))
{
- WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
+ if (!c)
+ {
+ WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
+ }
+ else
+ {
+ if (c->binarymodes & CM_INVITEONLY)
+ {
+ WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
+ }
+ }
+
+ return;
}
- else
+
+ if (c->binarymodes & CM_INVITEONLY)
{
- if (c->binarymodes & CM_INVITEONLY)
+ if (cstatus(user,c) < STATUS_HOP)
{
- WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[0]);
+ WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, c->name);
+ return;
}
}
+ if (has_channel(u,c))
+ {
+ WriteServ(user->fd,"443 %s %s %s :Is already on channel %s",user->nick,u->nick,c->name,c->name);
+ return;
+ }
+ if (!has_channel(user,c))
+ {
+ WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, c->name);
+ return;
+ }
- return;
- }
+ int MOD_RESULT = 0;
+ FOREACH_RESULT(OnUserPreInvite(user,u,c));
+ if (MOD_RESULT == 1) {
+ return;
+ }
- if (c->binarymodes & CM_INVITEONLY)
+ 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);
+
+ // i token must go to ALL servers!!!
+ char buffer[MAXBUF];
+ snprintf(buffer,MAXBUF,"i %s %s %s",u->nick,user->nick,c->name);
+ NetSendToAll(buffer);
+ }
+ else
{
- if (cstatus(user,c) < STATUS_HOP)
+ // pinched from ircu - invite with not enough parameters shows channels
+ // youve been invited to but haven't joined yet.
+ InvitedList* il = user->GetInviteList();
+ for (InvitedList::iterator i = il->begin(); i != il->end(); i++)
{
- WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",user->nick, c->name);
- return;
+ if (i->channel) {
+ WriteServ(user->fd,"346 %s :%s",user->nick,i->channel);
+ }
}
+ WriteServ(user->fd,"347 %s :End of INVITE list",user->nick);
}
- if (has_channel(u,c))
- {
- WriteServ(user->fd,"443 %s %s %s :Is already on channel %s",user->nick,u->nick,c->name,c->name);
- return;
- }
- if (!has_channel(user,c))
- {
- WriteServ(user->fd,"442 %s %s :You're not on that channel!",user->nick, c->name);
- return;
- }
-
- int MOD_RESULT = 0;
- FOREACH_RESULT(OnUserPreInvite(user,u,c));
- if (MOD_RESULT == 1) {
- 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);
-
- // i token must go to ALL servers!!!
- char buffer[MAXBUF];
- snprintf(buffer,MAXBUF,"i %s %s %s",u->nick,user->nick,c->name);
- NetSendToAll(buffer);
}
void handle_topic(char **parameters, int pcnt, userrec *user)
{
log(DEBUG,"kqueue: Failed to remove user from queue!");
}
+#endif
+#ifdef USE_EPOLL
+ struct epoll_event ev;
+ ev.events = EPOLLIN | EPOLLET;
+ ev.data.fd = user->fd;
+ int i = epoll_ctl(ep, EPOLL_CTL_DEL, user->fd, &ev);
+ if (i < 0)
+ {
+ log(DEBUG,"epoll: List deletion failure!");
+ }
#endif
shutdown(user->fd,2);
close(user->fd);
void handle_whowas(char **parameters, int pcnt, userrec* user)
{
- user_hash::iterator i = whowas.find(parameters[0]);
+ whowas_hash::iterator i = whowas.find(parameters[0]);
if (i == whowas.end())
{
}
-void handle_v(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_v(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* servername = strtok(params," ");
char* versionstr = strtok(NULL,"\r\n");
}
}
-void handle_V(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_V(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* src = strtok(params," ");
char* dest = strtok(NULL," :");
}
-void handle_P(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_P(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* src = strtok(params," ");
char* dest = strtok(NULL," :");
}
-void handle_i(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_i(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = strtok(params," ");
char* from = strtok(NULL," ");
}
}
-void handle_t(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_t(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* setby = strtok(params," ");
char* channel = strtok(NULL," :");
}
-void handle_T(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_T(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* tm = strtok(params," ");
char* setby = strtok(NULL," ");
}
}
-void handle_M(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_M(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* pars[128];
char original[MAXBUF],target[MAXBUF];
// m is modes set by users only (not servers) valid targets are channels or users.
-void handle_m(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_m(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
// m blah #chatspike +b *!test@*4
char* pars[128];
}
-void handle_L(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_L(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = NULL;
char* channel = NULL;
}
}
-void handle_K(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_K(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* src = strtok(params," ");
char* nick = strtok(NULL," :");
}
}
-void handle_Q(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_Q(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = strtok(params," :");
char* reason = strtok(NULL,"\r\n");
}
}
-void handle_n(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_n(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* oldnick = strtok(params," ");
char* newnick = strtok(NULL," ");
// broadcast this because its a services thingy
char buffer[MAXBUF];
snprintf(buffer,MAXBUF,"n %s %s",user->nick,newnick);
- NetSendToAllExcept(tcp_host,buffer);
+ NetSendToAllExcept_WithSum(tcp_host,buffer,tcp_sum);
}
WriteCommon(user,"NICK %s",newnick);
user = ReHashNick(user->nick, newnick);
}
// k <SOURCE> <DEST> <CHANNEL> :<REASON>
-void handle_k(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_k(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* src = strtok(params," ");
char* dest = strtok(NULL," ");
}
}
-void handle_AT(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_AT(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* who = strtok(params," :");
char* text = strtok(NULL,"\r\n");
}
}
-void handle_H(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_H(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
log(DEBUG,"Adding ULined server %s to my map",params);
ircd_connector s;
WriteOpers("Non-Mesh server %s has joined the network",params);
}
-void handle_N(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_N(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* tm = strtok(params," ");
char* nick = strtok(NULL," ");
}
}
-void handle_F(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_F(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
if (!params)
return;
WriteOpers("TS split for %s -> %s: %d",source->name,reply->name,tdiff);
}
-void handle_a(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_a(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = strtok(params," :");
char* gecos = strtok(NULL,"\r\n");
strlcpy(user->fullname,gecos,MAXBUF);
}
-void handle_b(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_b(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = strtok(params," ");
char* host = strtok(NULL," ");
strlcpy(user->dhost,host,160);
}
-void handle_plus(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_plus(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
// %s %s %d %d
// + test3.chatspike.net 7010 -2016508415
me[defaultRoute]->MeshCookie(ipaddr,atoi(ipport),atoi(cookie),servername);
}
-void handle_R(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_R(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* server = strtok(params," ");
char* data = strtok(NULL,"\r\n");
NetSendToOne(server,data);
}
-void handle_J(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_J(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
- // IMPORTANT NOTE
- // The J token currently has no timestamp - this needs looking at
- // because it will allow splitriding.
char* nick = strtok(params," ");
char* channel = strtok(NULL," ");
}
}
-void handle_dollar(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_dollar(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
log(DEBUG,"Storing routing table...");
char* sourceserver = strtok(params," ");
log(DEBUG,"Warning! routing table received from nonexistent server!");
}
-void handle_amp(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_amp(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
if (!params)
return;
unsigned long authcookie;
-void handle_hash(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_hash(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
// # <mask> <who-set-it> <time-set> <duration> :<reason>
log(DEBUG,"Adding G-line");
apply_lines();
}
-void handle_dot(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_dot(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
log(DEBUG,"Removing G-line");
char* mask = strtok(params," ");
}
}
-void handle_add_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_add_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
// { <mask> <who-set-it> <time-set> <duration> :<reason>
log(DEBUG,"Adding Q-line");
apply_lines();
}
-void handle_del_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_del_sqline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
log(DEBUG,"Removing Q-line");
char* mask = strtok(params," ");
}
}
-void handle_add_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_add_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
// } <mask> <who-set-it> <time-set> <duration> :<reason>
log(DEBUG,"Adding Z-line");
apply_lines();
}
-void handle_del_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_del_szline(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
log(DEBUG,"Removing Z-line");
char* mask = strtok(params," ");
}
}
-void handle_pipe(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host)
+void handle_pipe(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host, char* tcp_sum)
{
char* nick = strtok(params," ");
char* type = strtok(params," ");
}
-void process_restricted_commands(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host,char* ipaddr,int port)
+void process_restricted_commands(char token,char* params,serverrec* source,serverrec* reply, char* tcp_host,char* ipaddr,int port,char* tcp_sum)
{
char buffer[MAXBUF];
int MOD_RESULT = 0;
// except the newcomer. They'll all attempt to connect back to it.
authcookie = rand()*rand();
snprintf(buffer,MAXBUF,"~ %lu",(unsigned long)authcookie);
- NetSendToAll(buffer);
+ NetSendToAll_WithSum(buffer,tcp_sum);
break;
// ~
// Store authcookie
break;
// connect back to a server using an authcookie
case '+':
- handle_plus(token,params,source,reply,tcp_host);
+ handle_plus(token,params,source,reply,tcp_host,tcp_sum);
break;
// routing table
case '$':
- handle_dollar(token,params,source,reply,tcp_host);
+ handle_dollar(token,params,source,reply,tcp_host,tcp_sum);
break;
// node unreachable - we cant route to a server, sooooo we slit it off.
// servers can generate these for themselves for an squit.
case '&':
- handle_amp(token,params,source,reply,tcp_host);
+ handle_amp(token,params,source,reply,tcp_host,tcp_sum);
break;
// R <server> <data>
// redirect token, send all of <data> along to the given
// server as this server has been found to still have a route to it
case 'R':
- handle_R(token,params,source,reply,tcp_host);
+ handle_R(token,params,source,reply,tcp_host,tcp_sum);
break;
// ?
// ping
// N <TS> <NICK> <HOST> <DHOST> <IDENT> <MODES> <SERVER> :<GECOS>
// introduce remote client
case 'N':
- handle_N(token,params,source,reply,tcp_host);
+ handle_N(token,params,source,reply,tcp_host,tcp_sum);
break;
// a <NICK> :<GECOS>
// change GECOS (SETNAME)
case 'a':
- handle_a(token,params,source,reply,tcp_host);
+ handle_a(token,params,source,reply,tcp_host,tcp_sum);
break;
// b <NICK> :<HOST>
// change displayed host (SETHOST)
case 'b':
- handle_b(token,params,source,reply,tcp_host);
+ handle_b(token,params,source,reply,tcp_host,tcp_sum);
break;
// t <NICK> <CHANNEL> :<TOPIC>
// change a channel topic
case 't':
- handle_t(token,params,source,reply,tcp_host);
+ handle_t(token,params,source,reply,tcp_host,tcp_sum);
break;
// i <NICK> <CHANNEL>
// invite a user to a channel
case 'i':
- handle_i(token,params,source,reply,tcp_host);
+ handle_i(token,params,source,reply,tcp_host,tcp_sum);
break;
// k <SOURCE> <DEST> <CHANNEL> :<REASON>
// kick a user from a channel
case 'k':
- handle_k(token,params,source,reply,tcp_host);
+ handle_k(token,params,source,reply,tcp_host,tcp_sum);
break;
// n <NICK> <NEWNICK>
// change nickname of client -- a server should only be able to
// change the nicknames of clients that reside on it unless
// they are ulined.
case 'n':
- handle_n(token,params,source,reply,tcp_host);
+ handle_n(token,params,source,reply,tcp_host,tcp_sum);
break;
// J <NICK> <CHANLIST>
// Join user to channel list, merge channel permissions
case 'J':
- handle_J(token,params,source,reply,tcp_host);
+ handle_J(token,params,source,reply,tcp_host,tcp_sum);
break;
// T <TS> <CHANNEL> <TOPICSETTER> :<TOPIC>
// change channel topic (netburst only)
case 'T':
- handle_T(token,params,source,reply,tcp_host);
+ handle_T(token,params,source,reply,tcp_host,tcp_sum);
break;
// M <TARGET> <MODES> [MODE-PARAMETERS]
// Server setting modes on an object
case 'M':
- handle_M(token,params,source,reply,tcp_host);
+ handle_M(token,params,source,reply,tcp_host,tcp_sum);
break;
// m <SOURCE> <TARGET> <MODES> [MODE-PARAMETERS]
// User setting modes on an object
case 'm':
- handle_m(token,params,source,reply,tcp_host);
+ handle_m(token,params,source,reply,tcp_host,tcp_sum);
break;
// P <SOURCE> <TARGET> :<TEXT>
// Send a private/channel message
case 'P':
- handle_P(token,params,source,reply,tcp_host);
+ handle_P(token,params,source,reply,tcp_host,tcp_sum);
break;
// V <SOURCE> <TARGET> :<TEXT>
// Send a private/channel notice
case 'V':
- handle_V(token,params,source,reply,tcp_host);
+ handle_V(token,params,source,reply,tcp_host,tcp_sum);
break;
// v <servername> <arbitary version string>
case 'v':
- handle_v(token,params,source,reply,tcp_host);
+ handle_v(token,params,source,reply,tcp_host,tcp_sum);
break;
// L <SOURCE> <CHANNEL> :<REASON>
// User parting a channel
case 'L':
- handle_L(token,params,source,reply,tcp_host);
+ handle_L(token,params,source,reply,tcp_host,tcp_sum);
break;
// Q <SOURCE> :<REASON>
// user quitting
case 'Q':
- handle_Q(token,params,source,reply,tcp_host);
+ handle_Q(token,params,source,reply,tcp_host,tcp_sum);
break;
// H <SERVER>
// introduce non-meshable server (such as a services server)
case 'H':
- handle_H(token,params,source,reply,tcp_host);
+ handle_H(token,params,source,reply,tcp_host,tcp_sum);
break;
// K <SOURCE> <DEST> :<REASON>
// remote kill
case 'K':
- handle_K(token,params,source,reply,tcp_host);
+ handle_K(token,params,source,reply,tcp_host,tcp_sum);
break;
// @ <SOURCE> :<TEXT>
// wallops
case '@':
- handle_AT(token,params,source,reply,tcp_host);
+ handle_AT(token,params,source,reply,tcp_host,tcp_sum);
break;
// # <mask> <who-set-it> <time-set> <duration> :<reason>
// add gline
case '#':
- handle_hash(token,params,source,reply,tcp_host);
+ handle_hash(token,params,source,reply,tcp_host,tcp_sum);
break;
// . <mask> <who>
// remove gline
case '.':
- handle_dot(token,params,source,reply,tcp_host);
+ handle_dot(token,params,source,reply,tcp_host,tcp_sum);
break;
// # <mask> <who-set-it> <time-set> <duration> :<reason>
// add gline
case '{':
- handle_add_sqline(token,params,source,reply,tcp_host);
+ handle_add_sqline(token,params,source,reply,tcp_host,tcp_sum);
break;
// . <mask> <who>
// remove gline
case '[':
- handle_del_sqline(token,params,source,reply,tcp_host);
+ handle_del_sqline(token,params,source,reply,tcp_host,tcp_sum);
break;
// # <mask> <who-set-it> <time-set> <duration> :<reason>
// add gline
case '}':
- handle_add_szline(token,params,source,reply,tcp_host);
+ handle_add_szline(token,params,source,reply,tcp_host,tcp_sum);
break;
// . <mask> <who>
// remove gline
case ']':
- handle_del_szline(token,params,source,reply,tcp_host);
+ handle_del_szline(token,params,source,reply,tcp_host,tcp_sum);
break;
// | <nick> <opertype>
// set opertype
case '|':
- handle_pipe(token,params,source,reply,tcp_host);
+ handle_pipe(token,params,source,reply,tcp_host,tcp_sum);
break;
// F <TS>
// end netburst
case 'F':
WriteOpers("Server %s has completed netburst. (%d secs)",tcp_host,TIME-nb_start);
- handle_F(token,params,source,reply,tcp_host);
+ handle_F(token,params,source,reply,tcp_host,tcp_sum);
nb_start = 0;
// tell all the other servers to use this authcookie to connect back again
// got '+ test3.chatspike.net 7010 -2016508415' from test.chatspike.net
snprintf(buffer,MAXBUF,"+ %s %s %d %lu",tcp_host,ipaddr,port,(unsigned long)authcookie);
- NetSendToAllExcept(tcp_host,buffer);
+ NetSendToAllExcept_WithSum(tcp_host,buffer,tcp_sum);
break;
case '/':
WriteOpers("Server %s is IRCServices-based server (assumes-SVSMODE) - Nickname Services: %s",tcp_host,params);
// end netburst with no mesh creation
case 'f':
WriteOpers("Server %s has completed netburst. (%d secs)",tcp_host,TIME-nb_start);
- handle_F(token,params,source,reply,tcp_host);
+ handle_F(token,params,source,reply,tcp_host,tcp_sum);
nb_start = 0;
// tell everyone else about the new server name so they just add it in the disconnected
// state
snprintf(buffer,MAXBUF,"u %s :%s",tcp_host,GetServerDescription(tcp_host).c_str());
- NetSendToAllExcept(tcp_host,buffer);
+ NetSendToAllExcept_WithSum(tcp_host,buffer,tcp_sum);
break;
// X <reserved>
// Send netburst now
}
-void handle_link_packet(char* tcp_msg, char* tcp_host, serverrec *serv)
+void handle_link_packet(char* tcp_msg, char* tcp_host, serverrec *serv,char* tcp_sum)
{
if ((!strncmp(tcp_msg,"USER ",5)) || (!strncmp(tcp_msg,"NICK ",5)) || (!strncmp(tcp_msg,"PASS ",5)) || (!strncmp(tcp_msg,"SERVER ",7)))
{
{
// we have a matching link line -
// send a 'diminutive' server message back...
- snprintf(response,10240,"s %s %s :%s",ServerName,Link_SendPass,ServerDesc);
+ snprintf(response,10240,"%s s %s %s :%s",CreateSum().c_str(),ServerName,Link_SendPass,ServerDesc);
serv->SendPacket(response,servername);
for (int t = 0; t < serv->connectors.size(); t++)
char buffer[MAXBUF];
me[j]->connectors[k].SetDescription(serverdesc);
me[j]->connectors[k].SetState(STATE_CONNECTED);
- snprintf(buffer,MAXBUF,"X 0");
+ snprintf(buffer,MAXBUF,"%s X 0",CreateSum().c_str());
serv->SendPacket(buffer,tcp_host);
DoSync(me[j],tcp_host);
NetSendMyRoutingTable();
me[j]->connectors[k].SetDescription(serverdesc);
me[j]->connectors[k].SetServerName(servername);
me[j]->connectors[k].SetState(STATE_SERVICES);
- snprintf(buffer,MAXBUF,"X 0");
+ snprintf(buffer,MAXBUF,"%s X 0",CreateSum().c_str());
serv->SendPacket(buffer,servername);
- snprintf(buffer,MAXBUF,"s %s %s %lu :%s",ServerName,Link_SendPass,LinkPort,ServerDesc);
+ snprintf(buffer,MAXBUF,"%s s %s %s %lu :%s",CreateSum().c_str(),ServerName,Link_SendPass,LinkPort,ServerDesc);
serv->SendPacket(buffer,servername);
DoSync(me[j],servername);
snprintf(buffer,MAXBUF,"H %s",servername);
{
// found a valid ircd_connector.
if ((params) && (*params))
- process_restricted_commands(token,params,me[j],serv,tcp_host,me[j]->connectors[x].GetServerIP(),me[j]->connectors[x].GetServerPort());
+ process_restricted_commands(token,params,me[j],serv,tcp_host,me[j]->connectors[x].GetServerIP(),me[j]->connectors[x].GetServerPort(),tcp_sum);
return;
}
}
projects / user / henk / code / inspircd.git / blobdiff