]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/modules/m_spanningtree.cpp
a95d40b2f00c4b3347d49041db7f1c404949dbd5
[user/henk/code/inspircd.git] / src / modules / m_spanningtree.cpp
1 /*       +------------------------------------+
2  *       | Inspire Internet Relay Chat Daemon |
3  *       +------------------------------------+
4  *
5  *  InspIRCd is copyright (C) 2002-2006 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 /* $ModDesc: Povides a spanning tree server link protocol */
18
19 using namespace std;
20
21 #include <stdio.h>
22 #include <vector>
23 #include <deque>
24 #include "globals.h"
25 #include "inspircd_config.h"
26 #ifdef GCC3
27 #include <ext/hash_map>
28 #else
29 #include <hash_map>
30 #endif
31 #include "users.h"
32 #include "channels.h"
33 #include "modules.h"
34 #include "commands.h"
35 #include "socket.h"
36 #include "helperfuncs.h"
37 #include "inspircd.h"
38 #include "inspstring.h"
39 #include "hashcomp.h"
40 #include "message.h"
41 #include "xline.h"
42 #include "typedefs.h"
43 #include "cull_list.h"
44 #include "aes.h"
45
46 #ifdef GCC3
47 #define nspace __gnu_cxx
48 #else
49 #define nspace std
50 #endif
51
52 /*
53  * The server list in InspIRCd is maintained as two structures
54  * which hold the data in different ways. Most of the time, we
55  * want to very quicky obtain three pieces of information:
56  *
57  * (1) The information on a server
58  * (2) The information on the server we must send data through
59  *     to actually REACH the server we're after
60  * (3) Potentially, the child/parent objects of this server
61  *
62  * The InspIRCd spanning protocol provides easy access to these
63  * by storing the data firstly in a recursive structure, where
64  * each item references its parent item, and a dynamic list
65  * of child items, and another structure which stores the items
66  * hashed, linearly. This means that if we want to find a server
67  * by name quickly, we can look it up in the hash, avoiding
68  * any O(n) lookups. If however, during a split or sync, we want
69  * to apply an operation to a server, and any of its child objects
70  * we can resort to recursion to walk the tree structure.
71  */
72
73 class ModuleSpanningTree;
74 static ModuleSpanningTree* TreeProtocolModule;
75
76 extern ServerConfig* Config;
77
78 extern std::vector<Module*> modules;
79 extern std::vector<ircd_module*> factory;
80 extern int MODCOUNT;
81
82 /* Any socket can have one of five states at any one time.
83  * The LISTENER state indicates a socket which is listening
84  * for connections. It cannot receive data itself, only incoming
85  * sockets.
86  * The CONNECTING state indicates an outbound socket which is
87  * waiting to be writeable.
88  * The WAIT_AUTH_1 state indicates the socket is outbound and
89  * has successfully connected, but has not yet sent and received
90  * SERVER strings.
91  * The WAIT_AUTH_2 state indicates that the socket is inbound
92  * (allocated by a LISTENER) but has not yet sent and received
93  * SERVER strings.
94  * The CONNECTED state represents a fully authorized, fully
95  * connected server.
96  */
97 enum ServerState { LISTENER, CONNECTING, WAIT_AUTH_1, WAIT_AUTH_2, CONNECTED };
98
99 /* We need to import these from the core for use in netbursts */
100 extern user_hash clientlist;
101 extern chan_hash chanlist;
102
103 /* Foward declarations */
104 class TreeServer;
105 class TreeSocket;
106
107 /* This variable represents the root of the server tree
108  * (for all intents and purposes, it's us)
109  */
110 TreeServer *TreeRoot;
111
112 Server* Srv;
113
114 /* This hash_map holds the hash equivalent of the server
115  * tree, used for rapid linear lookups.
116  */
117 typedef nspace::hash_map<std::string, TreeServer*> server_hash;
118 server_hash serverlist;
119
120 /* More forward declarations */
121 bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> &params, std::string target);
122 bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> &params, std::string omit);
123 bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> &params);
124 bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> &params);
125 void ReadConfiguration(bool rebind);
126
127 /* Flatten links and /MAP for non-opers */
128 bool FlatLinks;
129 /* Hide U-Lined servers in /MAP and /LINKS */
130 bool HideULines;
131
132 /* Imported from xline.cpp for use during netburst */
133 extern std::vector<KLine> klines;
134 extern std::vector<GLine> glines;
135 extern std::vector<ZLine> zlines;
136 extern std::vector<QLine> qlines;
137 extern std::vector<ELine> elines;
138 extern std::vector<KLine> pklines;
139 extern std::vector<GLine> pglines;
140 extern std::vector<ZLine> pzlines;
141 extern std::vector<QLine> pqlines;
142 extern std::vector<ELine> pelines;
143
144 /* Each server in the tree is represented by one class of
145  * type TreeServer. A locally connected TreeServer can
146  * have a class of type TreeSocket associated with it, for
147  * remote servers, the TreeSocket entry will be NULL.
148  * Each server also maintains a pointer to its parent
149  * (NULL if this server is ours, at the top of the tree)
150  * and a pointer to its "Route" (see the comments in the
151  * constructors below), and also a dynamic list of pointers
152  * to its children which can be iterated recursively
153  * if required. Creating or deleting objects of type
154  * TreeServer automatically maintains the hash_map of
155  * TreeServer items, deleting and inserting them as they
156  * are created and destroyed.
157  */
158
159 class TreeServer
160 {
161         TreeServer* Parent;                     /* Parent entry */
162         TreeServer* Route;                      /* Route entry */
163         std::vector<TreeServer*> Children;      /* List of child objects */
164         std::string ServerName;                 /* Server's name */
165         std::string ServerDesc;                 /* Server's description */
166         std::string VersionString;              /* Version string or empty string */
167         int UserCount;                          /* Not used in this version */
168         int OperCount;                          /* Not used in this version */
169         TreeSocket* Socket;                     /* For directly connected servers this points at the socket object */
170         time_t NextPing;                        /* After this time, the server should be PINGed*/
171         bool LastPingWasGood;                   /* True if the server responded to the last PING with a PONG */
172         
173  public:
174
175         /* We don't use this constructor. Its a dummy, and won't cause any insertion
176          * of the TreeServer into the hash_map. See below for the two we DO use.
177          */
178         TreeServer()
179         {
180                 Parent = NULL;
181                 ServerName = "";
182                 ServerDesc = "";
183                 VersionString = "";
184                 UserCount = OperCount = 0;
185                 VersionString = Srv->GetVersion();
186         }
187
188         /* We use this constructor only to create the 'root' item, TreeRoot, which
189          * represents our own server. Therefore, it has no route, no parent, and
190          * no socket associated with it. Its version string is our own local version.
191          */
192         TreeServer(std::string Name, std::string Desc) : ServerName(Name), ServerDesc(Desc)
193         {
194                 Parent = NULL;
195                 VersionString = "";
196                 UserCount = OperCount = 0;
197                 VersionString = Srv->GetVersion();
198                 Route = NULL;
199                 Socket = NULL; /* Fix by brain */
200                 AddHashEntry();
201         }
202
203         /* When we create a new server, we call this constructor to initialize it.
204          * This constructor initializes the server's Route and Parent, and sets up
205          * its ping counters so that it will be pinged one minute from now.
206          */
207         TreeServer(std::string Name, std::string Desc, TreeServer* Above, TreeSocket* Sock) : Parent(Above), ServerName(Name), ServerDesc(Desc), Socket(Sock)
208         {
209                 VersionString = "";
210                 UserCount = OperCount = 0;
211                 this->SetNextPingTime(time(NULL) + 120);
212                 this->SetPingFlag();
213
214                 /* find the 'route' for this server (e.g. the one directly connected
215                  * to the local server, which we can use to reach it)
216                  *
217                  * In the following example, consider we have just added a TreeServer
218                  * class for server G on our network, of which we are server A.
219                  * To route traffic to G (marked with a *) we must send the data to
220                  * B (marked with a +) so this algorithm initializes the 'Route'
221                  * value to point at whichever server traffic must be routed through
222                  * to get here. If we were to try this algorithm with server B,
223                  * the Route pointer would point at its own object ('this').
224                  *
225                  *              A
226                  *             / \
227                  *          + B   C
228                  *           / \   \
229                  *          D   E   F
230                  *         /         \
231                  *      * G           H
232                  *
233                  * We only run this algorithm when a server is created, as
234                  * the routes remain constant while ever the server exists, and
235                  * do not need to be re-calculated.
236                  */
237
238                 Route = Above;
239                 if (Route == TreeRoot)
240                 {
241                         Route = this;
242                 }
243                 else
244                 {
245                         while (this->Route->GetParent() != TreeRoot)
246                         {
247                                 this->Route = Route->GetParent();
248                         }
249                 }
250
251                 /* Because recursive code is slow and takes a lot of resources,
252                  * we store two representations of the server tree. The first
253                  * is a recursive structure where each server references its
254                  * children and its parent, which is used for netbursts and
255                  * netsplits to dump the whole dataset to the other server,
256                  * and the second is used for very fast lookups when routing
257                  * messages and is instead a hash_map, where each item can
258                  * be referenced by its server name. The AddHashEntry()
259                  * call below automatically inserts each TreeServer class
260                  * into the hash_map as it is created. There is a similar
261                  * maintainance call in the destructor to tidy up deleted
262                  * servers.
263                  */
264
265                 this->AddHashEntry();
266         }
267
268         /* This method is used to add the structure to the
269          * hash_map for linear searches. It is only called
270          * by the constructors.
271          */
272         void AddHashEntry()
273         {
274                 server_hash::iterator iter;
275                 iter = serverlist.find(this->ServerName);
276                 if (iter == serverlist.end())
277                         serverlist[this->ServerName] = this;
278         }
279
280         /* This method removes the reference to this object
281          * from the hash_map which is used for linear searches.
282          * It is only called by the default destructor.
283          */
284         void DelHashEntry()
285         {
286                 server_hash::iterator iter;
287                 iter = serverlist.find(this->ServerName);
288                 if (iter != serverlist.end())
289                         serverlist.erase(iter);
290         }
291
292         /* These accessors etc should be pretty self-
293          * explanitory.
294          */
295
296         TreeServer* GetRoute()
297         {
298                 return Route;
299         }
300
301         std::string GetName()
302         {
303                 return ServerName;
304         }
305
306         std::string GetDesc()
307         {
308                 return ServerDesc;
309         }
310
311         std::string GetVersion()
312         {
313                 return VersionString;
314         }
315
316         void SetNextPingTime(time_t t)
317         {
318                 this->NextPing = t;
319                 LastPingWasGood = false;
320         }
321
322         time_t NextPingTime()
323         {
324                 return NextPing;
325         }
326
327         bool AnsweredLastPing()
328         {
329                 return LastPingWasGood;
330         }
331
332         void SetPingFlag()
333         {
334                 LastPingWasGood = true;
335         }
336
337         int GetUserCount()
338         {
339                 return UserCount;
340         }
341
342         void AddUserCount()
343         {
344                 UserCount++;
345         }
346
347         void DelUserCount()
348         {
349                 UserCount--;
350         }
351
352         int GetOperCount()
353         {
354                 return OperCount;
355         }
356
357         TreeSocket* GetSocket()
358         {
359                 return Socket;
360         }
361
362         TreeServer* GetParent()
363         {
364                 return Parent;
365         }
366
367         void SetVersion(std::string Version)
368         {
369                 VersionString = Version;
370         }
371
372         unsigned int ChildCount()
373         {
374                 return Children.size();
375         }
376
377         TreeServer* GetChild(unsigned int n)
378         {
379                 if (n < Children.size())
380                 {
381                         /* Make sure they  cant request
382                          * an out-of-range object. After
383                          * all we know what these programmer
384                          * types are like *grin*.
385                          */
386                         return Children[n];
387                 }
388                 else
389                 {
390                         return NULL;
391                 }
392         }
393
394         void AddChild(TreeServer* Child)
395         {
396                 Children.push_back(Child);
397         }
398
399         bool DelChild(TreeServer* Child)
400         {
401                 for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
402                 {
403                         if (*a == Child)
404                         {
405                                 Children.erase(a);
406                                 return true;
407                         }
408                 }
409                 return false;
410         }
411
412         /* Removes child nodes of this node, and of that node, etc etc.
413          * This is used during netsplits to automatically tidy up the
414          * server tree. It is slow, we don't use it for much else.
415          */
416         bool Tidy()
417         {
418                 bool stillchildren = true;
419                 while (stillchildren)
420                 {
421                         stillchildren = false;
422                         for (std::vector<TreeServer*>::iterator a = Children.begin(); a < Children.end(); a++)
423                         {
424                                 TreeServer* s = (TreeServer*)*a;
425                                 s->Tidy();
426                                 Children.erase(a);
427                                 delete s;
428                                 stillchildren = true;
429                                 break;
430                         }
431                 }
432                 return true;
433         }
434
435         ~TreeServer()
436         {
437                 /* We'd better tidy up after ourselves, eh? */
438                 this->DelHashEntry();
439         }
440 };
441
442 /* The Link class might as well be a struct,
443  * but this is C++ and we don't believe in structs (!).
444  * It holds the entire information of one <link>
445  * tag from the main config file. We maintain a list
446  * of them, and populate the list on rehash/load.
447  */
448
449 class Link
450 {
451  public:
452          std::string Name;
453          std::string IPAddr;
454          int Port;
455          std::string SendPass;
456          std::string RecvPass;
457          unsigned long AutoConnect;
458          time_t NextConnectTime;
459          std::string EncryptionKey;
460          bool HiddenFromStats;
461 };
462
463 /* The usual stuff for inspircd modules,
464  * plus the vector of Link classes which we
465  * use to store the <link> tags from the config
466  * file.
467  */
468 ConfigReader *Conf;
469 std::vector<Link> LinkBlocks;
470
471 /* Yay for fast searches!
472  * This is hundreds of times faster than recursion
473  * or even scanning a linked list, especially when
474  * there are more than a few servers to deal with.
475  * (read as: lots).
476  */
477 TreeServer* FindServer(std::string ServerName)
478 {
479         server_hash::iterator iter;
480         iter = serverlist.find(ServerName);
481         if (iter != serverlist.end())
482         {
483                 return iter->second;
484         }
485         else
486         {
487                 return NULL;
488         }
489 }
490
491 /* Returns the locally connected server we must route a
492  * message through to reach server 'ServerName'. This
493  * only applies to one-to-one and not one-to-many routing.
494  * See the comments for the constructor of TreeServer
495  * for more details.
496  */
497 TreeServer* BestRouteTo(std::string ServerName)
498 {
499         if (ServerName.c_str() == TreeRoot->GetName())
500                 return NULL;
501         TreeServer* Found = FindServer(ServerName);
502         if (Found)
503         {
504                 return Found->GetRoute();
505         }
506         else
507         {
508                 return NULL;
509         }
510 }
511
512 /* Find the first server matching a given glob mask.
513  * Theres no find-using-glob method of hash_map [awwww :-(]
514  * so instead, we iterate over the list using an iterator
515  * and match each one until we get a hit. Yes its slow,
516  * deal with it.
517  */
518 TreeServer* FindServerMask(std::string ServerName)
519 {
520         for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
521         {
522                 if (Srv->MatchText(i->first,ServerName))
523                         return i->second;
524         }
525         return NULL;
526 }
527
528 /* A convenient wrapper that returns true if a server exists */
529 bool IsServer(std::string ServerName)
530 {
531         return (FindServer(ServerName) != NULL);
532 }
533
534
535 class cmd_rconnect : public command_t    
536 {
537         Module* Creator;
538  public:
539          cmd_rconnect (Module* Callback) : command_t("RCONNECT", 'o', 2), Creator(Callback)
540          {
541                 this->source = "m_spanningtree.so";
542          }
543                 
544          void Handle (char **parameters, int pcnt, userrec *user)
545          {
546                 WriteServ(user->fd,"NOTICE %s :*** RCONNECT: Sending remote connect to \002%s\002 to connect server \002%s\002.",user->nick,parameters[0],parameters[1]);
547                 /* Is this aimed at our server? */
548                 if (Srv->MatchText(Srv->GetServerName(),parameters[0]))
549                 {
550                         /* Yes, initiate the given connect */
551                         WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]);
552                         char* para[1];
553                         para[0] = parameters[1];
554                         Creator->OnPreCommand("CONNECT", para, 1, user, true);
555                 }
556          }
557 };
558          
559
560
561 /* Every SERVER connection inbound or outbound is represented by
562  * an object of type TreeSocket.
563  * TreeSockets, being inherited from InspSocket, can be tied into
564  * the core socket engine, and we cn therefore receive activity events
565  * for them, just like activex objects on speed. (yes really, that
566  * is a technical term!) Each of these which relates to a locally
567  * connected server is assocated with it, by hooking it onto a
568  * TreeSocket class using its constructor. In this way, we can
569  * maintain a list of servers, some of which are directly connected,
570  * some of which are not.
571  */
572
573 class TreeSocket : public InspSocket
574 {
575         std::string myhost;
576         std::string in_buffer;
577         ServerState LinkState;
578         std::string InboundServerName;
579         std::string InboundDescription;
580         int num_lost_users;
581         int num_lost_servers;
582         time_t NextPing;
583         bool LastPingWasGood;
584         bool bursting;
585         AES* ctx_in;
586         AES* ctx_out;
587         unsigned int keylength;
588         
589  public:
590
591         /* Because most of the I/O gubbins are encapsulated within
592          * InspSocket, we just call the superclass constructor for
593          * most of the action, and append a few of our own values
594          * to it.
595          */
596         TreeSocket(std::string host, int port, bool listening, unsigned long maxtime)
597                 : InspSocket(host, port, listening, maxtime)
598         {
599                 myhost = host;
600                 this->LinkState = LISTENER;
601                 this->ctx_in = NULL;
602                 this->ctx_out = NULL;
603         }
604
605         TreeSocket(std::string host, int port, bool listening, unsigned long maxtime, std::string ServerName)
606                 : InspSocket(host, port, listening, maxtime)
607         {
608                 myhost = ServerName;
609                 this->LinkState = CONNECTING;
610                 this->ctx_in = NULL;
611                 this->ctx_out = NULL;
612         }
613
614         /* When a listening socket gives us a new file descriptor,
615          * we must associate it with a socket without creating a new
616          * connection. This constructor is used for this purpose.
617          */
618         TreeSocket(int newfd, char* ip)
619                 : InspSocket(newfd, ip)
620         {
621                 this->LinkState = WAIT_AUTH_1;
622                 this->ctx_in = NULL;
623                 this->ctx_out = NULL;
624                 this->SendCapabilities();
625         }
626
627         ~TreeSocket()
628         {
629                 if (ctx_in)
630                         delete ctx_in;
631                 if (ctx_out)
632                         delete ctx_out;
633         }
634
635         void InitAES(std::string key,std::string SName)
636         {
637                 if (key == "")
638                         return;
639
640                 ctx_in = new AES();
641                 ctx_out = new AES();
642                 log(DEBUG,"Initialized AES key %s",key.c_str());
643                 // key must be 16, 24, 32 etc bytes (multiple of 8)
644                 keylength = key.length();
645                 if (!(keylength == 16 || keylength == 24 || keylength == 32))
646                 {
647                         WriteOpers("*** \2ERROR\2: Key length for encryptionkey is not 16, 24 or 32 bytes in length!");
648                         log(DEBUG,"Key length not 16, 24 or 32 characters!");
649                 }
650                 else
651                 {
652                         WriteOpers("*** \2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
653                         ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
654                                 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
655                         ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
656                                 \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
657                 }
658         }
659         
660         /* When an outbound connection finishes connecting, we receive
661          * this event, and must send our SERVER string to the other
662          * side. If the other side is happy, as outlined in the server
663          * to server docs on the inspircd.org site, the other side
664          * will then send back its own server string.
665          */
666         virtual bool OnConnected()
667         {
668                 if (this->LinkState == CONNECTING)
669                 {
670                         /* we do not need to change state here. */
671                         for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
672                         {
673                                 if (x->Name == this->myhost)
674                                 {
675                                         Srv->SendOpers("*** Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] established.");
676                                         this->SendCapabilities();
677                                         if (x->EncryptionKey != "")
678                                         {
679                                                 if (!(x->EncryptionKey.length() == 16 || x->EncryptionKey.length() == 24 || x->EncryptionKey.length() == 32))
680                                                 {
681                                                         WriteOpers("\2WARNING\2: Your encryption key is NOT 16, 24 or 32 characters in length, encryption will \2NOT\2 be enabled.");
682                                                 }
683                                                 else
684                                                 {
685                                                         this->WriteLine("AES "+Srv->GetServerName());
686                                                         this->InitAES(x->EncryptionKey,x->Name);
687                                                 }
688                                         }
689                                         /* found who we're supposed to be connecting to, send the neccessary gubbins. */
690                                         this->WriteLine("SERVER "+Srv->GetServerName()+" "+x->SendPass+" 0 :"+Srv->GetServerDescription());
691                                         return true;
692                                 }
693                         }
694                 }
695                 /* There is a (remote) chance that between the /CONNECT and the connection
696                  * being accepted, some muppet has removed the <link> block and rehashed.
697                  * If that happens the connection hangs here until it's closed. Unlikely
698                  * and rather harmless.
699                  */
700                 Srv->SendOpers("*** Connection to \2"+myhost+"\2 lost link tag(!)");
701                 return true;
702         }
703         
704         virtual void OnError(InspSocketError e)
705         {
706                 /* We don't handle this method, because all our
707                  * dirty work is done in OnClose() (see below)
708                  * which is still called on error conditions too.
709                  */
710         }
711
712         virtual int OnDisconnect()
713         {
714                 /* For the same reason as above, we don't
715                  * handle OnDisconnect()
716                  */
717                 return true;
718         }
719
720         /* Recursively send the server tree with distances as hops.
721          * This is used during network burst to inform the other server
722          * (and any of ITS servers too) of what servers we know about.
723          * If at any point any of these servers already exist on the other
724          * end, our connection may be terminated. The hopcounts given
725          * by this function are relative, this doesn't matter so long as
726          * they are all >1, as all the remote servers re-calculate them
727          * to be relative too, with themselves as hop 0.
728          */
729         void SendServers(TreeServer* Current, TreeServer* s, int hops)
730         {
731                 char command[1024];
732                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
733                 {
734                         TreeServer* recursive_server = Current->GetChild(q);
735                         if (recursive_server != s)
736                         {
737                                 snprintf(command,1024,":%s SERVER %s * %d :%s",Current->GetName().c_str(),recursive_server->GetName().c_str(),hops,recursive_server->GetDesc().c_str());
738                                 this->WriteLine(command);
739                                 this->WriteLine(":"+recursive_server->GetName()+" VERSION :"+recursive_server->GetVersion());
740                                 /* down to next level */
741                                 this->SendServers(recursive_server, s, hops+1);
742                         }
743                 }
744         }
745
746         std::string MyCapabilities()
747         {
748                 ServerConfig* Config = Srv->GetConfig();
749                 std::vector<std::string> modlist;
750                 std::string capabilities = "";
751
752                 for (int i = 0; i <= MODCOUNT; i++)
753                 {
754                         if ((modules[i]->GetVersion().Flags & VF_STATIC) || (modules[i]->GetVersion().Flags & VF_COMMON))
755                                 modlist.push_back(Config->module_names[i]);
756                 }
757                 sort(modlist.begin(),modlist.end());
758                 for (unsigned int i = 0; i < modlist.size(); i++)
759                 {
760                         if (i)
761                                 capabilities = capabilities + ",";
762                         capabilities = capabilities + modlist[i];
763                 }
764                 return capabilities;
765         }
766         
767         void SendCapabilities()
768         {
769                 this->WriteLine("CAPAB "+MyCapabilities());
770         }
771
772         bool Capab(std::deque<std::string> params)
773         {
774                 if (params.size() != 1)
775                 {
776                         this->WriteLine("ERROR :Invalid number of parameters for CAPAB");
777                         return false;
778                 }
779                 if (params[0] != this->MyCapabilities())
780                 {
781                         std::string quitserver = this->myhost;
782                         if (this->InboundServerName != "")
783                         {
784                                 quitserver = this->InboundServerName;
785                         }
786                         WriteOpers("*** \2ERROR\2: Server '%s' does not have the same set of modules loaded, cannot link!",quitserver.c_str());
787                         WriteOpers("*** Our networked module set is: '%s'",this->MyCapabilities().c_str());
788                         WriteOpers("*** Other server's networked module set is: '%s'",params[0].c_str());
789                         WriteOpers("*** These lists must match exactly on both servers. Please correct these errors, and try again.");
790                         this->WriteLine("ERROR :CAPAB mismatch; My capabilities: '"+this->MyCapabilities()+"'");
791                         return false;
792                 }
793                 return true;
794         }
795
796         /* This function forces this server to quit, removing this server
797          * and any users on it (and servers and users below that, etc etc).
798          * It's very slow and pretty clunky, but luckily unless your network
799          * is having a REAL bad hair day, this function shouldnt be called
800          * too many times a month ;-)
801          */
802         void SquitServer(TreeServer* Current, CullList* Goners)
803         {
804                 /* recursively squit the servers attached to 'Current'.
805                  * We're going backwards so we don't remove users
806                  * while we still need them ;)
807                  */
808                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
809                 {
810                         TreeServer* recursive_server = Current->GetChild(q);
811                         this->SquitServer(recursive_server,Goners);
812                 }
813                 /* Now we've whacked the kids, whack self */
814                 num_lost_servers++;
815                 for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
816                 {
817                         if (!strcasecmp(u->second->server,Current->GetName().c_str()))
818                         {
819                                 std::string qreason = Current->GetName()+" "+std::string(Srv->GetServerName());
820                                 Goners->AddItem(u->second,qreason);
821                                 num_lost_users++;
822                         }
823                 }
824         }
825
826         /* This is a wrapper function for SquitServer above, which
827          * does some validation first and passes on the SQUIT to all
828          * other remaining servers.
829          */
830         void Squit(TreeServer* Current,std::string reason)
831         {
832                 if ((Current) && (Current != TreeRoot))
833                 {
834                         std::deque<std::string> params;
835                         params.push_back(Current->GetName());
836                         params.push_back(":"+reason);
837                         DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
838                         if (Current->GetParent() == TreeRoot)
839                         {
840                                 Srv->SendOpers("Server \002"+Current->GetName()+"\002 split: "+reason);
841                         }
842                         else
843                         {
844                                 Srv->SendOpers("Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
845                         }
846                         num_lost_servers = 0;
847                         num_lost_users = 0;
848                         CullList* Goners = new CullList();
849                         SquitServer(Current, Goners);
850                         Goners->Apply();
851                         Current->Tidy();
852                         Current->GetParent()->DelChild(Current);
853                         delete Current;
854                         delete Goners;
855                         WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
856                 }
857                 else
858                 {
859                         log(DEFAULT,"Squit from unknown server");
860                 }
861         }
862
863         /* FMODE command */
864         bool ForceMode(std::string source, std::deque<std::string> params)
865         {
866                 userrec* who = new userrec;
867                 who->fd = FD_MAGIC_NUMBER;
868                 if (params.size() < 2)
869                         return true;
870                 char* modelist[255];
871                 for (unsigned int q = 0; q < params.size(); q++)
872                 {
873                         modelist[q] = (char*)params[q].c_str();
874                 }
875                 Srv->SendMode(modelist,params.size(),who);
876                 DoOneToAllButSender(source,"FMODE",params,source);
877                 delete who;
878                 return true;
879         }
880
881         /* FTOPIC command */
882         bool ForceTopic(std::string source, std::deque<std::string> params)
883         {
884                 if (params.size() != 4)
885                         return true;
886                 time_t ts = atoi(params[1].c_str());
887                 std::string nsource = source;
888
889                 chanrec* c = Srv->FindChannel(params[0]);
890                 if (c)
891                 {
892                         if ((ts >= c->topicset) || (!*c->topic))
893                         {
894                                 std::string oldtopic = c->topic;
895                                 strlcpy(c->topic,params[3].c_str(),MAXTOPIC);
896                                 strlcpy(c->setby,params[2].c_str(),NICKMAX);
897                                 c->topicset = ts;
898                                 /* if the topic text is the same as the current topic,
899                                  * dont bother to send the TOPIC command out, just silently
900                                  * update the set time and set nick.
901                                  */
902                                 if (oldtopic != params[3])
903                                 {
904                                         userrec* user = Srv->FindNick(source);
905                                         if (!user)
906                                         {
907                                                 WriteChannelWithServ((char*)source.c_str(), c, "TOPIC %s :%s", c->name, c->topic);
908                                         }
909                                         else
910                                         {
911                                                 WriteChannel(c, user, "TOPIC %s :%s", c->name, c->topic);
912                                                 nsource = user->server;
913                                         }
914                                 }
915                         }
916                         
917                 }
918                 
919                 /* all done, send it on its way */
920                 params[3] = ":" + params[3];
921                 DoOneToAllButSender(source,"FTOPIC",params,nsource);
922
923                 return true;
924         }
925
926         /* FJOIN, similar to unreal SJOIN */
927         bool ForceJoin(std::string source, std::deque<std::string> params)
928         {
929                 if (params.size() < 3)
930                         return true;
931
932                 char first[MAXBUF];
933                 char modestring[MAXBUF];
934                 char* mode_users[127];
935                 mode_users[0] = first;
936                 mode_users[1] = modestring;
937                 strcpy(mode_users[1],"+");
938                 unsigned int modectr = 2;
939                 
940                 userrec* who = NULL;
941                 std::string channel = params[0];
942                 time_t TS = atoi(params[1].c_str());
943                 char* key = "";
944                 
945                 chanrec* chan = Srv->FindChannel(channel);
946                 if (chan)
947                 {
948                         key = chan->key;
949                 }
950                 strlcpy(mode_users[0],channel.c_str(),MAXBUF);
951
952                 /* default is a high value, which if we dont have this
953                  * channel will let the other side apply their modes.
954                  */
955                 time_t ourTS = time(NULL)+600;
956                 chanrec* us = Srv->FindChannel(channel);
957                 if (us)
958                 {
959                         ourTS = us->age;
960                 }
961
962                 log(DEBUG,"FJOIN detected, our TS=%lu, their TS=%lu",ourTS,TS);
963
964                 /* do this first, so our mode reversals are correctly received by other servers
965                  * if there is a TS collision.
966                  */
967                 DoOneToAllButSender(source,"FJOIN",params,source);
968                 
969                 for (unsigned int usernum = 2; usernum < params.size(); usernum++)
970                 {
971                         /* process one channel at a time, applying modes. */
972                         char* usr = (char*)params[usernum].c_str();
973                         /* Safety check just to make sure someones not sent us an FJOIN full of spaces
974                          * (is this even possible?) */
975                         if (usr && *usr)
976                         {
977                                 char permissions = *usr;
978                                 switch (permissions)
979                                 {
980                                         case '@':
981                                                 usr++;
982                                                 mode_users[modectr++] = usr;
983                                                 strlcat(modestring,"o",MAXBUF);
984                                         break;
985                                         case '%':
986                                                 usr++;
987                                                 mode_users[modectr++] = usr;
988                                                 strlcat(modestring,"h",MAXBUF);
989                                         break;
990                                         case '+':
991                                                 usr++;
992                                                 mode_users[modectr++] = usr;
993                                                 strlcat(modestring,"v",MAXBUF);
994                                         break;
995                                 }
996                                 who = Srv->FindNick(usr);
997                                 if (who)
998                                 {
999                                         Srv->JoinUserToChannel(who,channel,key);
1000                                         if (modectr >= (MAXMODES-1))
1001                                         {
1002                                                 /* theres a mode for this user. push them onto the mode queue, and flush it
1003                                                  * if there are more than MAXMODES to go.
1004                                                  */
1005                                                 if ((ourTS >= TS) || (Srv->IsUlined(who->server)))
1006                                                 {
1007                                                         /* We also always let u-lined clients win, no matter what the TS value */
1008                                                         log(DEBUG,"Our our channel newer than theirs, accepting their modes");
1009                                                         Srv->SendMode(mode_users,modectr,who);
1010                                                 }
1011                                                 else
1012                                                 {
1013                                                         log(DEBUG,"Their channel newer than ours, bouncing their modes");
1014                                                         /* bouncy bouncy! */
1015                                                         std::deque<std::string> params;
1016                                                         /* modes are now being UNSET... */
1017                                                         *mode_users[1] = '-';
1018                                                         for (unsigned int x = 0; x < modectr; x++)
1019                                                         {
1020                                                                 params.push_back(mode_users[x]);
1021                                                         }
1022                                                         // tell everyone to bounce the modes. bad modes, bad!
1023                                                         DoOneToMany(Srv->GetServerName(),"FMODE",params);
1024                                                 }
1025                                                 strcpy(mode_users[1],"+");
1026                                                 modectr = 2;
1027                                         }
1028                                 }
1029                         }
1030                 }
1031                 /* there werent enough modes built up to flush it during FJOIN,
1032                  * or, there are a number left over. flush them out.
1033                  */
1034                 if ((modectr > 2) && (who))
1035                 {
1036                         if (ourTS >= TS)
1037                         {
1038                                 log(DEBUG,"Our our channel newer than theirs, accepting their modes");
1039                                 Srv->SendMode(mode_users,modectr,who);
1040                         }
1041                         else
1042                         {
1043                                 log(DEBUG,"Their channel newer than ours, bouncing their modes");
1044                                 std::deque<std::string> params;
1045                                 *mode_users[1] = '-';
1046                                 for (unsigned int x = 0; x < modectr; x++)
1047                                 {
1048                                         params.push_back(mode_users[x]);
1049                                 }
1050                                 DoOneToMany(Srv->GetServerName(),"FMODE",params);
1051                         }
1052                 }
1053                 return true;
1054         }
1055
1056         /* NICK command */
1057         bool IntroduceClient(std::string source, std::deque<std::string> params)
1058         {
1059                 if (params.size() < 8)
1060                         return true;
1061                 if (params.size() > 8)
1062                 {
1063                         this->WriteLine(":"+Srv->GetServerName()+" KILL "+params[1]+" :Invalid client introduction ("+params[1]+"?)");
1064                         return true;
1065                 }
1066                 // NICK age nick host dhost ident +modes ip :gecos
1067                 //       0   1    2    3      4     5    6   7
1068                 time_t age = atoi(params[0].c_str());
1069                 std::string modes = params[5];
1070                 while (*(modes.c_str()) == '+')
1071                 {
1072                         char* m = (char*)modes.c_str();
1073                         m++;
1074                         modes = m;
1075                 }
1076                 char* tempnick = (char*)params[1].c_str();
1077                 log(DEBUG,"Introduce client %s!%s@%s",tempnick,params[4].c_str(),params[2].c_str());
1078                 
1079                 user_hash::iterator iter;
1080                 iter = clientlist.find(tempnick);
1081                 if (iter != clientlist.end())
1082                 {
1083                         // nick collision
1084                         log(DEBUG,"Nick collision on %s!%s@%s: %lu %lu",tempnick,params[4].c_str(),params[2].c_str(),(unsigned long)age,(unsigned long)iter->second->age);
1085                         this->WriteLine(":"+Srv->GetServerName()+" KILL "+tempnick+" :Nickname collision");
1086                         return true;
1087                 }
1088
1089                 clientlist[tempnick] = new userrec();
1090                 clientlist[tempnick]->fd = FD_MAGIC_NUMBER;
1091                 strlcpy(clientlist[tempnick]->nick, tempnick,NICKMAX);
1092                 strlcpy(clientlist[tempnick]->host, params[2].c_str(),160);
1093                 strlcpy(clientlist[tempnick]->dhost, params[3].c_str(),160);
1094                 clientlist[tempnick]->server = (char*)FindServerNamePtr(source.c_str());
1095                 strlcpy(clientlist[tempnick]->ident, params[4].c_str(),IDENTMAX);
1096                 strlcpy(clientlist[tempnick]->fullname, params[7].c_str(),MAXGECOS);
1097                 clientlist[tempnick]->registered = 7;
1098                 clientlist[tempnick]->signon = age;
1099                 strlcpy(clientlist[tempnick]->modes, modes.c_str(),53);
1100                 inet_aton(params[6].c_str(),&clientlist[tempnick]->ip4);
1101
1102                 ucrec a;
1103                 a.channel = NULL;
1104                 a.uc_modes = 0;
1105                 for (int i = 0; i < MAXCHANS; i++)
1106                         clientlist[tempnick]->chans.push_back(a);
1107
1108                 if (!this->bursting)
1109                 {
1110                         WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",clientlist[tempnick]->server,clientlist[tempnick]->nick,clientlist[tempnick]->ident,clientlist[tempnick]->host,(char*)inet_ntoa(clientlist[tempnick]->ip4));
1111                 }
1112                 params[7] = ":" + params[7];
1113                 DoOneToAllButSender(source,"NICK",params,source);
1114
1115                 // Increment the Source Servers User Count..
1116                 TreeServer* SourceServer = FindServer(source);
1117                 if (SourceServer) {
1118                         SourceServer->AddUserCount();
1119                 }
1120
1121                 return true;
1122         }
1123
1124         /* Send one or more FJOINs for a channel of users.
1125          * If the length of a single line is more than 480-NICKMAX
1126          * in length, it is split over multiple lines.
1127          */
1128         void SendFJoins(TreeServer* Current, chanrec* c)
1129         {
1130                 log(DEBUG,"Sending FJOINs to other server for %s",c->name);
1131                 char list[MAXBUF];
1132                 snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
1133                 std::map<char*,char*> *ulist = c->GetUsers();
1134                 for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
1135                 {
1136                         char* o = i->second;
1137                         userrec* otheruser = (userrec*)o;
1138                         strlcat(list," ",MAXBUF);
1139                         strlcat(list,cmode(otheruser,c),MAXBUF);
1140                         strlcat(list,otheruser->nick,MAXBUF);
1141                         if (strlen(list)>(480-NICKMAX))
1142                         {
1143                                 log(DEBUG,"FJOIN line wrapped");
1144                                 this->WriteLine(list);
1145                                 snprintf(list,MAXBUF,":%s FJOIN %s %lu",Srv->GetServerName().c_str(),c->name,(unsigned long)c->age);
1146                         }
1147                 }
1148                 if (list[strlen(list)-1] != ':')
1149                 {
1150                         log(DEBUG,"Final FJOIN line");
1151                         this->WriteLine(list);
1152                 }
1153         }
1154
1155         /* Send G, Q, Z and E lines */
1156         void SendXLines(TreeServer* Current)
1157         {
1158                 char data[MAXBUF];
1159                 const char* sn = Srv->GetServerName().c_str();
1160                 /* Yes, these arent too nice looking, but they get the job done */
1161                 for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
1162                 {
1163                         snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1164                         this->WriteLine(data);
1165                 }
1166                 for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
1167                 {
1168                         snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1169                         this->WriteLine(data);
1170                 }
1171                 for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
1172                 {
1173                         snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1174                         this->WriteLine(data);
1175                 }
1176                 for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
1177                 {
1178                         snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1179                         this->WriteLine(data);
1180                 }
1181                 for (std::vector<ZLine>::iterator i = pzlines.begin(); i != pzlines.end(); i++)
1182                 {
1183                         snprintf(data,MAXBUF,":%s ADDLINE Z %s %s %lu %lu :%s",sn,i->ipaddr,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1184                         this->WriteLine(data);
1185                 }
1186                 for (std::vector<QLine>::iterator i = pqlines.begin(); i != pqlines.end(); i++)
1187                 {
1188                         snprintf(data,MAXBUF,":%s ADDLINE Q %s %s %lu %lu :%s",sn,i->nick,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1189                         this->WriteLine(data);
1190                 }
1191                 for (std::vector<GLine>::iterator i = pglines.begin(); i != pglines.end(); i++)
1192                 {
1193                         snprintf(data,MAXBUF,":%s ADDLINE G %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1194                         this->WriteLine(data);
1195                 }
1196                 for (std::vector<ELine>::iterator i = pelines.begin(); i != pelines.end(); i++)
1197                 {
1198                         snprintf(data,MAXBUF,":%s ADDLINE E %s %s %lu %lu :%s",sn,i->hostmask,i->source,(unsigned long)i->set_time,(unsigned long)i->duration,i->reason);
1199                         this->WriteLine(data);
1200                 }
1201         }
1202
1203         /* Send channel modes and topics */
1204         void SendChannelModes(TreeServer* Current)
1205         {
1206                 char data[MAXBUF];
1207                 std::deque<std::string> list;
1208                 const char* sn = Srv->GetServerName().c_str();
1209                 for (chan_hash::iterator c = chanlist.begin(); c != chanlist.end(); c++)
1210                 {
1211                         SendFJoins(Current, c->second);
1212                         snprintf(data,MAXBUF,":%s FMODE %s +%s",sn,c->second->name,chanmodes(c->second,true));
1213                         this->WriteLine(data);
1214                         if (*c->second->topic)
1215                         {
1216                                 snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s",sn,c->second->name,(unsigned long)c->second->topicset,c->second->setby,c->second->topic);
1217                                 this->WriteLine(data);
1218                         }
1219                         for (BanList::iterator b = c->second->bans.begin(); b != c->second->bans.end(); b++)
1220                         {
1221                                 snprintf(data,MAXBUF,":%s FMODE %s +b %s",sn,c->second->name,b->data);
1222                                 this->WriteLine(data);
1223                         }
1224                         FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
1225                         list.clear();
1226                         c->second->GetExtList(list);
1227                         for (unsigned int j = 0; j < list.size(); j++)
1228                         {
1229                                 FOREACH_MOD(I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
1230                         }
1231                 }
1232         }
1233
1234         /* send all users and their oper state/modes */
1235         void SendUsers(TreeServer* Current)
1236         {
1237                 char data[MAXBUF];
1238                 std::deque<std::string> list;
1239                 for (user_hash::iterator u = clientlist.begin(); u != clientlist.end(); u++)
1240                 {
1241                         if (u->second->registered == 7)
1242                         {
1243                                 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,(char*)inet_ntoa(u->second->ip4),u->second->fullname);
1244                                 this->WriteLine(data);
1245                                 if (*u->second->oper)
1246                                 {
1247                                         this->WriteLine(":"+std::string(u->second->nick)+" OPERTYPE "+std::string(u->second->oper));
1248                                 }
1249                                 if (*u->second->awaymsg)
1250                                 {
1251                                         this->WriteLine(":"+std::string(u->second->nick)+" AWAY :"+std::string(u->second->awaymsg));
1252                                 }
1253                                 FOREACH_MOD(I_OnSyncUser,OnSyncUser(u->second,(Module*)TreeProtocolModule,(void*)this));
1254                                 list.clear();
1255                                 u->second->GetExtList(list);
1256                                 for (unsigned int j = 0; j < list.size(); j++)
1257                                 {
1258                                         FOREACH_MOD(I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)TreeProtocolModule,(void*)this,list[j]));
1259                                 }
1260                         }
1261                 }
1262         }
1263
1264         /* This function is called when we want to send a netburst to a local
1265          * server. There is a set order we must do this, because for example
1266          * users require their servers to exist, and channels require their
1267          * users to exist. You get the idea.
1268          */
1269         void DoBurst(TreeServer* s)
1270         {
1271                 Srv->SendOpers("*** Bursting to \2"+s->GetName()+"\2.");
1272                 this->WriteLine("BURST");
1273                 /* send our version string */
1274                 this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
1275                 /* Send server tree */
1276                 this->SendServers(TreeRoot,s,1);
1277                 /* Send users and their oper status */
1278                 this->SendUsers(s);
1279                 /* Send everything else (channel modes, xlines etc) */
1280                 this->SendChannelModes(s);
1281                 this->SendXLines(s);
1282                 FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
1283                 this->WriteLine("ENDBURST");
1284                 Srv->SendOpers("*** Finished bursting to \2"+s->GetName()+"\2.");
1285         }
1286
1287         /* This function is called when we receive data from a remote
1288          * server. We buffer the data in a std::string (it doesnt stay
1289          * there for long), reading using InspSocket::Read() which can
1290          * read up to 16 kilobytes in one operation.
1291          *
1292          * IF THIS FUNCTION RETURNS FALSE, THE CORE CLOSES AND DELETES
1293          * THE SOCKET OBJECT FOR US.
1294          */
1295         virtual bool OnDataReady()
1296         {
1297                 char* data = this->Read();
1298                 /* Check that the data read is a valid pointer and it has some content */
1299                 if (data && *data)
1300                 {
1301                         this->in_buffer.append(data);
1302                         /* While there is at least one new line in the buffer,
1303                          * do something useful (we hope!) with it.
1304                          */
1305                         while (in_buffer.find("\n") != std::string::npos)
1306                         {
1307                                 std::string ret = in_buffer.substr(0,in_buffer.find("\n")-1);
1308                                 in_buffer = in_buffer.substr(in_buffer.find("\n")+1,in_buffer.length()-in_buffer.find("\n"));
1309                                 if (ret.find("\r") != std::string::npos)
1310                                         ret = in_buffer.substr(0,in_buffer.find("\r")-1);
1311                                 /* Process this one, abort if it
1312                                  * didnt return true.
1313                                  */
1314                                 if (this->ctx_in)
1315                                 {
1316                                         char out[1024];
1317                                         char result[1024];
1318                                         memset(result,0,1024);
1319                                         memset(out,0,1024);
1320                                         log(DEBUG,"Original string '%s'",ret.c_str());
1321                                         /* ERROR + CAPAB is still allowed unencryped */
1322                                         if ((ret.substr(0,7) != "ERROR :") && (ret.substr(0,6) != "CAPAB "))
1323                                         {
1324                                                 int nbytes = from64tobits(out, ret.c_str(), 1024);
1325                                                 if ((nbytes > 0) && (nbytes < 1024))
1326                                                 {
1327                                                         log(DEBUG,"m_spanningtree: decrypt %d bytes",nbytes);
1328                                                         ctx_in->Decrypt(out, result, nbytes, 1);
1329                                                         for (int t = 0; t < nbytes; t++)
1330                                                                 if (result[t] == '\7') result[t] = 0;
1331                                                         ret = result;
1332                                                 }
1333                                         }
1334                                 }
1335                                 if (!this->ProcessLine(ret))
1336                                 {
1337                                         return false;
1338                                 }
1339                         }
1340                 }
1341                 /* EAGAIN returns an empty but non-NULL string, so this
1342                  * evaluates to TRUE for EAGAIN but to FALSE for EOF.
1343                  */
1344                 return (data != NULL);
1345         }
1346
1347         int WriteLine(std::string line)
1348         {
1349                 log(DEBUG,"OUT: %s",line.c_str());
1350                 if (this->ctx_out)
1351                 {
1352                         log(DEBUG,"AES context");
1353                         char result[10240];
1354                         char result64[10240];
1355                         if (this->keylength)
1356                         {
1357                                 while (line.length() % this->keylength != 0)
1358                                 {
1359                                         // pad it to be a multiple of the key length
1360                                         line = line + "\7";
1361                                 }
1362                         }
1363                         unsigned int ll = line.length();
1364                         log(DEBUG,"Plaintext line with padding = %d chars",ll);
1365                         ctx_out->Encrypt(line.c_str(), result, ll, 1);
1366                         log(DEBUG,"Encrypted.");
1367                         to64frombits((unsigned char*)result64,(unsigned char*)result,ll);
1368                         line = result64;
1369                         log(DEBUG,"Encrypted: %s",line.c_str());
1370                         //int from64tobits(char *out, const char *in, int maxlen);
1371                 }
1372                 return this->Write(line + "\r\n");
1373         }
1374
1375         /* Handle ERROR command */
1376         bool Error(std::deque<std::string> params)
1377         {
1378                 if (params.size() < 1)
1379                         return false;
1380                 std::string Errmsg = params[0];
1381                 std::string SName = myhost;
1382                 if (InboundServerName != "")
1383                 {
1384                         SName = InboundServerName;
1385                 }
1386                 Srv->SendOpers("*** ERROR from "+SName+": "+Errmsg);
1387                 /* we will return false to cause the socket to close.
1388                  */
1389                 return false;
1390         }
1391
1392         /* Because the core won't let users or even SERVERS set +o,
1393          * we use the OPERTYPE command to do this.
1394          */
1395         bool OperType(std::string prefix, std::deque<std::string> &params)
1396         {
1397                 if (params.size() != 1)
1398                         return true;
1399                 std::string opertype = params[0];
1400                 userrec* u = Srv->FindNick(prefix);
1401                 if (u)
1402                 {
1403                         strlcpy(u->oper,opertype.c_str(),NICKMAX);
1404                         if (!strchr(u->modes,'o'))
1405                         {
1406                                 strcat(u->modes,"o");
1407                         }
1408                         DoOneToAllButSender(u->nick,"OPERTYPE",params,u->server);
1409                 }
1410                 return true;
1411         }
1412
1413         /* Because Andy insists that services-compatible servers must
1414          * implement SVSNICK and SVSJOIN, that's exactly what we do :p
1415          */
1416         bool ForceNick(std::string prefix, std::deque<std::string> &params)
1417         {
1418                 if (params.size() < 3)
1419                         return true;
1420                 userrec* u = Srv->FindNick(params[0]);
1421                 if (u)
1422                 {
1423                         DoOneToAllButSender(prefix,"SVSNICK",params,prefix);
1424                         if (IS_LOCAL(u))
1425                         {
1426                                 std::deque<std::string> par;
1427                                 par.push_back(params[1]);
1428                                 DoOneToMany(u->nick,"NICK",par);
1429                                 Srv->ChangeUserNick(u,params[1]);
1430                                 u->age = atoi(params[2].c_str());
1431                         }
1432                 }
1433                 return true;
1434         }
1435
1436         bool ServiceJoin(std::string prefix, std::deque<std::string> &params)
1437         {
1438                 if (params.size() < 2)
1439                         return true;
1440                 userrec* u = Srv->FindNick(params[0]);
1441                 if (u)
1442                 {
1443                         Srv->JoinUserToChannel(u,params[1],"");
1444                         DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
1445                 }
1446                 return true;
1447         }
1448
1449         bool RemoteRehash(std::string prefix, std::deque<std::string> &params)
1450         {
1451                 if (params.size() < 1)
1452                         return false;
1453                 std::string servermask = params[0];
1454                 if (Srv->MatchText(Srv->GetServerName(),servermask))
1455                 {
1456                         Srv->SendOpers("*** Remote rehash initiated from server \002"+prefix+"\002.");
1457                         Srv->RehashServer();
1458                         ReadConfiguration(false);
1459                 }
1460                 DoOneToAllButSender(prefix,"REHASH",params,prefix);
1461                 return true;
1462         }
1463
1464         bool RemoteKill(std::string prefix, std::deque<std::string> &params)
1465         {
1466                 if (params.size() != 2)
1467                         return true;
1468                 std::string nick = params[0];
1469                 userrec* u = Srv->FindNick(prefix);
1470                 userrec* who = Srv->FindNick(nick);
1471                 if (who)
1472                 {
1473                         /* Prepend kill source, if we don't have one */
1474                         std::string sourceserv = prefix;
1475                         if (u)
1476                         {
1477                                 sourceserv = u->server;
1478                         }
1479                         if (*(params[1].c_str()) != '[')
1480                         {
1481                                 params[1] = "[" + sourceserv + "] Killed (" + params[1] +")";
1482                         }
1483                         std::string reason = params[1];
1484                         params[1] = ":" + params[1];
1485                         DoOneToAllButSender(prefix,"KILL",params,sourceserv);
1486                         Srv->QuitUser(who,reason);
1487                 }
1488                 return true;
1489         }
1490
1491         bool LocalPong(std::string prefix, std::deque<std::string> &params)
1492         {
1493                 if (params.size() < 1)
1494                         return true;
1495                 TreeServer* ServerSource = FindServer(prefix);
1496                 if (ServerSource)
1497                 {
1498                         ServerSource->SetPingFlag();
1499                 }
1500                 return true;
1501         }
1502         
1503         bool MetaData(std::string prefix, std::deque<std::string> &params)
1504         {
1505                 if (params.size() < 3)
1506                         return true;
1507                 TreeServer* ServerSource = FindServer(prefix);
1508                 if (ServerSource)
1509                 {
1510                         if (params[0] == "*")
1511                         {
1512                                 FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2]));
1513                         }
1514                         else if (*(params[0].c_str()) == '#')
1515                         {
1516                                 chanrec* c = Srv->FindChannel(params[0]);
1517                                 if (c)
1518                                 {
1519                                         FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]));
1520                                 }
1521                         }
1522                         else if (*(params[0].c_str()) != '#')
1523                         {
1524                                 userrec* u = Srv->FindNick(params[0]);
1525                                 if (u)
1526                                 {
1527                                         FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2]));
1528                                 }
1529                         }
1530                 }
1531                 params[2] = ":" + params[2];
1532                 DoOneToAllButSender(prefix,"METADATA",params,prefix);
1533                 return true;
1534         }
1535
1536         bool ServerVersion(std::string prefix, std::deque<std::string> &params)
1537         {
1538                 if (params.size() < 1)
1539                         return true;
1540                 TreeServer* ServerSource = FindServer(prefix);
1541                 if (ServerSource)
1542                 {
1543                         ServerSource->SetVersion(params[0]);
1544                 }
1545                 params[0] = ":" + params[0];
1546                 DoOneToAllButSender(prefix,"VERSION",params,prefix);
1547                 return true;
1548         }
1549
1550         bool ChangeHost(std::string prefix, std::deque<std::string> &params)
1551         {
1552                 if (params.size() < 1)
1553                         return true;
1554                 userrec* u = Srv->FindNick(prefix);
1555                 if (u)
1556                 {
1557                         Srv->ChangeHost(u,params[0]);
1558                         DoOneToAllButSender(prefix,"FHOST",params,u->server);
1559                 }
1560                 return true;
1561         }
1562
1563         bool AddLine(std::string prefix, std::deque<std::string> &params)
1564         {
1565                 if (params.size() < 6)
1566                         return true;
1567
1568                 bool propogate = false;
1569
1570                 switch (*(params[0].c_str()))
1571                 {
1572                         case 'Z':
1573                                 propogate = add_zline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
1574                                 zline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
1575                         break;
1576                         case 'Q':
1577                                 propogate = add_qline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
1578                                 qline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
1579                         break;
1580                         case 'E':
1581                                 propogate = add_eline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
1582                                 eline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
1583                         break;
1584                         case 'G':
1585                                 propogate = add_gline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
1586                                 gline_set_creation_time((char*)params[1].c_str(), atoi(params[3].c_str()));
1587                         break;
1588                         case 'K':
1589                                 propogate = add_kline(atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
1590                         break;
1591                         default:
1592                                 /* Just in case... */
1593                                 Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!");
1594                                 propogate = false;
1595                         break;
1596                 }
1597                 /* Send it on its way */
1598                 if (propogate)
1599                 {
1600                         params[5] = ":" + params[5];
1601                         DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
1602                 }
1603                 return true;
1604         }
1605
1606         bool ChangeName(std::string prefix, std::deque<std::string> &params)
1607         {
1608                 if (params.size() < 1)
1609                         return true;
1610                 userrec* u = Srv->FindNick(prefix);
1611                 if (u)
1612                 {
1613                         Srv->ChangeGECOS(u,params[0]);
1614                         params[0] = ":" + params[0];
1615                         DoOneToAllButSender(prefix,"FNAME",params,u->server);
1616                 }
1617                 return true;
1618         }
1619
1620         bool Whois(std::string prefix, std::deque<std::string> &params)
1621         {
1622                 if (params.size() < 1)
1623                         return true;
1624                 log(DEBUG,"In IDLE command");
1625                 userrec* u = Srv->FindNick(prefix);
1626                 if (u)
1627                 {
1628                         log(DEBUG,"USER EXISTS: %s",u->nick);
1629                         // an incoming request
1630                         if (params.size() == 1)
1631                         {
1632                                 userrec* x = Srv->FindNick(params[0]);
1633                                 if ((x) && (x->fd > -1))
1634                                 {
1635                                         userrec* x = Srv->FindNick(params[0]);
1636                                         log(DEBUG,"Got IDLE");
1637                                         char signon[MAXBUF];
1638                                         char idle[MAXBUF];
1639                                         log(DEBUG,"Sending back IDLE 3");
1640                                         snprintf(signon,MAXBUF,"%lu",(unsigned long)x->signon);
1641                                         snprintf(idle,MAXBUF,"%lu",(unsigned long)abs((x->idle_lastmsg)-time(NULL)));
1642                                         std::deque<std::string> par;
1643                                         par.push_back(prefix);
1644                                         par.push_back(signon);
1645                                         par.push_back(idle);
1646                                         // ours, we're done, pass it BACK
1647                                         DoOneToOne(params[0],"IDLE",par,u->server);
1648                                 }
1649                                 else
1650                                 {
1651                                         // not ours pass it on
1652                                         DoOneToOne(prefix,"IDLE",params,x->server);
1653                                 }
1654                         }
1655                         else if (params.size() == 3)
1656                         {
1657                                 std::string who_did_the_whois = params[0];
1658                                 userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
1659                                 if ((who_to_send_to) && (who_to_send_to->fd > -1))
1660                                 {
1661                                         log(DEBUG,"Got final IDLE");
1662                                         // an incoming reply to a whois we sent out
1663                                         std::string nick_whoised = prefix;
1664                                         unsigned long signon = atoi(params[1].c_str());
1665                                         unsigned long idle = atoi(params[2].c_str());
1666                                         if ((who_to_send_to) && (who_to_send_to->fd > -1))
1667                                                 do_whois(who_to_send_to,u,signon,idle,(char*)nick_whoised.c_str());
1668                                 }
1669                                 else
1670                                 {
1671                                         // not ours, pass it on
1672                                         DoOneToOne(prefix,"IDLE",params,who_to_send_to->server);
1673                                 }
1674                         }
1675                 }
1676                 return true;
1677         }
1678
1679         bool Push(std::string prefix, std::deque<std::string> &params)
1680         {
1681                 if (params.size() < 2)
1682                         return true;
1683                 userrec* u = Srv->FindNick(params[0]);
1684                 if (IS_LOCAL(u))
1685                 {
1686                         // push the raw to the user
1687                         if (Srv->IsUlined(prefix))
1688                         {
1689                                 ::Write(u->fd,"%s",params[1].c_str());
1690                         }
1691                         else
1692                         {
1693                                 log(DEBUG,"PUSH from non-ulined server dropped into the bit-bucket:  :%s PUSH %s :%s",prefix.c_str(),params[0].c_str(),params[1].c_str());
1694                         }
1695                 }
1696                 else
1697                 {
1698                         // continue the raw onwards
1699                         params[1] = ":" + params[1];
1700                         DoOneToOne(prefix,"PUSH",params,u->server);
1701                 }
1702                 return true;
1703         }
1704
1705         bool Time(std::string prefix, std::deque<std::string> &params)
1706         {
1707                 // :source.server TIME remote.server sendernick
1708                 // :remote.server TIME source.server sendernick TS
1709                 if (params.size() == 2)
1710                 {
1711                         // someone querying our time?
1712                         if (Srv->GetServerName() == params[0])
1713                         {
1714                                 userrec* u = Srv->FindNick(params[1]);
1715                                 if (u)
1716                                 {
1717                                         char curtime[256];
1718                                         snprintf(curtime,256,"%lu",(unsigned long)time(NULL));
1719                                         params.push_back(curtime);
1720                                         params[0] = prefix;
1721                                         DoOneToOne(Srv->GetServerName(),"TIME",params,params[0]);
1722                                 }
1723                         }
1724                         else
1725                         {
1726                                 // not us, pass it on
1727                                 userrec* u = Srv->FindNick(params[1]);
1728                                 if (u)
1729                                         DoOneToOne(prefix,"TIME",params,params[0]);
1730                         }
1731                 }
1732                 else if (params.size() == 3)
1733                 {
1734                         // a response to a previous TIME
1735                         userrec* u = Srv->FindNick(params[1]);
1736                         if ((u) && (IS_LOCAL(u)))
1737                         {
1738                                 time_t rawtime = atol(params[2].c_str());
1739                                 struct tm * timeinfo;
1740                                 timeinfo = localtime(&rawtime);
1741                                 char tms[26];
1742                                 snprintf(tms,26,"%s",asctime(timeinfo));
1743                                 tms[24] = 0;
1744                                 WriteServ(u->fd,"391 %s %s :%s",u->nick,prefix.c_str(),tms);
1745                         }
1746                         else
1747                         {
1748                                 if (u)
1749                                         DoOneToOne(prefix,"TIME",params,u->server);
1750                         }
1751                 }
1752                 return true;
1753         }
1754         
1755         bool LocalPing(std::string prefix, std::deque<std::string> &params)
1756         {
1757                 if (params.size() < 1)
1758                         return true;
1759                 std::string stufftobounce = params[0];
1760                 this->WriteLine(":"+Srv->GetServerName()+" PONG "+stufftobounce);
1761                 return true;
1762         }
1763
1764         bool RemoteServer(std::string prefix, std::deque<std::string> &params)
1765         {
1766                 if (params.size() < 4)
1767                         return false;
1768                 std::string servername = params[0];
1769                 std::string password = params[1];
1770                 // hopcount is not used for a remote server, we calculate this ourselves
1771                 std::string description = params[3];
1772                 TreeServer* ParentOfThis = FindServer(prefix);
1773                 if (!ParentOfThis)
1774                 {
1775                         this->WriteLine("ERROR :Protocol error - Introduced remote server from unknown server "+prefix);
1776                         return false;
1777                 }
1778                 TreeServer* CheckDupe = FindServer(servername);
1779                 if (CheckDupe)
1780                 {
1781                         this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
1782                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
1783                         return false;
1784                 }
1785                 TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
1786                 ParentOfThis->AddChild(Node);
1787                 params[3] = ":" + params[3];
1788                 DoOneToAllButSender(prefix,"SERVER",params,prefix);
1789                 Srv->SendOpers("*** Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
1790                 return true;
1791         }
1792
1793         bool Outbound_Reply_Server(std::deque<std::string> &params)
1794         {
1795                 if (params.size() < 4)
1796                         return false;
1797                 std::string servername = params[0];
1798                 std::string password = params[1];
1799                 int hops = atoi(params[2].c_str());
1800                 if (hops)
1801                 {
1802                         this->WriteLine("ERROR :Server too far away for authentication");
1803                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
1804                         return false;
1805                 }
1806                 std::string description = params[3];
1807                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
1808                 {
1809                         if ((x->Name == servername) && (x->RecvPass == password))
1810                         {
1811                                 TreeServer* CheckDupe = FindServer(servername);
1812                                 if (CheckDupe)
1813                                 {
1814                                         this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
1815                                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
1816                                         return false;
1817                                 }
1818                                 // Begin the sync here. this kickstarts the
1819                                 // other side, waiting in WAIT_AUTH_2 state,
1820                                 // into starting their burst, as it shows
1821                                 // that we're happy.
1822                                 this->LinkState = CONNECTED;
1823                                 // we should add the details of this server now
1824                                 // to the servers tree, as a child of the root
1825                                 // node.
1826                                 TreeServer* Node = new TreeServer(servername,description,TreeRoot,this);
1827                                 TreeRoot->AddChild(Node);
1828                                 params[3] = ":" + params[3];
1829                                 DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,servername);
1830                                 this->bursting = true;
1831                                 this->DoBurst(Node);
1832                                 return true;
1833                         }
1834                 }
1835                 this->WriteLine("ERROR :Invalid credentials");
1836                 Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
1837                 return false;
1838         }
1839
1840         bool Inbound_Server(std::deque<std::string> &params)
1841         {
1842                 if (params.size() < 4)
1843                         return false;
1844                 std::string servername = params[0];
1845                 std::string password = params[1];
1846                 int hops = atoi(params[2].c_str());
1847                 if (hops)
1848                 {
1849                         this->WriteLine("ERROR :Server too far away for authentication");
1850                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, server is too far away for authentication");
1851                         return false;
1852                 }
1853                 std::string description = params[3];
1854                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
1855                 {
1856                         if ((x->Name == servername) && (x->RecvPass == password))
1857                         {
1858                                 TreeServer* CheckDupe = FindServer(servername);
1859                                 if (CheckDupe)
1860                                 {
1861                                         this->WriteLine("ERROR :Server "+servername+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
1862                                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
1863                                         return false;
1864                                 }
1865                                 /* If the config says this link is encrypted, but the remote side
1866                                  * hasnt bothered to send the AES command before SERVER, then we
1867                                  * boot them off as we MUST have this connection encrypted.
1868                                  */
1869                                 if ((x->EncryptionKey != "") && (!this->ctx_in))
1870                                 {
1871                                         this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused.");
1872                                         Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, remote server did not enable AES.");
1873                                         return false;
1874                                 }
1875                                 Srv->SendOpers("*** Verified incoming server connection from \002"+servername+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
1876                                 this->InboundServerName = servername;
1877                                 this->InboundDescription = description;
1878                                 // this is good. Send our details: Our server name and description and hopcount of 0,
1879                                 // along with the sendpass from this block.
1880                                 this->WriteLine("SERVER "+Srv->GetServerName()+" "+x->SendPass+" 0 :"+Srv->GetServerDescription());
1881                                 // move to the next state, we are now waiting for THEM.
1882                                 this->LinkState = WAIT_AUTH_2;
1883                                 return true;
1884                         }
1885                 }
1886                 this->WriteLine("ERROR :Invalid credentials");
1887                 Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, invalid link credentials");
1888                 return false;
1889         }
1890
1891         void Split(std::string line, bool stripcolon, std::deque<std::string> &n)
1892         {
1893                 if (!strchr(line.c_str(),' '))
1894                 {
1895                         n.push_back(line);
1896                         return;
1897                 }
1898                 std::stringstream s(line);
1899                 std::string param = "";
1900                 n.clear();
1901                 int item = 0;
1902                 while (!s.eof())
1903                 {
1904                         char c;
1905                         s.get(c);
1906                         if (c == ' ')
1907                         {
1908                                 n.push_back(param);
1909                                 param = "";
1910                                 item++;
1911                         }
1912                         else
1913                         {
1914                                 if (!s.eof())
1915                                 {
1916                                         param = param + c;
1917                                 }
1918                                 if ((param == ":") && (item > 0))
1919                                 {
1920                                         param = "";
1921                                         while (!s.eof())
1922                                         {
1923                                                 s.get(c);
1924                                                 if (!s.eof())
1925                                                 {
1926                                                         param = param + c;
1927                                                 }
1928                                         }
1929                                         n.push_back(param);
1930                                         param = "";
1931                                 }
1932                         }
1933                 }
1934                 if (param != "")
1935                 {
1936                         n.push_back(param);
1937                 }
1938                 return;
1939         }
1940
1941         bool ProcessLine(std::string line)
1942         {
1943                 char* l = (char*)line.c_str();
1944                 while ((strlen(l)) && (l[strlen(l)-1] == '\r') || (l[strlen(l)-1] == '\n'))
1945                         l[strlen(l)-1] = '\0';
1946                 line = l;
1947                 if (line == "")
1948                         return true;
1949                 Srv->Log(DEBUG,"IN: "+line);
1950                 
1951                 std::deque<std::string> params;
1952                 this->Split(line,true,params);
1953                 std::string command = "";
1954                 std::string prefix = "";
1955                 if (((params[0].c_str())[0] == ':') && (params.size() > 1))
1956                 {
1957                         prefix = params[0];
1958                         command = params[1];
1959                         char* pref = (char*)prefix.c_str();
1960                         prefix = ++pref;
1961                         params.pop_front();
1962                         params.pop_front();
1963                 }
1964                 else
1965                 {
1966                         prefix = "";
1967                         command = params[0];
1968                         params.pop_front();
1969                 }
1970
1971                 if ((!this->ctx_in) && (command == "AES"))
1972                 {
1973                         std::string sserv = params[0];
1974                         for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
1975                         {
1976                                 if ((x->EncryptionKey != "") && (x->Name == sserv))
1977                                 {
1978                                         this->InitAES(x->EncryptionKey,sserv);
1979                                 }
1980                         }
1981                         return true;
1982                 }
1983                 else if ((this->ctx_in) && (command == "AES"))
1984                 {
1985                         WriteOpers("*** \2AES\2: Encryption already enabled on this connection yet %s is trying to enable it twice!",params[0].c_str());
1986                 }
1987
1988                 switch (this->LinkState)
1989                 {
1990                         TreeServer* Node;
1991                         
1992                         case WAIT_AUTH_1:
1993                                 // Waiting for SERVER command from remote server. Server initiating
1994                                 // the connection sends the first SERVER command, listening server
1995                                 // replies with theirs if its happy, then if the initiator is happy,
1996                                 // it starts to send its net sync, which starts the merge, otherwise
1997                                 // it sends an ERROR.
1998                                 if (command == "PASS")
1999                                 {
2000                                         /* Silently ignored */
2001                                 }
2002                                 else if (command == "SERVER")
2003                                 {
2004                                         return this->Inbound_Server(params);
2005                                 }
2006                                 else if (command == "ERROR")
2007                                 {
2008                                         return this->Error(params);
2009                                 }
2010                                 else if (command == "USER")
2011                                 {
2012                                         this->WriteLine("ERROR :Client connections to this port are prohibited.");
2013                                         return false;
2014                                 }
2015                                 else if (command == "CAPAB")
2016                                 {
2017                                         return this->Capab(params);
2018                                 }
2019                                 else if ((command == "U") || (command == "S"))
2020                                 {
2021                                         this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
2022                                         return false;
2023                                 }
2024                                 else
2025                                 {
2026                                         this->WriteLine("ERROR :Invalid command in negotiation phase.");
2027                                         return false;
2028                                 }
2029                         break;
2030                         case WAIT_AUTH_2:
2031                                 // Waiting for start of other side's netmerge to say they liked our
2032                                 // password.
2033                                 if (command == "SERVER")
2034                                 {
2035                                         // cant do this, they sent it to us in the WAIT_AUTH_1 state!
2036                                         // silently ignore.
2037                                         return true;
2038                                 }
2039                                 else if ((command == "U") || (command == "S"))
2040                                 {
2041                                         this->WriteLine("ERROR :Cannot use the old-style mesh linking protocol with m_spanningtree.so!");
2042                                         return false;
2043                                 }
2044                                 else if (command == "BURST")
2045                                 {
2046                                         this->LinkState = CONNECTED;
2047                                         Node = new TreeServer(InboundServerName,InboundDescription,TreeRoot,this);
2048                                         TreeRoot->AddChild(Node);
2049                                         params.clear();
2050                                         params.push_back(InboundServerName);
2051                                         params.push_back("*");
2052                                         params.push_back("1");
2053                                         params.push_back(":"+InboundDescription);
2054                                         DoOneToAllButSender(TreeRoot->GetName(),"SERVER",params,InboundServerName);
2055                                         this->bursting = true;
2056                                         this->DoBurst(Node);
2057                                 }
2058                                 else if (command == "ERROR")
2059                                 {
2060                                         return this->Error(params);
2061                                 }
2062                                 else if (command == "CAPAB")
2063                                 {
2064                                         return this->Capab(params);
2065                                 }
2066                                 
2067                         break;
2068                         case LISTENER:
2069                                 this->WriteLine("ERROR :Internal error -- listening socket accepted its own descriptor!!!");
2070                                 return false;
2071                         break;
2072                         case CONNECTING:
2073                                 if (command == "SERVER")
2074                                 {
2075                                         // another server we connected to, which was in WAIT_AUTH_1 state,
2076                                         // has just sent us their credentials. If we get this far, theyre
2077                                         // happy with OUR credentials, and they are now in WAIT_AUTH_2 state.
2078                                         // if we're happy with this, we should send our netburst which
2079                                         // kickstarts the merge.
2080                                         return this->Outbound_Reply_Server(params);
2081                                 }
2082                                 else if (command == "ERROR")
2083                                 {
2084                                         return this->Error(params);
2085                                 }
2086                         break;
2087                         case CONNECTED:
2088                                 // This is the 'authenticated' state, when all passwords
2089                                 // have been exchanged and anything past this point is taken
2090                                 // as gospel.
2091                                 
2092                                 if (prefix != "")
2093                                 {
2094                                         std::string direction = prefix;
2095                                         userrec* t = Srv->FindNick(prefix);
2096                                         if (t)
2097                                         {
2098                                                 direction = t->server;
2099                                         }
2100                                         TreeServer* route_back_again = BestRouteTo(direction);
2101                                         if ((!route_back_again) || (route_back_again->GetSocket() != this))
2102                                         {
2103                                                 if (route_back_again)
2104                                                         log(DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
2105                                                 return true;
2106                                         }
2107
2108                                         /* Fix by brain:
2109                                          * When there is activity on the socket, reset the ping counter so
2110                                          * that we're not wasting bandwidth pinging an active server.
2111                                          */                     
2112                                         route_back_again->SetNextPingTime(time(NULL) + 120);
2113                                         route_back_again->SetPingFlag();
2114                                 }
2115                                 
2116                                 if (command == "SVSMODE")
2117                                 {
2118                                         /* Services expects us to implement
2119                                          * SVSMODE. In inspircd its the same as
2120                                          * MODE anyway.
2121                                          */
2122                                         command = "MODE";
2123                                 }
2124                                 std::string target = "";
2125                                 /* Yes, know, this is a mess. Its reasonably fast though as we're
2126                                  * working with std::string here.
2127                                  */
2128                                 if ((command == "NICK") && (params.size() > 1))
2129                                 {
2130                                         return this->IntroduceClient(prefix,params);
2131                                 }
2132                                 else if (command == "FJOIN")
2133                                 {
2134                                         return this->ForceJoin(prefix,params);
2135                                 }
2136                                 else if (command == "SERVER")
2137                                 {
2138                                         return this->RemoteServer(prefix,params);
2139                                 }
2140                                 else if (command == "ERROR")
2141                                 {
2142                                         return this->Error(params);
2143                                 }
2144                                 else if (command == "OPERTYPE")
2145                                 {
2146                                         return this->OperType(prefix,params);
2147                                 }
2148                                 else if (command == "FMODE")
2149                                 {
2150                                         return this->ForceMode(prefix,params);
2151                                 }
2152                                 else if (command == "KILL")
2153                                 {
2154                                         return this->RemoteKill(prefix,params);
2155                                 }
2156                                 else if (command == "FTOPIC")
2157                                 {
2158                                         return this->ForceTopic(prefix,params);
2159                                 }
2160                                 else if (command == "REHASH")
2161                                 {
2162                                         return this->RemoteRehash(prefix,params);
2163                                 }
2164                                 else if (command == "METADATA")
2165                                 {
2166                                         return this->MetaData(prefix,params);
2167                                 }
2168                                 else if (command == "PING")
2169                                 {
2170                                         return this->LocalPing(prefix,params);
2171                                 }
2172                                 else if (command == "PONG")
2173                                 {
2174                                         return this->LocalPong(prefix,params);
2175                                 }
2176                                 else if (command == "VERSION")
2177                                 {
2178                                         return this->ServerVersion(prefix,params);
2179                                 }
2180                                 else if (command == "FHOST")
2181                                 {
2182                                         return this->ChangeHost(prefix,params);
2183                                 }
2184                                 else if (command == "FNAME")
2185                                 {
2186                                         return this->ChangeName(prefix,params);
2187                                 }
2188                                 else if (command == "ADDLINE")
2189                                 {
2190                                         return this->AddLine(prefix,params);
2191                                 }
2192                                 else if (command == "SVSNICK")
2193                                 {
2194                                         if (prefix == "")
2195                                         {
2196                                                 prefix = this->GetName();
2197                                         }
2198                                         return this->ForceNick(prefix,params);
2199                                 }
2200                                 else if (command == "IDLE")
2201                                 {
2202                                         return this->Whois(prefix,params);
2203                                 }
2204                                 else if (command == "PUSH")
2205                                 {
2206                                         return this->Push(prefix,params);
2207                                 }
2208                                 else if (command == "TIME")
2209                                 {
2210                                         return this->Time(prefix,params);
2211                                 }
2212                                 else if (command == "SVSJOIN")
2213                                 {
2214                                         if (prefix == "")
2215                                         {
2216                                                 prefix = this->GetName();
2217                                         }
2218                                         return this->ServiceJoin(prefix,params);
2219                                 }
2220                                 else if (command == "SQUIT")
2221                                 {
2222                                         if (params.size() == 2)
2223                                         {
2224                                                 this->Squit(FindServer(params[0]),params[1]);
2225                                         }
2226                                         return true;
2227                                 }
2228                                 else if (command == "ENDBURST")
2229                                 {
2230                                         this->bursting = false;
2231                                         return true;
2232                                 }
2233                                 else
2234                                 {
2235                                         // not a special inter-server command.
2236                                         // Emulate the actual user doing the command,
2237                                         // this saves us having a huge ugly parser.
2238                                         userrec* who = Srv->FindNick(prefix);
2239                                         std::string sourceserv = this->myhost;
2240                                         if (this->InboundServerName != "")
2241                                         {
2242                                                 sourceserv = this->InboundServerName;
2243                                         }
2244                                         if (who)
2245                                         {
2246                                                 if ((command == "NICK") && (params.size() > 0))
2247                                                 {
2248                                                         /* On nick messages, check that the nick doesnt
2249                                                          * already exist here. If it does, kill their copy,
2250                                                          * and our copy.
2251                                                          */
2252                                                         userrec* x = Srv->FindNick(params[0]);
2253                                                         if (x)
2254                                                         {
2255                                                                 std::deque<std::string> p;
2256                                                                 p.push_back(params[0]);
2257                                                                 p.push_back("Nickname collision ("+prefix+" -> "+params[0]+")");
2258                                                                 DoOneToMany(Srv->GetServerName(),"KILL",p);
2259                                                                 p.clear();
2260                                                                 p.push_back(prefix);
2261                                                                 p.push_back("Nickname collision");
2262                                                                 DoOneToMany(Srv->GetServerName(),"KILL",p);
2263                                                                 Srv->QuitUser(x,"Nickname collision ("+prefix+" -> "+params[0]+")");
2264                                                                 userrec* y = Srv->FindNick(prefix);
2265                                                                 if (y)
2266                                                                 {
2267                                                                         Srv->QuitUser(y,"Nickname collision");
2268                                                                 }
2269                                                                 return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
2270                                                         }
2271                                                 }
2272                                                 // its a user
2273                                                 target = who->server;
2274                                                 char* strparams[127];
2275                                                 for (unsigned int q = 0; q < params.size(); q++)
2276                                                 {
2277                                                         strparams[q] = (char*)params[q].c_str();
2278                                                 }
2279                                                 Srv->CallCommandHandler(command, strparams, params.size(), who);
2280                                         }
2281                                         else
2282                                         {
2283                                                 // its not a user. Its either a server, or somethings screwed up.
2284                                                 if (IsServer(prefix))
2285                                                 {
2286                                                         target = Srv->GetServerName();
2287                                                 }
2288                                                 else
2289                                                 {
2290                                                         log(DEBUG,"Command with unknown origin '%s'",prefix.c_str());
2291                                                         return true;
2292                                                 }
2293                                         }
2294                                         return DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
2295
2296                                 }
2297                                 return true;
2298                         break;
2299                 }
2300                 return true;
2301         }
2302
2303         virtual std::string GetName()
2304         {
2305                 std::string sourceserv = this->myhost;
2306                 if (this->InboundServerName != "")
2307                 {
2308                         sourceserv = this->InboundServerName;
2309                 }
2310                 return sourceserv;
2311         }
2312
2313         virtual void OnTimeout()
2314         {
2315                 if (this->LinkState == CONNECTING)
2316                 {
2317                         Srv->SendOpers("*** CONNECT: Connection to \002"+myhost+"\002 timed out.");
2318                 }
2319         }
2320
2321         virtual void OnClose()
2322         {
2323                 // Connection closed.
2324                 // If the connection is fully up (state CONNECTED)
2325                 // then propogate a netsplit to all peers.
2326                 std::string quitserver = this->myhost;
2327                 if (this->InboundServerName != "")
2328                 {
2329                         quitserver = this->InboundServerName;
2330                 }
2331                 TreeServer* s = FindServer(quitserver);
2332                 if (s)
2333                 {
2334                         Squit(s,"Remote host closed the connection");
2335                 }
2336                 WriteOpers("Server '\2%s\2' closed the connection.",quitserver.c_str());
2337         }
2338
2339         virtual int OnIncomingConnection(int newsock, char* ip)
2340         {
2341                 TreeSocket* s = new TreeSocket(newsock, ip);
2342                 Srv->AddSocket(s);
2343                 return true;
2344         }
2345 };
2346
2347 void AddThisServer(TreeServer* server, std::deque<TreeServer*> &list)
2348 {
2349         for (unsigned int c = 0; c < list.size(); c++)
2350         {
2351                 if (list[c] == server)
2352                 {
2353                         return;
2354                 }
2355         }
2356         list.push_back(server);
2357 }
2358
2359 // returns a list of DIRECT servernames for a specific channel
2360 void GetListOfServersForChannel(chanrec* c, std::deque<TreeServer*> &list)
2361 {
2362         std::map<char*,char*> *ulist = c->GetUsers();
2363         for (std::map<char*,char*>::iterator i = ulist->begin(); i != ulist->end(); i++)
2364         {
2365                 char* o = i->second;
2366                 userrec* otheruser = (userrec*)o;
2367                 if (otheruser->fd < 0)
2368                 {
2369                         TreeServer* best = BestRouteTo(otheruser->server);
2370                         if (best)
2371                                 AddThisServer(best,list);
2372                 }
2373         }
2374         return;
2375 }
2376
2377 bool DoOneToAllButSenderRaw(std::string data, std::string omit, std::string prefix, std::string command, std::deque<std::string> &params)
2378 {
2379         TreeServer* omitroute = BestRouteTo(omit);
2380         if ((command == "NOTICE") || (command == "PRIVMSG"))
2381         {
2382                 if ((params.size() >= 2) && (*(params[0].c_str()) != '$'))
2383                 {
2384                         /* Prefixes */
2385                         if ((*(params[0].c_str()) == '@') || (*(params[0].c_str()) == '%') || (*(params[0].c_str()) == '+'))
2386                         {
2387                                 params[0] = params[0].substr(1, params[0].length()-1);
2388                         }
2389                         if (*(params[0].c_str()) != '#')
2390                         {
2391                                 // special routing for private messages/notices
2392                                 userrec* d = Srv->FindNick(params[0]);
2393                                 if (d)
2394                                 {
2395                                         std::deque<std::string> par;
2396                                         par.push_back(params[0]);
2397                                         par.push_back(":"+params[1]);
2398                                         DoOneToOne(prefix,command,par,d->server);
2399                                         return true;
2400                                 }
2401                         }
2402                         else
2403                         {
2404                                 log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str());
2405                                 chanrec* c = Srv->FindChannel(params[0]);
2406                                 if (c)
2407                                 {
2408                                         std::deque<TreeServer*> list;
2409                                         GetListOfServersForChannel(c,list);
2410                                         log(DEBUG,"Got a list of %d servers",list.size());
2411                                         unsigned int lsize = list.size();
2412                                         for (unsigned int i = 0; i < lsize; i++)
2413                                         {
2414                                                 TreeSocket* Sock = list[i]->GetSocket();
2415                                                 if ((Sock) && (list[i]->GetName() != omit) && (omitroute != list[i]))
2416                                                 {
2417                                                         log(DEBUG,"Writing privmsg to server %s",list[i]->GetName().c_str());
2418                                                         Sock->WriteLine(data);
2419                                                 }
2420                                         }
2421                                         return true;
2422                                 }
2423                         }
2424                 }
2425         }
2426         unsigned int items = TreeRoot->ChildCount();
2427         for (unsigned int x = 0; x < items; x++)
2428         {
2429                 TreeServer* Route = TreeRoot->GetChild(x);
2430                 if ((Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
2431                 {
2432                         TreeSocket* Sock = Route->GetSocket();
2433                         Sock->WriteLine(data);
2434                 }
2435         }
2436         return true;
2437 }
2438
2439 bool DoOneToAllButSender(std::string prefix, std::string command, std::deque<std::string> &params, std::string omit)
2440 {
2441         TreeServer* omitroute = BestRouteTo(omit);
2442         std::string FullLine = ":" + prefix + " " + command;
2443         unsigned int words = params.size();
2444         for (unsigned int x = 0; x < words; x++)
2445         {
2446                 FullLine = FullLine + " " + params[x];
2447         }
2448         unsigned int items = TreeRoot->ChildCount();
2449         for (unsigned int x = 0; x < items; x++)
2450         {
2451                 TreeServer* Route = TreeRoot->GetChild(x);
2452                 // Send the line IF:
2453                 // The route has a socket (its a direct connection)
2454                 // The route isnt the one to be omitted
2455                 // The route isnt the path to the one to be omitted
2456                 if ((Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
2457                 {
2458                         TreeSocket* Sock = Route->GetSocket();
2459                         Sock->WriteLine(FullLine);
2460                 }
2461         }
2462         return true;
2463 }
2464
2465 bool DoOneToMany(std::string prefix, std::string command, std::deque<std::string> &params)
2466 {
2467         std::string FullLine = ":" + prefix + " " + command;
2468         unsigned int words = params.size();
2469         for (unsigned int x = 0; x < words; x++)
2470         {
2471                 FullLine = FullLine + " " + params[x];
2472         }
2473         unsigned int items = TreeRoot->ChildCount();
2474         for (unsigned int x = 0; x < items; x++)
2475         {
2476                 TreeServer* Route = TreeRoot->GetChild(x);
2477                 if (Route->GetSocket())
2478                 {
2479                         TreeSocket* Sock = Route->GetSocket();
2480                         Sock->WriteLine(FullLine);
2481                 }
2482         }
2483         return true;
2484 }
2485
2486 bool DoOneToOne(std::string prefix, std::string command, std::deque<std::string> &params, std::string target)
2487 {
2488         TreeServer* Route = BestRouteTo(target);
2489         if (Route)
2490         {
2491                 std::string FullLine = ":" + prefix + " " + command;
2492                 unsigned int words = params.size();
2493                 for (unsigned int x = 0; x < words; x++)
2494                 {
2495                         FullLine = FullLine + " " + params[x];
2496                 }
2497                 if (Route->GetSocket())
2498                 {
2499                         TreeSocket* Sock = Route->GetSocket();
2500                         Sock->WriteLine(FullLine);
2501                 }
2502                 return true;
2503         }
2504         else
2505         {
2506                 return true;
2507         }
2508 }
2509
2510 std::vector<TreeSocket*> Bindings;
2511
2512 void ReadConfiguration(bool rebind)
2513 {
2514         Conf = new ConfigReader;
2515         if (rebind)
2516         {
2517                 for (int j =0; j < Conf->Enumerate("bind"); j++)
2518                 {
2519                         std::string Type = Conf->ReadValue("bind","type",j);
2520                         std::string IP = Conf->ReadValue("bind","address",j);
2521                         long Port = Conf->ReadInteger("bind","port",j,true);
2522                         if (Type == "servers")
2523                         {
2524                                 if (IP == "*")
2525                                 {
2526                                         IP = "";
2527                                 }
2528                                 TreeSocket* listener = new TreeSocket(IP.c_str(),Port,true,10);
2529                                 if (listener->GetState() == I_LISTENING)
2530                                 {
2531                                         Srv->AddSocket(listener);
2532                                         Bindings.push_back(listener);
2533                                 }
2534                                 else
2535                                 {
2536                                         log(DEFAULT,"m_spanningtree: Warning: Failed to bind server port %d",Port);
2537                                         listener->Close();
2538                                         delete listener;
2539                                 }
2540                         }
2541                 }
2542         }
2543         FlatLinks = Conf->ReadFlag("options","flatlinks",0);
2544         HideULines = Conf->ReadFlag("options","hideulines",0);
2545         LinkBlocks.clear();
2546         for (int j =0; j < Conf->Enumerate("link"); j++)
2547         {
2548                 Link L;
2549                 L.Name = Conf->ReadValue("link","name",j);
2550                 L.IPAddr = Conf->ReadValue("link","ipaddr",j);
2551                 L.Port = Conf->ReadInteger("link","port",j,true);
2552                 L.SendPass = Conf->ReadValue("link","sendpass",j);
2553                 L.RecvPass = Conf->ReadValue("link","recvpass",j);
2554                 L.AutoConnect = Conf->ReadInteger("link","autoconnect",j,true);
2555                 L.EncryptionKey =  Conf->ReadValue("link","encryptionkey",j);
2556                 L.HiddenFromStats = Conf->ReadFlag("link","hidden",j);
2557                 L.NextConnectTime = time(NULL) + L.AutoConnect;
2558                 /* Bugfix by brain, do not allow people to enter bad configurations */
2559                 if ((L.RecvPass != "") && (L.SendPass != "") && (L.Name != "") && (L.Port))
2560                 {
2561                         LinkBlocks.push_back(L);
2562                         log(DEBUG,"m_spanningtree: Read server %s with host %s:%d",L.Name.c_str(),L.IPAddr.c_str(),L.Port);
2563                 }
2564                 else
2565                 {
2566                         if (L.RecvPass == "")
2567                         {
2568                                 log(DEFAULT,"Invalid configuration for server '%s', recvpass not defined!",L.Name.c_str());
2569                         }
2570                         else if (L.SendPass == "")
2571                         {
2572                                 log(DEFAULT,"Invalid configuration for server '%s', sendpass not defined!",L.Name.c_str());
2573                         }
2574                         else if (L.Name == "")
2575                         {
2576                                 log(DEFAULT,"Invalid configuration, link tag without a name!");
2577                         }
2578                         else if (!L.Port)
2579                         {
2580                                 log(DEFAULT,"Invalid configuration for server '%s', no port specified!",L.Name.c_str());
2581                         }
2582                 }
2583         }
2584         delete Conf;
2585 }
2586
2587
2588 class ModuleSpanningTree : public Module
2589 {
2590         std::vector<TreeSocket*> Bindings;
2591         int line;
2592         int NumServers;
2593         unsigned int max_local;
2594         unsigned int max_global;
2595         cmd_rconnect* command_rconnect;
2596
2597  public:
2598
2599         ModuleSpanningTree(Server* Me)
2600                 : Module::Module(Me), max_local(0), max_global(0)
2601         {
2602                 Srv = Me;
2603                 Bindings.clear();
2604
2605                 // Create the root of the tree
2606                 TreeRoot = new TreeServer(Srv->GetServerName(),Srv->GetServerDescription());
2607
2608                 ReadConfiguration(true);
2609
2610                 command_rconnect = new cmd_rconnect(this);
2611                 Srv->AddCommand(command_rconnect);
2612         }
2613
2614         void ShowLinks(TreeServer* Current, userrec* user, int hops)
2615         {
2616                 std::string Parent = TreeRoot->GetName();
2617                 if (Current->GetParent())
2618                 {
2619                         Parent = Current->GetParent()->GetName();
2620                 }
2621                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
2622                 {
2623                         if ((HideULines) && (Srv->IsUlined(Current->GetName())))
2624                         {
2625                                 if (*user->oper)
2626                                 {
2627                                          ShowLinks(Current->GetChild(q),user,hops+1);
2628                                 }
2629                         }
2630                         else
2631                         {
2632                                 ShowLinks(Current->GetChild(q),user,hops+1);
2633                         }
2634                 }
2635                 WriteServ(user->fd,"364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(FlatLinks && (!*user->oper)) ? Srv->GetServerName().c_str() : Parent.c_str(),(FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
2636         }
2637
2638         int CountLocalServs()
2639         {
2640                 return TreeRoot->ChildCount();
2641         }
2642
2643         int CountServs()
2644         {
2645                 return serverlist.size();
2646         }
2647
2648         void HandleLinks(char** parameters, int pcnt, userrec* user)
2649         {
2650                 ShowLinks(TreeRoot,user,0);
2651                 WriteServ(user->fd,"365 %s * :End of /LINKS list.",user->nick);
2652                 return;
2653         }
2654
2655         void HandleLusers(char** parameters, int pcnt, userrec* user)
2656         {
2657                 /* Only update these when someone wants to see them, more efficient */
2658                 if ((unsigned int)local_count() > max_local)
2659                         max_local = local_count();
2660                 if (clientlist.size() > max_global)
2661                         max_global = clientlist.size();
2662
2663                 WriteServ(user->fd,"251 %s :There are %d users and %d invisible on %d servers",user->nick,usercnt()-usercount_invisible(),usercount_invisible(),this->CountServs());
2664                 WriteServ(user->fd,"252 %s %d :operator(s) online",user->nick,usercount_opers());
2665                 WriteServ(user->fd,"253 %s %d :unknown connections",user->nick,usercount_unknown());
2666                 WriteServ(user->fd,"254 %s %d :channels formed",user->nick,chancount());
2667                 WriteServ(user->fd,"254 %s :I have %d clients and %d servers",user->nick,local_count(),this->CountLocalServs());
2668                 WriteServ(user->fd,"265 %s :Current Local Users: %d  Max: %d",user->nick,local_count(),max_local);
2669                 WriteServ(user->fd,"266 %s :Current Global Users: %d  Max: %d",user->nick,clientlist.size(),max_global);
2670                 return;
2671         }
2672
2673         // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS.
2674
2675         void ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80])
2676         {
2677                 if (line < 128)
2678                 {
2679                         for (int t = 0; t < depth; t++)
2680                         {
2681                                 matrix[line][t] = ' ';
2682                         }
2683
2684                         // For Aligning, we need to work out exactly how deep this thing is, and produce
2685                         // a 'Spacer' String to compensate.
2686                         char spacer[40];
2687
2688                         memset(spacer,' ',40);
2689                         if ((40 - Current->GetName().length() - depth) > 1) {
2690                                 spacer[40 - Current->GetName().length() - depth] = '\0';
2691                         }
2692                         else
2693                         {
2694                                 spacer[5] = '\0';
2695                         }
2696
2697                         float percent;
2698                         char text[80];
2699                         if (clientlist.size() == 0) {
2700                                 // If there are no users, WHO THE HELL DID THE /MAP?!?!?!
2701                                 percent = 0;
2702                         }
2703                         else
2704                         {
2705                                 percent = ((float)Current->GetUserCount() / (float)clientlist.size()) * 100;
2706                         }
2707                         snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent);
2708                         strlcpy(&matrix[line][depth],text,80);
2709                         line++;
2710                         for (unsigned int q = 0; q < Current->ChildCount(); q++)
2711                         {
2712                                 if ((HideULines) && (Srv->IsUlined(Current->GetChild(q)->GetName())))
2713                                 {
2714                                         if (*user->oper)
2715                                         {
2716                                                 ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix);
2717                                         }
2718                                 }
2719                                 else
2720                                 {
2721                                         ShowMap(Current->GetChild(q),user,(FlatLinks && (!*user->oper)) ? depth : depth+2,matrix);
2722                                 }
2723                         }
2724                 }
2725         }
2726
2727         // Ok, prepare to be confused.
2728         // After much mulling over how to approach this, it struck me that
2729         // the 'usual' way of doing a /MAP isnt the best way. Instead of
2730         // keeping track of a ton of ascii characters, and line by line
2731         // under recursion working out where to place them using multiplications
2732         // and divisons, we instead render the map onto a backplane of characters
2733         // (a character matrix), then draw the branches as a series of "L" shapes
2734         // from the nodes. This is not only friendlier on CPU it uses less stack.
2735
2736         void HandleMap(char** parameters, int pcnt, userrec* user)
2737         {
2738                 // This array represents a virtual screen which we will
2739                 // "scratch" draw to, as the console device of an irc
2740                 // client does not provide for a proper terminal.
2741                 char matrix[128][80];
2742                 for (unsigned int t = 0; t < 128; t++)
2743                 {
2744                         matrix[t][0] = '\0';
2745                 }
2746                 line = 0;
2747                 // The only recursive bit is called here.
2748                 ShowMap(TreeRoot,user,0,matrix);
2749                 // Process each line one by one. The algorithm has a limit of
2750                 // 128 servers (which is far more than a spanning tree should have
2751                 // anyway, so we're ok). This limit can be raised simply by making
2752                 // the character matrix deeper, 128 rows taking 10k of memory.
2753                 for (int l = 1; l < line; l++)
2754                 {
2755                         // scan across the line looking for the start of the
2756                         // servername (the recursive part of the algorithm has placed
2757                         // the servers at indented positions depending on what they
2758                         // are related to)
2759                         int first_nonspace = 0;
2760                         while (matrix[l][first_nonspace] == ' ')
2761                         {
2762                                 first_nonspace++;
2763                         }
2764                         first_nonspace--;
2765                         // Draw the `- (corner) section: this may be overwritten by
2766                         // another L shape passing along the same vertical pane, becoming
2767                         // a |- (branch) section instead.
2768                         matrix[l][first_nonspace] = '-';
2769                         matrix[l][first_nonspace-1] = '`';
2770                         int l2 = l - 1;
2771                         // Draw upwards until we hit the parent server, causing possibly
2772                         // other corners (`-) to become branches (|-)
2773                         while ((matrix[l2][first_nonspace-1] == ' ') || (matrix[l2][first_nonspace-1] == '`'))
2774                         {
2775                                 matrix[l2][first_nonspace-1] = '|';
2776                                 l2--;
2777                         }
2778                 }
2779                 // dump the whole lot to the user. This is the easy bit, honest.
2780                 for (int t = 0; t < line; t++)
2781                 {
2782                         WriteServ(user->fd,"006 %s :%s",user->nick,&matrix[t][0]);
2783                 }
2784                 WriteServ(user->fd,"007 %s :End of /MAP",user->nick);
2785                 return;
2786         }
2787
2788         int HandleSquit(char** parameters, int pcnt, userrec* user)
2789         {
2790                 TreeServer* s = FindServerMask(parameters[0]);
2791                 if (s)
2792                 {
2793                         if (s == TreeRoot)
2794                         {
2795                                  WriteServ(user->fd,"NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]);
2796                                 return 1;
2797                         }
2798                         TreeSocket* sock = s->GetSocket();
2799                         if (sock)
2800                         {
2801                                 log(DEBUG,"Splitting server %s",s->GetName().c_str());
2802                                 WriteOpers("*** SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
2803                                 sock->Squit(s,"Server quit by "+std::string(user->nick)+"!"+std::string(user->ident)+"@"+std::string(user->host));
2804                                 Srv->RemoveSocket(sock);
2805                         }
2806                         else
2807                         {
2808                                 WriteServ(user->fd,"NOTICE %s :*** SQUIT: The server \002%s\002 is not directly connected.",user->nick,parameters[0]);
2809                         }
2810                 }
2811                 else
2812                 {
2813                          WriteServ(user->fd,"NOTICE %s :*** SQUIT: The server \002%s\002 does not exist on the network.",user->nick,parameters[0]);
2814                 }
2815                 return 1;
2816         }
2817
2818         int HandleTime(char** parameters, int pcnt, userrec* user)
2819         {
2820                 if ((user->fd > -1) && (pcnt))
2821                 {
2822                         TreeServer* found = FindServerMask(parameters[0]);
2823                         if (found)
2824                         {
2825                                 // we dont' override for local server
2826                                 if (found == TreeRoot)
2827                                         return 0;
2828                                 
2829                                 std::deque<std::string> params;
2830                                 params.push_back(found->GetName());
2831                                 params.push_back(user->nick);
2832                                 DoOneToOne(Srv->GetServerName(),"TIME",params,found->GetName());
2833                         }
2834                         else
2835                         {
2836                                 WriteServ(user->fd,"402 %s %s :No such server",user->nick,parameters[0]);
2837                         }
2838                 }
2839                 return 1;
2840         }
2841
2842         int HandleRemoteWhois(char** parameters, int pcnt, userrec* user)
2843         {
2844                 if ((user->fd > -1) && (pcnt > 1))
2845                 {
2846                         userrec* remote = Srv->FindNick(parameters[1]);
2847                         if ((remote) && (remote->fd < 0))
2848                         {
2849                                 std::deque<std::string> params;
2850                                 params.push_back(parameters[1]);
2851                                 DoOneToOne(user->nick,"IDLE",params,remote->server);
2852                                 return 1;
2853                         }
2854                         else if (!remote)
2855                         {
2856                                 WriteServ(user->fd,"401 %s %s :No such nick/channel",user->nick, parameters[1]);
2857                                 WriteServ(user->fd,"318 %s %s :End of /WHOIS list.",user->nick, parameters[1]);
2858                                 return 1;
2859                         }
2860                 }
2861                 return 0;
2862         }
2863
2864         void DoPingChecks(time_t curtime)
2865         {
2866                 for (unsigned int j = 0; j < TreeRoot->ChildCount(); j++)
2867                 {
2868                         TreeServer* serv = TreeRoot->GetChild(j);
2869                         TreeSocket* sock = serv->GetSocket();
2870                         if (sock)
2871                         {
2872                                 if (curtime >= serv->NextPingTime())
2873                                 {               
2874                                         if (serv->AnsweredLastPing())
2875                                         {               
2876                                                 sock->WriteLine(":"+Srv->GetServerName()+" PING "+serv->GetName());
2877                                                 serv->SetNextPingTime(curtime + 120);
2878                                         }                       
2879                                         else            
2880                                         {       
2881                                                 // they didnt answer, boot them
2882                                                 WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str());
2883                                                 sock->Squit(serv,"Ping timeout");
2884                                                 Srv->RemoveSocket(sock);
2885                                                 return;
2886                                         }
2887                                 }
2888
2889                         }
2890                 }
2891         }
2892
2893         void AutoConnectServers(time_t curtime)
2894         {
2895                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
2896                 {
2897                         if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
2898                         {
2899                                 log(DEBUG,"Auto-Connecting %s",x->Name.c_str());
2900                                 x->NextConnectTime = curtime + x->AutoConnect;
2901                                 TreeServer* CheckDupe = FindServer(x->Name);
2902                                 if (!CheckDupe)
2903                                 {
2904                                         // an autoconnected server is not connected. Check if its time to connect it
2905                                         WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
2906                                         TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
2907                                         if (newsocket->GetState() != I_ERROR)
2908                                         {
2909                                                 Srv->AddSocket(newsocket);
2910                                         }
2911                                         else
2912                                         {
2913                                                 WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002.",x->Name.c_str());
2914                                                 delete newsocket;
2915                                         }
2916                                 }
2917                         }
2918                 }
2919         }
2920
2921         int HandleVersion(char** parameters, int pcnt, userrec* user)
2922         {
2923                 // we've already checked if pcnt > 0, so this is safe
2924                 TreeServer* found = FindServerMask(parameters[0]);
2925                 if (found)
2926                 {
2927                         std::string Version = found->GetVersion();
2928                         WriteServ(user->fd,"351 %s :%s",user->nick,Version.c_str());
2929                         if (found == TreeRoot)
2930                         {
2931                                 std::stringstream out(Config->data005);
2932                                 std::string token = "";
2933                                 std::string line5 = "";
2934                                 int token_counter = 0;
2935                                 while (!out.eof())
2936                                 {
2937                                         out >> token;
2938                                         line5 = line5 + token + " ";   
2939                                         token_counter++;
2940                                         if ((token_counter >= 13) || (out.eof() == true))
2941                                         {
2942                                                 WriteServ(user->fd,"005 %s %s:are supported by this server",user->nick,line5.c_str());
2943                                                 line5 = "";
2944                                                 token_counter = 0;
2945                                         }
2946                                 }
2947                         }
2948                 }
2949                 else
2950                 {
2951                         WriteServ(user->fd,"402 %s %s :No such server",user->nick,parameters[0]);
2952                 }
2953                 return 1;
2954         }
2955         
2956         int HandleConnect(char** parameters, int pcnt, userrec* user)
2957         {
2958                 for (std::vector<Link>::iterator x = LinkBlocks.begin(); x < LinkBlocks.end(); x++)
2959                 {
2960                         if (Srv->MatchText(x->Name.c_str(),parameters[0]))
2961                         {
2962                                 TreeServer* CheckDupe = FindServer(x->Name);
2963                                 if (!CheckDupe)
2964                                 {
2965                                         WriteServ(user->fd,"NOTICE %s :*** CONNECT: Connecting to server: \002%s\002 (%s:%d)",user->nick,x->Name.c_str(),(x->HiddenFromStats ? "<hidden>" : x->IPAddr.c_str()),x->Port);
2966                                         TreeSocket* newsocket = new TreeSocket(x->IPAddr,x->Port,false,10,x->Name);
2967                                         if (newsocket->GetState() != I_ERROR)
2968                                         {
2969                                                 Srv->AddSocket(newsocket);
2970                                         }
2971                                         else
2972                                         {
2973                                                 WriteServ(user->fd,"NOTICE %s :*** CONNECT: Error connecting \002%s\002.",user->nick,x->Name.c_str());
2974                                                 delete newsocket;
2975                                         }
2976                                         return 1;
2977                                 }
2978                                 else
2979                                 {
2980                                         WriteServ(user->fd,"NOTICE %s :*** CONNECT: Server \002%s\002 already exists on the network and is connected via \002%s\002",user->nick,x->Name.c_str(),CheckDupe->GetParent()->GetName().c_str());
2981                                         return 1;
2982                                 }
2983                         }
2984                 }
2985                 WriteServ(user->fd,"NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]);
2986                 return 1;
2987         }
2988
2989         virtual int OnStats(char statschar, userrec* user)
2990         {
2991                 if (statschar == 'c')
2992                 {
2993                         for (unsigned int i = 0; i < LinkBlocks.size(); i++)
2994                         {
2995                                 WriteServ(user->fd,"213 %s C *@%s * %s %d 0 %c%c%c",user->nick,(LinkBlocks[i].HiddenFromStats ? "<hidden>" : LinkBlocks[i].IPAddr).c_str(),LinkBlocks[i].Name.c_str(),LinkBlocks[i].Port,(LinkBlocks[i].EncryptionKey != "" ? 'e' : '-'),(LinkBlocks[i].AutoConnect ? 'a' : '-'),'s');
2996                                 WriteServ(user->fd,"244 %s H * * %s",user->nick,LinkBlocks[i].Name.c_str());
2997                         }
2998                         WriteServ(user->fd,"219 %s %c :End of /STATS report",user->nick,statschar);
2999                         WriteOpers("*** Notice: Stats '%c' requested by %s (%s@%s)",statschar,user->nick,user->ident,user->host);
3000                         return 1;
3001                 }
3002                 return 0;
3003         }
3004
3005         virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated)
3006         {
3007                 /* If the command doesnt appear to be valid, we dont want to mess with it. */
3008                 if (!validated)
3009                         return 0;
3010
3011                 if (command == "CONNECT")
3012                 {
3013                         return this->HandleConnect(parameters,pcnt,user);
3014                 }
3015                 else if (command == "SQUIT")
3016                 {
3017                         return this->HandleSquit(parameters,pcnt,user);
3018                 }
3019                 else if (command == "MAP")
3020                 {
3021                         this->HandleMap(parameters,pcnt,user);
3022                         return 1;
3023                 }
3024                 else if ((command == "TIME") && (pcnt > 0))
3025                 {
3026                         return this->HandleTime(parameters,pcnt,user);
3027                 }
3028                 else if (command == "LUSERS")
3029                 {
3030                         this->HandleLusers(parameters,pcnt,user);
3031                         return 1;
3032                 }
3033                 else if (command == "LINKS")
3034                 {
3035                         this->HandleLinks(parameters,pcnt,user);
3036                         return 1;
3037                 }
3038                 else if (command == "WHOIS")
3039                 {
3040                         if (pcnt > 1)
3041                         {
3042                                 // remote whois
3043                                 return this->HandleRemoteWhois(parameters,pcnt,user);
3044                         }
3045                 }
3046                 else if ((command == "VERSION") && (pcnt > 0))
3047                 {
3048                         this->HandleVersion(parameters,pcnt,user);
3049                         return 1;
3050                 }
3051                 else if (Srv->IsValidModuleCommand(command, pcnt, user))
3052                 {
3053                         // this bit of code cleverly routes all module commands
3054                         // to all remote severs *automatically* so that modules
3055                         // can just handle commands locally, without having
3056                         // to have any special provision in place for remote
3057                         // commands and linking protocols.
3058                         std::deque<std::string> params;
3059                         params.clear();
3060                         for (int j = 0; j < pcnt; j++)
3061                         {
3062                                 if (strchr(parameters[j],' '))
3063                                 {
3064                                         params.push_back(":" + std::string(parameters[j]));
3065                                 }
3066                                 else
3067                                 {
3068                                         params.push_back(std::string(parameters[j]));
3069                                 }
3070                         }
3071                         log(DEBUG,"Globally route '%s'",command.c_str());
3072                         DoOneToMany(user->nick,command,params);
3073                 }
3074                 return 0;
3075         }
3076
3077         virtual void OnGetServerDescription(std::string servername,std::string &description)
3078         {
3079                 TreeServer* s = FindServer(servername);
3080                 if (s)
3081                 {
3082                         description = s->GetDesc();
3083                 }
3084         }
3085
3086         virtual void OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
3087         {
3088                 if (source->fd > -1)
3089                 {
3090                         std::deque<std::string> params;
3091                         params.push_back(dest->nick);
3092                         params.push_back(channel->name);
3093                         DoOneToMany(source->nick,"INVITE",params);
3094                 }
3095         }
3096
3097         virtual void OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic)
3098         {
3099                 std::deque<std::string> params;
3100                 params.push_back(chan->name);
3101                 params.push_back(":"+topic);
3102                 DoOneToMany(user->nick,"TOPIC",params);
3103         }
3104
3105         virtual void OnWallops(userrec* user, std::string text)
3106         {
3107                 if (user->fd > -1)
3108                 {
3109                         std::deque<std::string> params;
3110                         params.push_back(":"+text);
3111                         DoOneToMany(user->nick,"WALLOPS",params);
3112                 }
3113         }
3114
3115         virtual void OnUserNotice(userrec* user, void* dest, int target_type, std::string text, char status)
3116         {
3117                 if (target_type == TYPE_USER)
3118                 {
3119                         userrec* d = (userrec*)dest;
3120                         if ((d->fd < 0) && (user->fd > -1))
3121                         {
3122                                 std::deque<std::string> params;
3123                                 params.clear();
3124                                 params.push_back(d->nick);
3125                                 params.push_back(":"+text);
3126                                 DoOneToOne(user->nick,"NOTICE",params,d->server);
3127                         }
3128                 }
3129                 else
3130                 {
3131                         if (user->fd > -1)
3132                         {
3133                                 chanrec *c = (chanrec*)dest;
3134                                 std::string cname = c->name;
3135                                 if (status)
3136                                         cname = status + cname;
3137                                 std::deque<TreeServer*> list;
3138                                 GetListOfServersForChannel(c,list);
3139                                 unsigned int ucount = list.size();
3140                                 for (unsigned int i = 0; i < ucount; i++)
3141                                 {
3142                                         TreeSocket* Sock = list[i]->GetSocket();
3143                                         if (Sock)
3144                                                 Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text);
3145                                 }
3146                         }
3147                 }
3148         }
3149
3150         virtual void OnUserMessage(userrec* user, void* dest, int target_type, std::string text, char status)
3151         {
3152                 if (target_type == TYPE_USER)
3153                 {
3154                         // route private messages which are targetted at clients only to the server
3155                         // which needs to receive them
3156                         userrec* d = (userrec*)dest;
3157                         if ((d->fd < 0) && (user->fd > -1))
3158                         {
3159                                 std::deque<std::string> params;
3160                                 params.clear();
3161                                 params.push_back(d->nick);
3162                                 params.push_back(":"+text);
3163                                 DoOneToOne(user->nick,"PRIVMSG",params,d->server);
3164                         }
3165                 }
3166                 else
3167                 {
3168                         if (user->fd > -1)
3169                         {
3170                                 chanrec *c = (chanrec*)dest;
3171                                 std::string cname = c->name;
3172                                 if (status)
3173                                         cname = status + cname;
3174                                 std::deque<TreeServer*> list;
3175                                 GetListOfServersForChannel(c,list);
3176                                 unsigned int ucount = list.size();
3177                                 for (unsigned int i = 0; i < ucount; i++)
3178                                 {
3179                                         TreeSocket* Sock = list[i]->GetSocket();
3180                                         if (Sock)
3181                                                 Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text);
3182                                 }
3183                         }
3184                 }
3185         }
3186
3187         virtual void OnBackgroundTimer(time_t curtime)
3188         {
3189                 AutoConnectServers(curtime);
3190                 DoPingChecks(curtime);
3191         }
3192
3193         virtual void OnUserJoin(userrec* user, chanrec* channel)
3194         {
3195                 // Only do this for local users
3196                 if (user->fd > -1)
3197                 {
3198                         std::deque<std::string> params;
3199                         params.clear();
3200                         params.push_back(channel->name);
3201                         if (*channel->key)
3202                         {
3203                                 // if the channel has a key, force the join by emulating the key.
3204                                 params.push_back(channel->key);
3205                         }
3206                         if (channel->GetUserCounter() > 1)
3207                         {
3208                                 // not the first in the channel
3209                                 DoOneToMany(user->nick,"JOIN",params);
3210                         }
3211                         else
3212                         {
3213                                 // first in the channel, set up their permissions
3214                                 // and the channel TS with FJOIN.
3215                                 char ts[24];
3216                                 snprintf(ts,24,"%lu",(unsigned long)channel->age);
3217                                 params.clear();
3218                                 params.push_back(channel->name);
3219                                 params.push_back(ts);
3220                                 params.push_back("@"+std::string(user->nick));
3221                                 DoOneToMany(Srv->GetServerName(),"FJOIN",params);
3222                         }
3223                 }
3224         }
3225
3226         virtual void OnChangeHost(userrec* user, std::string newhost)
3227         {
3228                 // only occurs for local clients
3229                 if (user->registered != 7)
3230                         return;
3231                 std::deque<std::string> params;
3232                 params.push_back(newhost);
3233                 DoOneToMany(user->nick,"FHOST",params);
3234         }
3235
3236         virtual void OnChangeName(userrec* user, std::string gecos)
3237         {
3238                 // only occurs for local clients
3239                 if (user->registered != 7)
3240                         return;
3241                 std::deque<std::string> params;
3242                 params.push_back(gecos);
3243                 DoOneToMany(user->nick,"FNAME",params);
3244         }
3245
3246         virtual void OnUserPart(userrec* user, chanrec* channel, std::string partmessage)
3247         {
3248                 if (user->fd > -1)
3249                 {
3250                         std::deque<std::string> params;
3251                         params.push_back(channel->name);
3252                         if (partmessage != "")
3253                                 params.push_back(":"+partmessage);
3254                         DoOneToMany(user->nick,"PART",params);
3255                 }
3256         }
3257
3258         virtual void OnUserConnect(userrec* user)
3259         {
3260                 char agestr[MAXBUF];
3261                 if (user->fd > -1)
3262                 {
3263                         std::deque<std::string> params;
3264                         snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
3265                         params.push_back(agestr);
3266                         params.push_back(user->nick);
3267                         params.push_back(user->host);
3268                         params.push_back(user->dhost);
3269                         params.push_back(user->ident);
3270                         params.push_back("+"+std::string(user->modes));
3271                         params.push_back((char*)inet_ntoa(user->ip4));
3272                         params.push_back(":"+std::string(user->fullname));
3273                         DoOneToMany(Srv->GetServerName(),"NICK",params);
3274
3275                         // User is Local, change needs to be reflected!
3276                         TreeServer* SourceServer = FindServer(user->server);
3277                         if (SourceServer) {
3278                                 SourceServer->AddUserCount();
3279                         }
3280
3281                 }
3282         }
3283
3284         virtual void OnUserQuit(userrec* user, std::string reason)
3285         {
3286                 if ((user->fd > -1) && (user->registered == 7))
3287                 {
3288                         std::deque<std::string> params;
3289                         params.push_back(":"+reason);
3290                         DoOneToMany(user->nick,"QUIT",params);
3291                 }
3292                 // Regardless, We need to modify the user Counts..
3293                 TreeServer* SourceServer = FindServer(user->server);
3294                 if (SourceServer) {
3295                         SourceServer->DelUserCount();
3296                 }
3297
3298         }
3299
3300         virtual void OnUserPostNick(userrec* user, std::string oldnick)
3301         {
3302                 if (user->fd > -1)
3303                 {
3304                         std::deque<std::string> params;
3305                         params.push_back(user->nick);
3306                         DoOneToMany(oldnick,"NICK",params);
3307                 }
3308         }
3309
3310         virtual void OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason)
3311         {
3312                 if ((source) && (source->fd > -1))
3313                 {
3314                         std::deque<std::string> params;
3315                         params.push_back(chan->name);
3316                         params.push_back(user->nick);
3317                         params.push_back(":"+reason);
3318                         DoOneToMany(source->nick,"KICK",params);
3319                 }
3320         }
3321
3322         virtual void OnRemoteKill(userrec* source, userrec* dest, std::string reason)
3323         {
3324                 std::deque<std::string> params;
3325                 params.push_back(dest->nick);
3326                 params.push_back(":"+reason);
3327                 DoOneToMany(source->nick,"KILL",params);
3328         }
3329
3330         virtual void OnRehash(std::string parameter)
3331         {
3332                 if (parameter != "")
3333                 {
3334                         std::deque<std::string> params;
3335                         params.push_back(parameter);
3336                         DoOneToMany(Srv->GetServerName(),"REHASH",params);
3337                         // check for self
3338                         if (Srv->MatchText(Srv->GetServerName(),parameter))
3339                         {
3340                                 Srv->SendOpers("*** Remote rehash initiated from server \002"+Srv->GetServerName()+"\002.");
3341                                 Srv->RehashServer();
3342                         }
3343                 }
3344                 ReadConfiguration(false);
3345         }
3346
3347         // note: the protocol does not allow direct umode +o except
3348         // via NICK with 8 params. sending OPERTYPE infers +o modechange
3349         // locally.
3350         virtual void OnOper(userrec* user, std::string opertype)
3351         {
3352                 if (user->fd > -1)
3353                 {
3354                         std::deque<std::string> params;
3355                         params.push_back(opertype);
3356                         DoOneToMany(user->nick,"OPERTYPE",params);
3357                 }
3358         }
3359
3360         void OnLine(userrec* source, std::string host, bool adding, char linetype, long duration, std::string reason)
3361         {
3362                 if (source->fd > -1)
3363                 {
3364                         char type[8];
3365                         snprintf(type,8,"%cLINE",linetype);
3366                         std::string stype = type;
3367                         if (adding)
3368                         {
3369                                 char sduration[MAXBUF];
3370                                 snprintf(sduration,MAXBUF,"%ld",duration);
3371                                 std::deque<std::string> params;
3372                                 params.push_back(host);
3373                                 params.push_back(sduration);
3374                                 params.push_back(":"+reason);
3375                                 DoOneToMany(source->nick,stype,params);
3376                         }
3377                         else
3378                         {
3379                                 std::deque<std::string> params;
3380                                 params.push_back(host);
3381                                 DoOneToMany(source->nick,stype,params);
3382                         }
3383                 }
3384         }
3385
3386         virtual void OnAddGLine(long duration, userrec* source, std::string reason, std::string hostmask)
3387         {
3388                 OnLine(source,hostmask,true,'G',duration,reason);
3389         }
3390         
3391         virtual void OnAddZLine(long duration, userrec* source, std::string reason, std::string ipmask)
3392         {
3393                 OnLine(source,ipmask,true,'Z',duration,reason);
3394         }
3395
3396         virtual void OnAddQLine(long duration, userrec* source, std::string reason, std::string nickmask)
3397         {
3398                 OnLine(source,nickmask,true,'Q',duration,reason);
3399         }
3400
3401         virtual void OnAddELine(long duration, userrec* source, std::string reason, std::string hostmask)
3402         {
3403                 OnLine(source,hostmask,true,'E',duration,reason);
3404         }
3405
3406         virtual void OnDelGLine(userrec* source, std::string hostmask)
3407         {
3408                 OnLine(source,hostmask,false,'G',0,"");
3409         }
3410
3411         virtual void OnDelZLine(userrec* source, std::string ipmask)
3412         {
3413                 OnLine(source,ipmask,false,'Z',0,"");
3414         }
3415
3416         virtual void OnDelQLine(userrec* source, std::string nickmask)
3417         {
3418                 OnLine(source,nickmask,false,'Q',0,"");
3419         }
3420
3421         virtual void OnDelELine(userrec* source, std::string hostmask)
3422         {
3423                 OnLine(source,hostmask,false,'E',0,"");
3424         }
3425
3426         virtual void OnMode(userrec* user, void* dest, int target_type, std::string text)
3427         {
3428                 if ((user->fd > -1) && (user->registered == 7))
3429                 {
3430                         if (target_type == TYPE_USER)
3431                         {
3432                                 userrec* u = (userrec*)dest;
3433                                 std::deque<std::string> params;
3434                                 params.push_back(u->nick);
3435                                 params.push_back(text);
3436                                 DoOneToMany(user->nick,"MODE",params);
3437                         }
3438                         else
3439                         {
3440                                 chanrec* c = (chanrec*)dest;
3441                                 std::deque<std::string> params;
3442                                 params.push_back(c->name);
3443                                 params.push_back(text);
3444                                 DoOneToMany(user->nick,"MODE",params);
3445                         }
3446                 }
3447         }
3448
3449         virtual void OnSetAway(userrec* user)
3450         {
3451                 if (IS_LOCAL(user))
3452                 {
3453                         std::deque<std::string> params;
3454                         params.push_back(":"+std::string(user->awaymsg));
3455                         DoOneToMany(user->nick,"AWAY",params);
3456                 }
3457         }
3458
3459         virtual void OnCancelAway(userrec* user)
3460         {
3461                 if (IS_LOCAL(user))
3462                 {
3463                         std::deque<std::string> params;
3464                         params.clear();
3465                         DoOneToMany(user->nick,"AWAY",params);
3466                 }
3467         }
3468
3469         virtual void ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline)
3470         {
3471                 TreeSocket* s = (TreeSocket*)opaque;
3472                 if (target)
3473                 {
3474                         if (target_type == TYPE_USER)
3475                         {
3476                                 userrec* u = (userrec*)target;
3477                                 s->WriteLine(":"+Srv->GetServerName()+" FMODE "+u->nick+" "+modeline);
3478                         }
3479                         else
3480                         {
3481                                 chanrec* c = (chanrec*)target;
3482                                 s->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+modeline);
3483                         }
3484                 }
3485         }
3486
3487         virtual void ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata)
3488         {
3489                 TreeSocket* s = (TreeSocket*)opaque;
3490                 if (target)
3491                 {
3492                         if (target_type == TYPE_USER)
3493                         {
3494                                 userrec* u = (userrec*)target;
3495                                 s->WriteLine(":"+Srv->GetServerName()+" METADATA "+u->nick+" "+extname+" :"+extdata);
3496                         }
3497                         else if (target_type == TYPE_OTHER)
3498                         {
3499                                 s->WriteLine(":"+Srv->GetServerName()+" METADATA * "+extname+" :"+extdata);
3500                         }
3501                         else if (target_type == TYPE_CHANNEL)
3502                         {
3503                                 chanrec* c = (chanrec*)target;
3504                                 s->WriteLine(":"+Srv->GetServerName()+" METADATA "+c->name+" "+extname+" :"+extdata);
3505                         }
3506                 }
3507         }
3508
3509         virtual void OnEvent(Event* event)
3510         {
3511                 if (event->GetEventID() == "send_metadata")
3512                 {
3513                         std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
3514                         if (params->size() < 3)
3515                                 return;
3516                         (*params)[2] = ":" + (*params)[2];
3517                         DoOneToMany(Srv->GetServerName(),"METADATA",*params);
3518                 }
3519         }
3520
3521         virtual ~ModuleSpanningTree()
3522         {
3523         }
3524
3525         virtual Version GetVersion()
3526         {
3527                 return Version(1,0,0,0,VF_STATIC|VF_VENDOR);
3528         }
3529
3530         void Implements(char* List)
3531         {
3532                 List[I_OnPreCommand] = List[I_OnGetServerDescription] = List[I_OnUserInvite] = List[I_OnPostLocalTopicChange] = 1;
3533                 List[I_OnWallops] = List[I_OnUserNotice] = List[I_OnUserMessage] = List[I_OnBackgroundTimer] = 1;
3534                 List[I_OnUserJoin] = List[I_OnChangeHost] = List[I_OnChangeName] = List[I_OnUserPart] = List[I_OnUserConnect] = 1;
3535                 List[I_OnUserQuit] = List[I_OnUserPostNick] = List[I_OnUserKick] = List[I_OnRemoteKill] = List[I_OnRehash] = 1;
3536                 List[I_OnOper] = List[I_OnAddGLine] = List[I_OnAddZLine] = List[I_OnAddQLine] = List[I_OnAddELine] = 1;
3537                 List[I_OnDelGLine] = List[I_OnDelZLine] = List[I_OnDelQLine] = List[I_OnDelELine] = List[I_ProtoSendMode] = List[I_OnMode] = 1;
3538                 List[I_OnStats] = List[I_ProtoSendMetaData] = List[I_OnEvent] = List[I_OnSetAway] = List[I_OnCancelAway] = 1;
3539         }
3540
3541         /* It is IMPORTANT that m_spanningtree is the last module in the chain
3542          * so that any activity it sees is FINAL, e.g. we arent going to send out
3543          * a NICK message before m_cloaking has finished putting the +x on the user,
3544          * etc etc.
3545          * Therefore, we return PRIORITY_LAST to make sure we end up at the END of
3546          * the module call queue.
3547          */
3548         Priority Prioritize()
3549         {
3550                 return PRIORITY_LAST;
3551         }
3552 };
3553
3554
3555 class ModuleSpanningTreeFactory : public ModuleFactory
3556 {
3557  public:
3558         ModuleSpanningTreeFactory()
3559         {
3560         }
3561         
3562         ~ModuleSpanningTreeFactory()
3563         {
3564         }
3565         
3566         virtual Module * CreateModule(Server* Me)
3567         {
3568                 TreeProtocolModule = new ModuleSpanningTree(Me);
3569                 return TreeProtocolModule;
3570         }
3571         
3572 };
3573
3574
3575 extern "C" void * init_module( void )
3576 {
3577         return new ModuleSpanningTreeFactory;
3578 }