]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/modules/m_spanningtree.cpp
3de75765bf3eb7fd8afa58991dce2dd67aa5fba8
[user/henk/code/inspircd.git] / src / modules / m_spanningtree.cpp
1 /*       +------------------------------------+
2  *       | Inspire Internet Relay Chat Daemon |
3  *       +------------------------------------+
4  *
5  *  Inspire is copyright (C) 2002-2005 ChatSpike-Dev.
6  *                       E-mail:
7  *                <brain@chatspike.net>
8  *                <Craig@chatspike.net>
9  *     
10  * Written by Craig Edwards, Craig McLure, and others.
11  * This program is free but copyrighted software; see
12  *            the file COPYING for details.
13  *
14  * ---------------------------------------------------
15  */
16
17 using namespace std;
18
19 #include <stdio.h>
20 #include <vector>
21 #include <deque>
22 #include "globals.h"
23 #include "inspircd_config.h"
24 #ifdef GCC3
25 #include <ext/hash_map>
26 #else
27 #include <hash_map>
28 #endif
29 #include "users.h"
30 #include "channels.h"
31 #include "modules.h"
32 #include "socket.h"
33 #include "helperfuncs.h"
34 #include "inspircd.h"
35 #include "inspstring.h"
36 #include "hashcomp.h"
37 #include "message.h"
38
39 #ifdef GCC3
40 #define nspace __gnu_cxx
41 #else
42 #define nspace std
43 #endif
44
45 enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
46
47 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash;
48 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash;
49
50 extern user_hash clientlist;
51 extern chan_hash chanlist;
52
53 class TreeServer;
54 class TreeSocket;
55
56 bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> params, std::string target);
57 bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> params, std::string omit);
58 bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> params);
59 bool DoOneToAllButSenderRaw(std::string data,std::string omit);
60
61 class TreeServer
62 {
63         TreeServer* Parent;
64         std::vector<TreeServer*> Children;
65         std::string ServerName;
66         std::string ServerDesc;
67         std::string VersionString;
68         int UserCount;
69         int OperCount;
70         TreeSocket* Socket;     // for directly connected servers this points at the socket object
71         
72  public:
73
74         TreeServer()
75         {
76                 Parent = NULL;
77                 ServerName = "";
78                 ServerDesc = "";
79                 VersionString = "";
80                 UserCount = OperCount = 0;
81         }
82
83         TreeServer(std::string Name, std::string Desc) : ServerName(Name), ServerDesc(Desc)
84         {
85                 Parent = NULL;
86                 VersionString = "";
87                 UserCount = OperCount = 0;
88         }
89
90         TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock)
91         {
92                 VersionString = "";
93                 UserCount = OperCount = 0;
94         }
95
96         std::string GetName()
97         {
98                 return this->ServerName;
99         }
100
101         std::string GetDesc()
102         {
103                 return this->ServerDesc;
104         }
105
106         std::string GetVersion()
107         {
108                 return this->VersionString;
109         }
110
111         int GetUserCount()
112         {
113                 return this->UserCount;
114         }
115
116         int GetOperCount()
117         {
118                 return this->OperCount;
119         }
120
121         TreeSocket* GetSocket()
122         {
123                 return this->Socket;
124         }
125
126         TreeServer* GetParent()
127         {
128                 return this->Parent;
129         }
130
131         unsigned int ChildCount()
132         {
133                 return Children.size();
134         }
135
136         TreeServer* GetChild(unsigned int n)
137         {
138                 if (n < Children.size())
139                 {
140                         return Children[n];
141                 }
142                 else
143                 {
144                         return NULL;
145                 }
146         }
147
148         void AddChild(TreeServer* Child)
149         {
150                 Children.push_back(Child);
151         }
152
153         bool DelChild(TreeServer* Child)
154         {
155                 for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
156                 {
157                         if (*a == Child)
158                         {
159                                 Children.erase(a);
160                                 return true;
161                         }
162                 }
163                 return false;
164         }
165
166         // removes child nodes of this node, and of that node, etc etc
167         bool Tidy()
168         {
169                 bool stillchildren = true;
170                 while (stillchildren)
171                 {
172                         stillchildren = false;
173                         for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
174                         {
175                                 TreeServer* s = (TreeServer*)*a;
176                                 s->Tidy();
177                                 Children.erase(a);
178                                 delete s;
179                                 stillchildren = true;
180                                 break;
181                         }
182                 }
183                 return true;
184         }
185 };
186
187 class Link
188 {
189  public:
190          std::string Name;
191          std::string IPAddr;
192          int Port;
193          std::string SendPass;
194          std::string RecvPass;
195 };
196
197 /* $ModDesc: Povides a spanning tree server link protocol */
198
199 Server *Srv;
200 ConfigReader *Conf;
201 TreeServer *TreeRoot;
202 std::vector<Link> LinkBlocks;
203
204 TreeServer* RouteEnumerate(TreeServer* Current, std::string ServerName)
205 {
206         if (Current->GetName() == ServerName)
207                 return Current;
208         for (unsigned int q = 0; q < Current->ChildCount(); q++)
209         {
210                 TreeServer* found = RouteEnumerate(Current->GetChild(q),ServerName);
211                 if (found)
212                 {
213                         return found;
214                 }
215         }
216         return NULL;
217 }
218
219 // Returns the locally connected server we must route a
220 // message through to reach server 'ServerName'. This
221 // only applies to one-to-one and not one-to-many routing.
222 TreeServer* BestRouteTo(std::string ServerName)
223 {
224         log(DEBUG,"Finding best route to %s",ServerName.c_str());
225         // first, find the server by recursively walking the tree
226         TreeServer* Found = RouteEnumerate(TreeRoot,ServerName);
227         // did we find it? If not, they did something wrong, abort.
228         if (!Found)
229         {
230                 log(DEBUG,"Failed to find %s by walking tree!",ServerName.c_str());
231                 return NULL;
232         }
233         else
234         {
235                 // The server exists, follow its parent nodes until
236                 // the parent of the current is 'TreeRoot', we know
237                 // then that this is a directly-connected server.
238                 while ((Found) && (Found->GetParent() != TreeRoot))
239                 {
240                         Found = Found->GetParent();
241                 }
242                 log(DEBUG,"Route to %s is via %s",ServerName.c_str(),Found->GetName().c_str());
243                 return Found;
244         }
245 }
246
247 bool LookForServer(TreeServer* Current, std::string ServerName)
248 {
249         if (ServerName == Current->GetName())
250                 return true;
251         for (unsigned int q = 0; q < Current->ChildCount(); q++)
252         {
253                 if (LookForServer(Current->GetChild(q),ServerName))
254                         return true;
255         }
256         return false;
257 }
258
259 TreeServer* Found;
260
261 void RFindServer(TreeServer* Current, std::string ServerName)
262 {
263         if ((ServerName == Current->GetName()) && (!Found))
264         {
265                 Found = Current;
266                 log(DEBUG,"Found server %s desc %s",Current->GetName().c_str(),Current->GetDesc().c_str());
267                 return;
268         }
269         if (!Found)
270         {
271                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
272                 {
273                         if (!Found)
274                                 RFindServer(Current->GetChild(q),ServerName);
275                 }
276         }
277         return;
278 }
279
280 TreeServer* FindServer(std::string ServerName)
281 {
282         Found = NULL;
283         RFindServer(TreeRoot,ServerName);
284         return Found;
285 }
286
287 bool IsServer(std::string ServerName)
288 {
289         return LookForServer(TreeRoot,ServerName);
290 }
291
292 class TreeSocket : public InspSocket
293 {
294         std::string myhost;
295         std::string in_buffer;
296         ServerState LinkState;
297         std::string InboundServerName;
298         std::string InboundDescription;
299         int num_lost_users;
300         int num_lost_servers;
301         
302  public:
303
304         TreeSocket(std::string host, int port, bool listening, unsigned long maxtime)
305                 : InspSocket(host, port, listening, maxtime)
306         {
307                 Srv->Log(DEBUG,"Create new listening");
308                 myhost = host;
309                 this->LinkState = LISTENER;
310         }
311
312         TreeSocket(std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName)
313                 : InspSocket(host, port, listening, maxtime)
314         {
315                 Srv->Log(DEBUG,"Create new outbound");
316                 myhost = ServerName;
317                 this->LinkState = CONNECTING;
318         }
319
320         TreeSocket(int newfd, char* ip)
321                 : InspSocket(newfd, ip)
322         {
323                 Srv->Log(DEBUG,"Associate new inbound");
324                 this->LinkState = WAIT_AUTH_1;
325         }
326         
327         virtual bool OnConnected()
328         {
329                 if (this->LinkState == CONNECTING)
330                 {
331                         Srv->SendOpers("*** Connection to "+myhost+"["+this->GetIP()+"] established.");
332                         // we should send our details here.
333                         // if the other side is satisfied, they send theirs.
334                         // we do not need to change state here.
335                         for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
336                         {
337                                 if (x->Name == this->myhost)
338                                 {
339                                         // found who we're supposed to be connecting to, send the neccessary gubbins.
340                                         this->WriteLine("SERVER "+Srv->GetServerName()+" "+x->SendPass+" 0 :"+Srv->GetServerDescription());
341                                         return true;
342                                 }
343                         }
344                 }
345                 log(DEBUG,"Outbound connection ERROR: Could not find the right link block!");
346                 return true;
347         }
348         
349         virtual void OnError(InspSocketError e)
350         {
351         }
352
353         virtual int OnDisconnect()
354         {
355                 return true;
356         }
357
358         // recursively send the server tree with distances as hops
359         void SendServers(TreeServer* Current, TreeServer* s, int hops)
360         {
361                 char command[1024];
362                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
363                 {
364                         TreeServer* recursive_server = Current->GetChild(q);
365                         if (recursive_server != s)
366                         {
367                                 // :source.server SERVER server.name hops :Description
368                                 snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str());
369                                 this->WriteLine(command);
370                                 // down to next level
371                                 this->SendServers(recursive_server, s, hops+1);
372                         }
373                 }
374         }
375
376         void SquitServer(TreeServer* Current)
377         {
378                 // recursively squit the servers attached to 'Current'
379                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
380                 {
381                         TreeServer* recursive_server = Current->GetChild(q);
382                         this->SquitServer(recursive_server);
383                 }
384                 // Now we've whacked the kids, whack self
385                 log(DEBUG,"Deleted %s",Current->GetName().c_str());
386                 num_lost_servers++;
387                 bool quittingpeople = true;
388                 while (quittingpeople)
389                 {
390                         quittingpeople = false;
391                         for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
392                         {
393                                 if (!strcasecmp(u->second->server,Current->GetName().c_str()))
394                                 {
395                                         log(DEBUG,"Quitting user %s of server %s",u->second->nick,u->second->server);
396                                         Srv->QuitUser(u->second,Current->GetName()+" "+std::string(Srv->GetServerName()));
397                                         num_lost_users++;
398                                         quittingpeople = true;
399                                         break;
400                                 }
401                         }
402                 }
403         }
404
405         void Squit(TreeServer* Current,std::string reason)
406         {
407                 if (Current)
408                 {
409                         std::deque<std::string> params;
410                         params.push_back(Current->GetName());
411                         params.push_back(":"+reason);
412                         DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
413                         if (Current->GetParent() == TreeRoot)
414                         {
415                                 Srv->SendOpers("Server \002"+Current->GetName()+"\002 split: "+reason);
416                         }
417                         else
418                         {
419                                 Srv->SendOpers("Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
420                         }
421                         num_lost_servers = 0;
422                         num_lost_users = 0;
423                         SquitServer(Current);
424                         Current->Tidy();
425                         Current->GetParent()->DelChild(Current);
426                         delete Current;
427                         WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
428                 }
429                 else
430                 {
431                         log(DEBUG,"Squit from unknown server");
432                 }
433         }
434
435         bool ForceMode(std::string source, std::deque<std::string> params)
436         {
437                 userrec* who = new userrec;
438                 who->fd = FD_MAGIC_NUMBER;
439                 if (params.size() < 2)
440                         return true;
441                 char* modelist[255];
442                 for (unsigned int q = 0; q < params.size(); q++)
443                 {
444                         modelist[q] = (char*)params[q].c_str();
445                 }
446                 Srv->SendMode(modelist,params.size(),who);
447                 DoOneToAllButSender(source,"FMODE",params,source);
448                 delete who;
449                 return true;
450         }
451
452         bool ForceJoin(std::string source, std::deque<std::string> params)
453         {
454                 if (params.size() < 1)
455                         return true;
456                 for (unsigned int channelnum = 0; channelnum < params.size(); channelnum++)
457                 {
458                         // process one channel at a time, applying modes.
459                         char* channel = (char*)params[channelnum].c_str();
460                         char permissions = *channel;
461                         char* mode = NULL;
462                         switch (permissions)
463                         {
464                                 case '@':
465                                         channel++;
466                                         mode = "+o";
467                                 break;
468                                 case '%':
469                                         channel++;
470                                         mode = "+h";
471                                 break;
472                                 case '+':
473                                         channel++;
474                                         mode = "+v";
475                                 break;
476                         }
477                         userrec* who = Srv->FindNick(source);
478                         if (who)
479                         {
480                                 char* key = "";
481                                 chanrec* chan = Srv->FindChannel(channel);
482                                 if ((chan) && (*chan->key))
483                                 {
484                                         key = chan->key;
485                                 }
486                                 Srv->JoinUserToChannel(who,channel,key);
487                                 if (mode)
488                                 {
489                                         char* modelist[3];
490                                         modelist[0] = channel;
491                                         modelist[1] = mode;
492                                         modelist[2] = who->nick;
493                                         Srv->SendMode(modelist,3,who);
494                                 }
495                                 DoOneToAllButSender(source,"FJOIN",params,who->server);
496                         }
497                 }
498                 return true;
499         }
500
501         bool IntroduceClient(std::string source, std::deque<std::string> params)
502         {
503                 if (params.size() < 8)
504                         return true;
505                 // NICK age nick host dhost ident +modes ip :gecos
506                 //       0   1    2    3      4     5    6   7
507                 std::string nick = params[1];
508                 std::string host = params[2];
509                 std::string dhost = params[3];
510                 std::string ident = params[4];
511                 time_t age = atoi(params[0].c_str());
512                 std::string modes = params[5];
513                 if (*(modes.c_str()) == '+')
514                 {
515                         char* m = (char*)modes.c_str();
516                         m++;
517                         modes = m;
518                 }
519                 std::string ip = params[6];
520                 std::string gecos = params[7];
521                 char* tempnick = (char*)nick.c_str();
522                 log(DEBUG,"Introduce client %s!%s@%s",tempnick,ident.c_str(),host.c_str());
523                 
524                 user_hash::iterator iter;
525                 iter = clientlist.find(tempnick);
526                 if (iter != clientlist.end())
527                 {
528                         // nick collision
529                         log(DEBUG,"Nick collision on %s!%s@%s",tempnick,ident.c_str(),host.c_str());
530                         return true;
531                 }
532                 
533                 clientlist[tempnick] = new userrec();
534                 clientlist[tempnick]->fd = FD_MAGIC_NUMBER;
535                 strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX);
536                 strlcpy(clientlist[tempnick]->host, host.c_str(),160);
537                 strlcpy(clientlist[tempnick]->dhost, dhost.c_str(),160);
538                 clientlist[tempnick]->server = (char*)FindServerNamePtr(source.c_str());
539                 strlcpy(clientlist[tempnick]->ident, ident.c_str(),IDENTMAX);
540                 strlcpy(clientlist[tempnick]->fullname, gecos.c_str(),MAXGECOS);
541                 clientlist[tempnick]->registered = 7;
542                 clientlist[tempnick]->signon = age;
543                 strlcpy(clientlist[tempnick]->ip,ip.c_str(),16);
544                 for (int i = 0; i < MAXCHANS; i++)
545                 {
546                         clientlist[tempnick]->chans[i].channel = NULL;
547                         clientlist[tempnick]->chans[i].uc_modes = 0;
548                 }
549                 params[7] = ":" + params[7];
550                 DoOneToAllButSender(source,"NICK",params,source);
551                 return true;
552         }
553
554         void SendChannelModes(TreeServer* Current)
555         {
556                 char data[MAXBUF];
557                 for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
558                 {
559                         snprintf(data,MAXBUF,":%s FMODE %s +%s",Srv->GetServerName().c_str(),c->second->name,chanmodes(c->second));
560                         this->WriteLine(data);
561                         if (*c->second->topic)
562                         {
563                                 snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",Srv->GetServerName().c_str(),c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
564                                 this->WriteLine(data);
565                         }
566                         for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++)
567                         {
568                                 snprintf(data,MAXBUF,":%s FMODE %s +b %s",Srv->GetServerName().c_str(),c->second->name,b->data);
569                                 this->WriteLine(data);
570                         }
571                 }
572         }
573
574         // send all users and their channels
575         void SendUsers(TreeServer* Current)
576         {
577                 char data[MAXBUF];
578                 for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
579                 {
580                         snprintf(data,MAXBUF,":%s NICK %lu %s %s %s %s +%s %s :%s",u->second->server,(unsigned long)u->second->age,u->second->nick,u->second->host,u->second->dhost,u->second->ident,u->second->modes,u->second->ip,u->second->fullname);
581                         this->WriteLine(data);
582                         if (strchr(u->second->modes,'o'))
583                         {
584                                 this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
585                         }
586                         char* chl = chlist(u->second,u->second);
587                         if (*chl)
588                         {
589                                 this->WriteLine(":"+std::string(u->second->nick)+" FJOIN "+std::string(chl));
590                         }
591                 }
592         }
593
594         void DoBurst(TreeServer* s)
595         {
596                 log(DEBUG,"Beginning network burst");
597                 Srv->SendOpers("*** Bursting to "+s->GetName()+".");
598                 this->WriteLine("BURST");
599                 // Send server tree
600                 this->SendServers(TreeRoot,s,1);
601                 // Send users and their channels
602                 this->SendUsers(s);
603                 // TODO: Send everything else (channel modes etc)
604                 this->SendChannelModes(s);
605                 this->WriteLine("ENDBURST");
606         }
607
608         virtual bool OnDataReady()
609         {
610                 char* data = this->Read();
611                 if (data)
612                 {
613                         this->in_buffer += data;
614                         while (in_buffer.find("\n") != std::string::npos)
615                         {
616                                 char* line = (char*)in_buffer.c_str();
617                                 std::string ret = "";
618                                 while ((*line != '\n') && (strlen(line)))
619                                 {
620                                         ret = ret + *line;
621                                         line++;
622                                 }
623                                 if ((*line == '\n') || (*line == '\r'))
624                                         line++;
625                                 in_buffer = line;
626                                 if (!this->ProcessLine(ret))
627                                 {
628                                         return false;
629                                 }
630                         }
631                 }
632                 return (data != NULL);
633         }
634
635         int WriteLine(std::string line)
636         {
637                 return this->Write(line + "\r\n");
638         }
639
640         bool Error(std::deque<std::string> params)
641         {
642                 if (params.size() < 1)
643                         return false;
644                 std::string Errmsg = params[0];
645                 std::string SName = myhost;
646                 if (InboundServerName != "")
647                 {
648                         SName = InboundServerName;
649                 }
650                 Srv->SendOpers("*** ERROR from "+SName+": "+Errmsg);
651                 // we will return false to cause the socket to close.
652                 return false;
653         }
654
655         bool OperType(std::string prefix, std::deque<std::string> params)
656         {
657                 if (params.size() != 1)
658                         return true;
659                 std::string opertype = params[0];
660                 userrec* u = Srv->FindNick(prefix);
661                 if (u)
662                 {
663                         strlcpy(u->oper,opertype.c_str(),NICKMAX);
664                         if (!strchr(u->modes,'o'))
665                         {
666                                 strcat(u->modes,"o");
667                         }
668                         DoOneToAllButSender(u->server,"OPERTYPE",params,u->server);
669                 }
670                 return true;
671         }
672
673         bool RemoteKill(std::string prefix, std::deque<std::string> params)
674         {
675                 if (params.size() != 2)
676                         return true;
677                 std::string nick = params[0];
678                 std::string reason = params[1];
679                 userrec* u = Srv->FindNick(prefix);
680                 userrec* who = Srv->FindNick(nick);
681                 if (who)
682                 {
683                         params[1] = ":" + params[1];
684                         DoOneToAllButSender(prefix,"KILL",params,u->server);
685                         Srv->QuitUser(who,reason);
686                 }
687                 return true;
688         }
689
690         bool RemoteServer(std::string prefix, std::deque<std::string> params)
691         {
692                 if (params.size() < 4)
693                         return false;
694                 std::string servername = params[0];
695                 std::string password = params[1];
696                 int hops = atoi(params[2].c_str());
697                 std::string description = params[3];
698                 if (!hops)
699                 {
700                         this->WriteLine("ERROR :Protocol error - Introduced remote server with incorrect hopcount!");
701                         return false;
702                 }
703                 TreeServer* ParentOfThis = FindServer(prefix);
704                 if (!ParentOfThis)
705                 {
706                         this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix);
707                         return false;
708                 }
709                 TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
710                 ParentOfThis->AddChild(Node);
711                 params[3] = ":" + params[3];
712                 DoOneToAllButSender(prefix,"SERVER",params,prefix);
713                 Srv->SendOpers("*** Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
714                 return true;
715         }
716
717         bool Outbound_Reply_Server(std::deque<std::string> params)
718         {
719                 if (params.size() < 4)
720                         return false;
721                 std::string servername = params[0];
722                 std::string password = params[1];
723                 int hops = atoi(params[2].c_str());
724                 if (hops)
725                 {
726                         this->WriteLine("ERROR :Server too far away for authentication");
727                         return false;
728                 }
729                 std::string description = params[3];
730                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
731                 {
732                         if ((x->Name == servername) && (x->RecvPass == password))
733                         {
734                                 // Begin the sync here. this kickstarts the
735                                 // other side, waiting in WAIT_AUTH_2 state,
736                                 // into starting their burst, as it shows
737                                 // that we're happy.
738                                 this->LinkState = CONNECTED;
739                                 // we should add the details of this server now
740                                 // to the servers tree, as a child of the root
741                                 // node.
742                                 TreeServer* Node = new TreeServer(servername,description,TreeRoot,this);
743                                 TreeRoot->AddChild(Node);
744                                 params[3] = ":" + params[3];
745                                 DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
746                                 this->DoBurst(Node);
747                                 return true;
748                         }
749                 }
750                 this->WriteLine("ERROR :Invalid credentials");
751                 return false;
752         }
753
754         bool Inbound_Server(std::deque<std::string> params)
755         {
756                 if (params.size() < 4)
757                         return false;
758                 std::string servername = params[0];
759                 std::string password = params[1];
760                 int hops = atoi(params[2].c_str());
761                 if (hops)
762                 {
763                         this->WriteLine("ERROR :Server too far away for authentication");
764                         return false;
765                 }
766                 std::string description = params[3];
767                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
768                 {
769                         if ((x->Name == servername) && (x->RecvPass == password))
770                         {
771                                 Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+this->GetIP()+"] ("+description+")");
772                                 this->InboundServerName = servername;
773                                 this->InboundDescription = description;
774                                 // this is good. Send our details: Our server name and description and hopcount of 0,
775                                 // along with the sendpass from this block.
776                                 this->WriteLine("SERVER "+Srv->GetServerName()+" "+x->SendPass+" 0 :"+Srv->GetServerDescription());
777                                 // move to the next state, we are now waiting for THEM.
778                                 this->LinkState = WAIT_AUTH_2;
779                                 return true;
780                         }
781                 }
782                 this->WriteLine("ERROR :Invalid credentials");
783                 return false;
784         }
785
786         std::deque<std::string> Split(std::string line, bool stripcolon)
787         {
788                 std::deque<std::string> n;
789                 std::stringstream s(line);
790                 std::string param = "";
791                 n.clear();
792                 int item = 0;
793                 while (!s.eof())
794                 {
795                         s >> param;
796                         if ((param != "") && (param != "\n"))
797                         {
798                                 if ((param.c_str()[0] == ':') && (item))
799                                 {
800                                         char* str = (char*)param.c_str();
801                                         str++;
802                                         param = str;
803                                         std::string append;
804                                         while (!s.eof())
805                                         {
806                                                 append = "";
807                                                 s >> append;
808                                                 if (append != "")
809                                                 {
810                                                         param = param + " " + append;
811                                                 }
812                                         }
813                                 }
814                                 item++;
815                                 n.push_back(param);
816                         }
817                 }
818                 return n;
819         }
820
821         bool ProcessLine(std::string line)
822         {
823                 char* l = (char*)line.c_str();
824                 while ((strlen(l)) && (l[strlen(l)-1] == '\r') || (l[strlen(l)-1] == '\n'))
825                         l[strlen(l)-1] = '\0';
826                 line = l;
827                 if (line == "")
828                         return true;
829                 Srv->Log(DEBUG,"inbound-line: '"+line+"'");
830                 std::deque<std::string> params = this->Split(line,true);
831                 std::string command = "";
832                 std::string prefix = "";
833                 if (((params[0].c_str())[0] == ':') && (params.size() > 1))
834                 {
835                         prefix = params[0];
836                         command = params[1];
837                         char* pref = (char*)prefix.c_str();
838                         prefix = ++pref;
839                         params.pop_front();
840                         params.pop_front();
841                 }
842                 else
843                 {
844                         prefix = "";
845                         command = params[0];
846                         params.pop_front();
847                 }
848                 
849                 switch (this->LinkState)
850                 {
851                         TreeServer* Node;
852                         
853                         case WAIT_AUTH_1:
854                                 // Waiting for SERVER command from remote server. Server initiating
855                                 // the connection sends the first SERVER command, listening server
856                                 // replies with theirs if its happy, then if the initiator is happy,
857                                 // it starts to send its net sync, which starts the merge, otherwise
858                                 // it sends an ERROR.
859                                 if (command == "SERVER")
860                                 {
861                                         return this->Inbound_Server(params);
862                                 }
863                                 else if (command == "ERROR")
864                                 {
865                                         return this->Error(params);
866                                 }
867                         break;
868                         case WAIT_AUTH_2:
869                                 // Waiting for start of other side's netmerge to say they liked our
870                                 // password.
871                                 if (command == "SERVER")
872                                 {
873                                         // cant do this, they sent it to us in the WAIT_AUTH_1 state!
874                                         // silently ignore.
875                                         return true;
876                                 }
877                                 else if (command == "BURST")
878                                 {
879                                         this->LinkState = CONNECTED;
880                                         Node = new TreeServer(InboundServerName,InboundDescription,TreeRoot,this);
881                                         TreeRoot->AddChild(Node);
882                                         params.clear();
883                                         params.push_back(InboundServerName);
884                                         params.push_back("*");
885                                         params.push_back("1");
886                                         params.push_back(":"+InboundDescription);
887                                         DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
888                                         this->DoBurst(Node);
889                                 }
890                                 else if (command == "ERROR")
891                                 {
892                                         return this->Error(params);
893                                 }
894                                 
895                         break;
896                         case LISTENER:
897                                 this->WriteLine("ERROR :Internal error -- listening socket accepted its own descriptor!!!");
898                                 return false;
899                         break;
900                         case CONNECTING:
901                                 if (command == "SERVER")
902                                 {
903                                         // another server we connected to, which was in WAIT_AUTH_1 state,
904                                         // has just sent us their credentials. If we get this far, theyre
905                                         // happy with OUR credentials, and they are now in WAIT_AUTH_2 state.
906                                         // if we're happy with this, we should send our netburst which
907                                         // kickstarts the merge.
908                                         return this->Outbound_Reply_Server(params);
909                                 }
910                         break;
911                         case CONNECTED:
912                                 // This is the 'authenticated' state, when all passwords
913                                 // have been exchanged and anything past this point is taken
914                                 // as gospel.
915                                 std::string target = "";
916                                 if ((command == "NICK") && (params.size() > 1))
917                                 {
918                                         return this->IntroduceClient(prefix,params);
919                                 }
920                                 else if (command == "FJOIN")
921                                 {
922                                         return this->ForceJoin(prefix,params);
923                                 }
924                                 else if (command == "SERVER")
925                                 {
926                                         return this->RemoteServer(prefix,params);
927                                 }
928                                 else if (command == "OPERTYPE")
929                                 {
930                                         return this->OperType(prefix,params);
931                                 }
932                                 else if (command == "FMODE")
933                                 {
934                                         return this->ForceMode(prefix,params);
935                                 }
936                                 else if (command == "KILL")
937                                 {
938                                         return this->RemoteKill(prefix,params);
939                                 }
940                                 else if (command == "SQUIT")
941                                 {
942                                         if (params.size() == 2)
943                                         {
944                                                 this->Squit(FindServer(params[0]),params[1]);
945                                         }
946                                         return true;
947                                 }
948                                 else
949                                 {
950                                         // not a special inter-server command.
951                                         // Emulate the actual user doing the command,
952                                         // this saves us having a huge ugly parser.
953                                         userrec* who = Srv->FindNick(prefix);
954                                         std::string sourceserv = this->myhost;
955                                         if (this->InboundServerName != "")
956                                         {
957                                                 sourceserv = this->InboundServerName;
958                                         }
959                                         if (who)
960                                         {
961                                                 // its a user
962                                                 target = who->server;
963                                                 char* strparams[127];
964                                                 for (unsigned int q = 0; q < params.size(); q++)
965                                                 {
966                                                         strparams[q] = (char*)params[q].c_str();
967                                                 }
968                                                 log(DEBUG,"*** CALL COMMAND HANDLER FOR %s, SOURCE: '%s'",command.c_str(),who->nick);
969                                                 Srv->CallCommandHandler(command, strparams, params.size(), who);
970                                         }
971                                         else
972                                         {
973                                                 // its not a user. Its either a server, or somethings screwed up.
974                                                 if (IsServer(prefix))
975                                                 {
976                                                         target = Srv->GetServerName();
977                                                 }
978                                                 else
979                                                 {
980                                                         log(DEBUG,"Command with unknown origin '%s'",prefix.c_str());
981                                                         return true;
982                                                 }
983                                         }
984                                         return DoOneToAllButSenderRaw(line,sourceserv);
985
986                                 }
987                                 return true;
988                         break;  
989                 }
990                 return true;
991         }
992
993         virtual void OnTimeout()
994         {
995                 if (this->LinkState == CONNECTING)
996                 {
997                         Srv->SendOpers("*** CONNECT: Connection to \002"+myhost+"\002 timed out.");
998                 }
999         }
1000
1001         virtual void OnClose()
1002         {
1003                 // Connection closed.
1004                 // If the connection is fully up (state CONNECTED)
1005                 // then propogate a netsplit to all peers.
1006                 std::string quitserver = this->myhost;
1007                 if (this->InboundServerName != "")
1008                 {
1009                         quitserver = this->InboundServerName;
1010                 }
1011                 TreeServer* s = FindServer(quitserver);
1012                 if (s)
1013                 {
1014                         Squit(s,"Remote host closed the connection");
1015                 }
1016         }
1017
1018         virtual int OnIncomingConnection(int newsock, char* ip)
1019         {
1020                 TreeSocket* s = new TreeSocket(newsock, ip);
1021                 Srv->AddSocket(s);
1022                 return true;
1023         }
1024 };
1025
1026 bool DoOneToAllButSenderRaw(std::string data,std::string omit)
1027 {
1028         for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
1029         {
1030                 TreeServer* Route = TreeRoot->GetChild(x);
1031                 if ((Route->GetSocket()) && (Route->GetName() != omit) && (BestRouteTo(omit) != Route))
1032                 {
1033                         TreeSocket* Sock = Route->GetSocket();
1034                         log(DEBUG,"Sending RAW to %s",Route->GetName().c_str());
1035                         Sock->WriteLine(data);
1036                 }
1037         }
1038         return true;
1039 }
1040
1041 bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> params, std::string omit)
1042 {
1043         log(DEBUG,"ALLBUTONE: Comes from %s SHOULD NOT go back to %s",prefix.c_str(),omit.c_str());
1044         // TODO: Special stuff with privmsg and notice
1045         std::string FullLine = ":" + prefix + " " + command;
1046         for (unsigned int x = 0; x < params.size(); x++)
1047         {
1048                 FullLine = FullLine + " " + params[x];
1049         }
1050         for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
1051         {
1052                 TreeServer* Route = TreeRoot->GetChild(x);
1053                 // Send the line IF:
1054                 // The route has a socket (its a direct connection)
1055                 // The route isnt the one to be omitted
1056                 // The route isnt the path to the one to be omitted
1057                 if ((Route->GetSocket()) && (Route->GetName() != omit) && (BestRouteTo(omit) != Route))
1058                 {
1059                         TreeSocket* Sock = Route->GetSocket();
1060                         log(DEBUG,"Sending to %s",Route->GetName().c_str());
1061                         Sock->WriteLine(FullLine);
1062                 }
1063         }
1064         return true;
1065 }
1066
1067 bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> params)
1068 {
1069         std::string FullLine = ":" + prefix + " " + command;
1070         for (unsigned int x = 0; x < params.size(); x++)
1071         {
1072                 FullLine = FullLine + " " + params[x];
1073         }
1074         for (unsigned int x = 0; x < TreeRoot->ChildCount(); x++)
1075         {
1076                 TreeServer* Route = TreeRoot->GetChild(x);
1077                 if (Route->GetSocket())
1078                 {
1079                         TreeSocket* Sock = Route->GetSocket();
1080                         Sock->WriteLine(FullLine);
1081                 }
1082         }
1083         return true;
1084 }
1085
1086 bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> params, std::string target)
1087 {
1088         TreeServer* Route = BestRouteTo(target);
1089         if (Route)
1090         {
1091                 std::string FullLine = ":" + prefix + " " + command;
1092                 for (unsigned int x = 0; x < params.size(); x++)
1093                 {
1094                         FullLine = FullLine + " " + params[x];
1095                 }
1096                 if (Route->GetSocket())
1097                 {
1098                         TreeSocket* Sock = Route->GetSocket();
1099                         Sock->WriteLine(FullLine);
1100                 }
1101                 return true;
1102         }
1103         else
1104         {
1105                 log(DEBUG,"Could not route message with target %s: %s",target.c_str(),command.c_str());
1106                 return true;
1107         }
1108 }
1109
1110
1111 class ModuleSpanningTree : public Module
1112 {
1113         std::vector<TreeSocket*> Bindings;
1114         int line;
1115
1116  public:
1117
1118         void ReadConfiguration(bool rebind)
1119         {
1120                 if (rebind)
1121                 {
1122                         for (int j =0; j < Conf->Enumerate("bind"); j++)
1123                         {
1124                                 std::string Type = Conf->ReadValue("bind","type",j);
1125                                 std::string IP = Conf->ReadValue("bind","address",j);
1126                                 long Port = Conf->ReadInteger("bind","port",j,true);
1127                                 if (Type == "servers")
1128                                 {
1129                                         if (IP == "*")
1130                                         {
1131                                                 IP = "";
1132                                         }
1133                                         TreeSocket* listener = new TreeSocket(IP.c_str(),Port,true,10);
1134                                         if (listener->GetState() == I_LISTENING)
1135                                         {
1136                                                 Srv->AddSocket(listener);
1137                                                 Bindings.push_back(listener);
1138                                         }
1139                                         else
1140                                         {
1141                                                 log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port);
1142                                                 listener->Close();
1143                                                 delete listener;
1144                                         }
1145                                 }
1146                         }
1147                 }
1148                 LinkBlocks.clear();
1149                 for (int j =0; j < Conf->Enumerate("link"); j++)
1150                 {
1151                         Link L;
1152                         L.Name = Conf->ReadValue("link","name",j);
1153                         L.IPAddr = Conf->ReadValue("link","ipaddr",j);
1154                         L.Port = Conf->ReadInteger("link","port",j,true);
1155                         L.SendPass = Conf->ReadValue("link","sendpass",j);
1156                         L.RecvPass = Conf->ReadValue("link","recvpass",j);
1157                         LinkBlocks.push_back(L);
1158                         log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port);
1159                 }
1160         }
1161
1162         ModuleSpanningTree()
1163         {
1164                 Srv = new Server;
1165                 Conf = new ConfigReader;
1166                 Bindings.clear();
1167
1168                 // Create the root of the tree
1169                 TreeRoot = new TreeServer(Srv->GetServerName(),Srv->GetServerDescription());
1170
1171                 ReadConfiguration(true);
1172         }
1173
1174         void ShowLinks(TreeServer* Current, userrec* user, int hops)
1175         {
1176                 std::string Parent = TreeRoot->GetName();
1177                 if (Current->GetParent())
1178                 {
1179                         Parent = Current->GetParent()->GetName();
1180                 }
1181                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
1182                 {
1183                         ShowLinks(Current->GetChild(q),user,hops+1);
1184                 }
1185                 WriteServ(user->fd,"364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),Parent.c_str(),hops,Current->GetDesc().c_str());
1186         }
1187
1188         void HandleLinks(char** parameters, int pcnt, userrec* user)
1189         {
1190                 ShowLinks(TreeRoot,user,0);
1191                 WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
1192                 return;
1193         }
1194
1195         void HandleLusers(char** parameters, int pcnt, userrec* user)
1196         {
1197                 return;
1198         }
1199
1200         // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS.
1201
1202         void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80])
1203         {
1204                 if (line < 128)
1205                 {
1206                         for (int t = 0; t < depth; t++)
1207                         {
1208                                 matrix[line][t] = ' ';
1209                         }
1210                         strlcpy(&matrix[line][depth],Current->GetName().c_str(),80);
1211                         line++;
1212                         for (unsigned int q = 0; q < Current->ChildCount(); q++)
1213                         {
1214                                 ShowMap(Current->GetChild(q),user,depth+2,matrix);
1215                         }
1216                 }
1217         }
1218
1219         // Ok, prepare to be confused.
1220         // After much mulling over how to approach this, it struck me that
1221         // the 'usual' way of doing a /MAP isnt the best way. Instead of
1222         // keeping track of a ton of ascii characters, and line by line
1223         // under recursion working out where to place them using multiplications
1224         // and divisons, we instead render the map onto a backplane of characters
1225         // (a character matrix), then draw the branches as a series of "L" shapes
1226         // from the nodes. This is not only friendlier on CPU it uses less stack.
1227
1228         void HandleMap(char** parameters, int pcnt, userrec* user)
1229         {
1230                 // This array represents a virtual screen which we will
1231                 // "scratch" draw to, as the console device of an irc
1232                 // client does not provide for a proper terminal.
1233                 char matrix[128][80];
1234                 for (unsigned int t = 0; t < 128; t++)
1235                 {
1236                         matrix[t][0] = '\0';
1237                 }
1238                 line = 0;
1239                 // The only recursive bit is called here.
1240                 ShowMap(TreeRoot,user,0,matrix);
1241                 // Process each line one by one. The algorithm has a limit of
1242                 // 128 servers (which is far more than a spanning tree should have
1243                 // anyway, so we're ok). This limit can be raised simply by making
1244                 // the character matrix deeper, 128 rows taking 10k of memory.
1245                 for (int l = 1; l < line; l++)
1246                 {
1247                         // scan across the line looking for the start of the
1248                         // servername (the recursive part of the algorithm has placed
1249                         // the servers at indented positions depending on what they
1250                         // are related to)
1251                         int first_nonspace = 0;
1252                         while (matrix[l][first_nonspace] == ' ')
1253                         {
1254                                 first_nonspace++;
1255                         }
1256                         first_nonspace--;
1257                         // Draw the `- (corner) section: this may be overwritten by
1258                         // another L shape passing along the same vertical pane, becoming
1259                         // a |- (branch) section instead.
1260                         matrix[l][first_nonspace] = '-';
1261                         matrix[l][first_nonspace-1] = '`';
1262                         int l2 = l - 1;
1263                         // Draw upwards until we hit the parent server, causing possibly
1264                         // other corners (`-) to become branches (|-)
1265                         while ((matrix[l2][first_nonspace-1] == ' ') || (matrix[l2][first_nonspace-1] == '`'))
1266                         {
1267                                 matrix[l2][first_nonspace-1] = '|';
1268                                 l2--;
1269                         }
1270                 }
1271                 // dump the whole lot to the user. This is the easy bit, honest.
1272                 for (int t = 0; t < line; t++)
1273                 {
1274                         WriteServ(user->fd,"006 %s :%s",user->nick,&matrix[t][0]);
1275                 }
1276                 WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
1277                 return;
1278         }
1279
1280         int HandleSquit(char** parameters, int pcnt, userrec* user)
1281         {
1282                 return 1;
1283         }
1284
1285         int HandleConnect(char** parameters, int pcnt, userrec* user)
1286         {
1287                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
1288                 {
1289                         if (Srv->MatchText(x->Name.c_str(),parameters[0]))
1290                         {
1291                                 WriteServ(user->fd,"NOTICE %s :*** CONNECT: Connecting to server: %s (%s:%d)",user->nick,x->Name.c_str(),x->IPAddr.c_str(),x->Port);
1292                                 TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
1293                                 Srv->AddSocket(newsocket);
1294                                 return 1;
1295                         }
1296                 }
1297                 WriteServ(user->fd,"NOTICE %s :*** CONNECT: No matching server could be found in the config file.",user->nick);
1298                 return 1;
1299         }
1300
1301         virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user)
1302         {
1303                 if (command == "CONNECT")
1304                 {
1305                         return this->HandleConnect(parameters,pcnt,user);
1306                 }
1307                 else if (command == "SQUIT")
1308                 {
1309                         return this->HandleSquit(parameters,pcnt,user);
1310                 }
1311                 else if (command == "MAP")
1312                 {
1313                         this->HandleMap(parameters,pcnt,user);
1314                         return 1;
1315                 }
1316                 else if (command == "LUSERS")
1317                 {
1318                         this->HandleLusers(parameters,pcnt,user);
1319                         return 1;
1320                 }
1321                 else if (command == "LINKS")
1322                 {
1323                         this->HandleLinks(parameters,pcnt,user);
1324                         return 1;
1325                 }
1326                 return 0;
1327         }
1328
1329         virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text)
1330         {
1331                 if (target_type == TYPE_USER)
1332                 {
1333                         userrec* d = (userrec*)dest;
1334                         if ((std::string(d->server) != Srv->GetServerName()) && (std::string(user->server) == Srv->GetServerName()))
1335                         {
1336                                 std::deque<std::string> params;
1337                                 params.clear();
1338                                 params.push_back(d->nick);
1339                                 params.push_back(":"+text);
1340                                 DoOneToOne(user->nick,"NOTICE",params,d->server);
1341                         }
1342                 }
1343                 else
1344                 {
1345                         if (std::string(user->server) == Srv->GetServerName())
1346                         {
1347                                 chanrec *c = (chanrec*)dest;
1348                                 std::deque<std::string> params;
1349                                 params.push_back(c->name);
1350                                 params.push_back(":"+text);
1351                                 DoOneToMany(user->nick,"NOTICE",params);
1352                         }
1353                 }
1354         }
1355
1356         virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text)
1357         {
1358                 if (target_type == TYPE_USER)
1359                 {
1360                         // route private messages which are targetted at clients only to the server
1361                         // which needs to receive them
1362                         userrec* d = (userrec*)dest;
1363                         if ((std::string(d->server) != Srv->GetServerName()) && (std::string(user->server) == Srv->GetServerName()))
1364                         {
1365                                 std::deque<std::string> params;
1366                                 params.clear();
1367                                 params.push_back(d->nick);
1368                                 params.push_back(":"+text);
1369                                 DoOneToOne(user->nick,"PRIVMSG",params,d->server);
1370                         }
1371                 }
1372                 else
1373                 {
1374                         if (std::string(user->server) == Srv->GetServerName())
1375                         {
1376                                 chanrec *c = (chanrec*)dest;
1377                                 std::deque<std::string> params;
1378                                 params.push_back(c->name);
1379                                 params.push_back(":"+text);
1380                                 DoOneToMany(user->nick,"PRIVMSG",params);
1381                         }
1382                 }
1383         }
1384
1385         virtual void OnUserJoin(userrec* user, chanrec* channel)
1386         {
1387                 // Only do this for local users
1388                 if (std::string(user->server) == Srv->GetServerName())
1389                 {
1390                         log(DEBUG,"**** User on %s JOINS %s",user->server,channel->name);
1391                         std::deque<std::string> params;
1392                         params.clear();
1393                         params.push_back(channel->name);
1394                         if (*channel->key)
1395                         {
1396                                 log(DEBUG,"**** With key %s",channel->key);
1397                                 // if the channel has a key, force the join by emulating the key.
1398                                 params.push_back(channel->key);
1399                         }
1400                         DoOneToMany(user->nick,"JOIN",params);
1401                 }
1402         }
1403
1404         virtual void OnUserPart(userrec* user, chanrec* channel)
1405         {
1406                 if (std::string(user->server) == Srv->GetServerName())
1407                 {
1408                         log(DEBUG,"**** User on %s PARTS %s",user->server,channel->name);
1409                         std::deque<std::string> params;
1410                         params.clear();
1411                         params.push_back(channel->name);
1412                         DoOneToMany(user->nick,"PART",params);
1413                 }
1414         }
1415
1416         virtual void OnUserConnect(userrec* user)
1417         {
1418                 char agestr[MAXBUF];
1419                 if (std::string(user->server) == Srv->GetServerName())
1420                 {
1421                         log(DEBUG,"**** User on %s CONNECTS: %s",user->server,user->nick);
1422                         std::deque<std::string> params;
1423                         snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
1424                         params.clear();
1425                         params.push_back(agestr);
1426                         params.push_back(user->nick);
1427                         params.push_back(user->host);
1428                         params.push_back(user->dhost);
1429                         params.push_back(user->ident);
1430                         params.push_back("+"+std::string(user->modes));
1431                         params.push_back(user->ip);
1432                         params.push_back(":"+std::string(user->fullname));
1433                         DoOneToMany(Srv->GetServerName(),"NICK",params);
1434                 }
1435         }
1436
1437         virtual void OnUserQuit(userrec* user, std::string reason)
1438         {
1439                 if (std::string(user->server) == Srv->GetServerName())
1440                 {
1441                         log(DEBUG,"**** User on %s QUITS: %s",user->server,user->nick);
1442                         std::deque<std::string> params;
1443                         params.push_back(":"+reason);
1444                         DoOneToMany(user->nick,"QUIT",params);
1445                 }
1446         }
1447
1448         virtual void OnUserPostNick(userrec* user, std::string oldnick)
1449         {
1450                 if (std::string(user->server) == Srv->GetServerName())
1451                 {
1452                         log(DEBUG,"**** User on %s changes NICK: %s",user->server,user->nick);
1453                         std::deque<std::string> params;
1454                         params.push_back(user->nick);
1455                         DoOneToMany(oldnick,"NICK",params);
1456                 }
1457         }
1458
1459         virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
1460         {
1461                 if (std::string(source->server) == Srv->GetServerName())
1462                 {
1463                         log(DEBUG,"**** User on %s KICKs: %s %s",source->server,source->nick,user->nick);
1464                         std::deque<std::string> params;
1465                         params.push_back(chan->name);
1466                         params.push_back(user->nick);
1467                         params.push_back(":"+reason);
1468                         DoOneToMany(source->nick,"KICK",params);
1469                 }
1470         }
1471
1472         virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
1473         {
1474                 std::deque<std::string> params;
1475                 params.push_back(dest->nick);
1476                 params.push_back(":"+reason);
1477                 DoOneToMany(source->nick,"KILL",params);
1478         }
1479
1480         // note: the protocol does not allow direct umode +o except
1481         // via NICK with 8 params. sending OPERTYPE infers +o modechange
1482         // locally.
1483         virtual void OnOper(userrec* user, std::string opertype)
1484         {
1485                 if (std::string(user->server) == Srv->GetServerName())
1486                 {
1487                         std::deque<std::string> params;
1488                         params.push_back(opertype);
1489                         DoOneToMany(user->nick,"OPERTYPE",params);
1490                 }
1491         }
1492
1493         virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
1494         {
1495                 log(DEBUG,"*** ONMODE TRIGGER");
1496                 if (std::string(user->server) == Srv->GetServerName())
1497                 {
1498                         log(DEBUG,"*** LOCAL");
1499                         if (target_type == TYPE_USER)
1500                         {
1501                                 userrec* u = (userrec*)dest;
1502                                 std::deque<std::string> params;
1503                                 params.push_back(u->nick);
1504                                 params.push_back(text);
1505                                 DoOneToMany(user->nick,"MODE",params);
1506                         }
1507                         else
1508                         {
1509                                 chanrec* c = (chanrec*)dest;
1510                                 std::deque<std::string> params;
1511                                 params.push_back(c->name);
1512                                 params.push_back(text);
1513                                 DoOneToMany(user->nick,"MODE",params);
1514                         }
1515                 }
1516         }
1517
1518         virtual ~ModuleSpanningTree()
1519         {
1520                 delete Srv;
1521         }
1522
1523         virtual Version GetVersion()
1524         {
1525                 return Version(1,0,0,0,VF_STATIC|VF_VENDOR);
1526         }
1527 };
1528
1529
1530 class ModuleSpanningTreeFactory : public ModuleFactory
1531 {
1532  public:
1533         ModuleSpanningTreeFactory()
1534         {
1535         }
1536         
1537         ~ModuleSpanningTreeFactory()
1538         {
1539         }
1540         
1541         virtual Module * CreateModule()
1542         {
1543                 return new ModuleSpanningTree;
1544         }
1545         
1546 };
1547
1548
1549 extern "C" void * init_module( void )
1550 {
1551         return new ModuleSpanningTreeFactory;
1552 }
1553