src/modules/m_spanningtree/main.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *          the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 /* $ModDesc: Provides a spanning tree server link protocol */
  15
  16 #include "configreader.h"
  17 #include "users.h"
  18 #include "channels.h"
  19 #include "modules.h"
  20 #include "commands/cmd_whois.h"
  21 #include "commands/cmd_stats.h"
  22 #include "socket.h"
  23 #include "inspircd.h"
  24 #include "wildcard.h"
  25 #include "xline.h"
  26 #include "transport.h"
  27
  28 #include "m_spanningtree/timesynctimer.h"
  29 #include "m_spanningtree/resolvers.h"
  30 #include "m_spanningtree/main.h"
  31 #include "m_spanningtree/utils.h"
  32 #include "m_spanningtree/treeserver.h"
  33 #include "m_spanningtree/link.h"
  34 #include "m_spanningtree/treesocket.h"
  35 #include "m_spanningtree/rconnect.h"
  36
  37 /* $ModDep: m_spanningtree/timesynctimer.h m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_spanningtree/rconnect.h */
  38
  39 ModuleSpanningTree::ModuleSpanningTree(InspIRCd* Me)
  40         : Module::Module(Me), max_local(0), max_global(0)
  41 {
  42         ServerInstance->UseInterface("InspSocketHook");
  43         Utils = new SpanningTreeUtilities(Me, this);
  44         command_rconnect = new cmd_rconnect(ServerInstance, this, Utils);
  45         ServerInstance->AddCommand(command_rconnect);
  46         if (Utils->EnableTimeSync)
  47         {
  48                 SyncTimer = new TimeSyncTimer(ServerInstance, this);
  49                 ServerInstance->Timers->AddTimer(SyncTimer);
  50         }
  51         else
  52                 SyncTimer = NULL;
  53 }
  54
  55 void ModuleSpanningTree::ShowLinks(TreeServer* Current, userrec* user, int hops)
  56 {
  57         std::string Parent = Utils->TreeRoot->GetName();
  58         if (Current->GetParent())
  59         {
  60                 Parent = Current->GetParent()->GetName();
  61         }
  62         for (unsigned int q = 0; q < Current->ChildCount(); q++)
  63         {
  64                 if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
  65                 {
  66                         if (*user->oper)
  67                         {
  68                                  ShowLinks(Current->GetChild(q),user,hops+1);
  69                         }
  70                 }
  71                 else
  72                 {
  73                         ShowLinks(Current->GetChild(q),user,hops+1);
  74                 }
  75         }
  76         /* Don't display the line if its a uline, hide ulines is on, and the user isnt an oper */
  77         if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetName().c_str())) && (!*user->oper))
  78                 return;
  79         user->WriteServ("364 %s %s %s :%d %s",user->nick,Current->GetName().c_str(),(Utils->FlatLinks && (!*user->oper)) ? ServerInstance->Config->ServerName : Parent.c_str(),(Utils->FlatLinks && (!*user->oper)) ? 0 : hops,Current->GetDesc().c_str());
  80 }
  81
  82 int ModuleSpanningTree::CountLocalServs()
  83 {
  84         return Utils->TreeRoot->ChildCount();
  85 }
  86
  87 int ModuleSpanningTree::CountServs()
  88 {
  89         return Utils->serverlist.size();
  90 }
  91
  92 void ModuleSpanningTree::HandleLinks(const char** parameters, int pcnt, userrec* user)
  93 {
  94         ShowLinks(Utils->TreeRoot,user,0);
  95         user->WriteServ("365 %s * :End of /LINKS list.",user->nick);
  96         return;
  97 }
  98
  99 void ModuleSpanningTree::HandleLusers(const char** parameters, int pcnt, userrec* user)
 100 {
 101         unsigned int n_users = ServerInstance->UserCount();
 102
 103         /* Only update these when someone wants to see them, more efficient */
 104         if ((unsigned int)ServerInstance->LocalUserCount() > max_local)
 105                 max_local = ServerInstance->LocalUserCount();
 106         if (n_users > max_global)
 107                 max_global = n_users;
 108
 109         unsigned int ulined_count = 0;
 110         unsigned int ulined_local_count = 0;
 111
 112         /* If ulined are hidden and we're not an oper, count the number of ulined servers hidden,
 113          * locally and globally (locally means directly connected to us)
 114          */
 115         if ((Utils->HideULines) && (!*user->oper))
 116         {
 117                 for (server_hash::iterator q = Utils->serverlist.begin(); q != Utils->serverlist.end(); q++)
 118                 {
 119                         if (ServerInstance->ULine(q->second->GetName().c_str()))
 120                         {
 121                                 ulined_count++;
 122                                 if (q->second->GetParent() == Utils->TreeRoot)
 123                                         ulined_local_count++;
 124                         }
 125                 }
 126         }
 127         user->WriteServ("251 %s :There are %d users and %d invisible on %d servers",user->nick,n_users-ServerInstance->InvisibleUserCount(),ServerInstance->InvisibleUserCount(),ulined_count ? this->CountServs() - ulined_count : this->CountServs());
 128         if (ServerInstance->OperCount())
 129                 user->WriteServ("252 %s %d :operator(s) online",user->nick,ServerInstance->OperCount());
 130         if (ServerInstance->UnregisteredUserCount())
 131                 user->WriteServ("253 %s %d :unknown connections",user->nick,ServerInstance->UnregisteredUserCount());
 132         if (ServerInstance->ChannelCount())
 133                 user->WriteServ("254 %s %d :channels formed",user->nick,ServerInstance->ChannelCount());
 134         user->WriteServ("255 %s :I have %d clients and %d servers",user->nick,ServerInstance->LocalUserCount(),ulined_local_count ? this->CountLocalServs() - ulined_local_count : this->CountLocalServs());
 135         user->WriteServ("265 %s :Current Local Users: %d  Max: %d",user->nick,ServerInstance->LocalUserCount(),max_local);
 136         user->WriteServ("266 %s :Current Global Users: %d  Max: %d",user->nick,n_users,max_global);
 137         return;
 138 }
 139
 140 // WARNING: NOT THREAD SAFE - DONT GET ANY SMART IDEAS.
 141 void ModuleSpanningTree::ShowMap(TreeServer* Current, userrec* user, int depth, char matrix[128][80], float &totusers, float &totservers)
 142 {
 143         if (line < 128)
 144         {
 145                 for (int t = 0; t < depth; t++)
 146                 {
 147                         matrix[line][t] = ' ';
 148                 }
 149                 // For Aligning, we need to work out exactly how deep this thing is, and produce
 150                 // a 'Spacer' String to compensate.
 151                 char spacer[40];
 152                 memset(spacer,' ',40);
 153                 if ((40 - Current->GetName().length() - depth) > 1) {
 154                         spacer[40 - Current->GetName().length() - depth] = '\0';
 155                 }
 156                 else
 157                 {
 158                         spacer[5] = '\0';
 159                 }
 160                 float percent;
 161                 char text[80];
 162                 if (ServerInstance->clientlist->size() == 0) {
 163                         // If there are no users, WHO THE HELL DID THE /MAP?!?!?!
 164                         percent = 0;
 165                 }
 166                 else
 167                 {
 168                         percent = ((float)Current->GetUserCount() / (float)ServerInstance->clientlist->size()) * 100;
 169                 }
 170                 snprintf(text, 80, "%s %s%5d [%5.2f%%]", Current->GetName().c_str(), spacer, Current->GetUserCount(), percent);
 171                 totusers += Current->GetUserCount();
 172                 totservers++;
 173                 strlcpy(&matrix[line][depth],text,80);
 174                 line++;
 175                 for (unsigned int q = 0; q < Current->ChildCount(); q++)
 176                 {
 177                         if ((Utils->HideULines) && (ServerInstance->ULine(Current->GetChild(q)->GetName().c_str())))
 178                         {
 179                                 if (*user->oper)
 180                                 {
 181                                         ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
 182                                 }
 183                         }
 184                         else
 185                         {
 186                                 ShowMap(Current->GetChild(q),user,(Utils->FlatLinks && (!*user->oper)) ? depth : depth+2,matrix,totusers,totservers);
 187                         }
 188                 }
 189         }
 190 }
 191
 192 int ModuleSpanningTree::HandleMotd(const char** parameters, int pcnt, userrec* user)
 193 {
 194         if (pcnt > 0)
 195         {
 196                 if (match(ServerInstance->Config->ServerName, parameters[0]))
 197                         return 0;
 198
 199                 /* Remote MOTD, the server is within the 1st parameter */
 200                 std::deque<std::string> params;
 201                 params.push_back(parameters[0]);
 202                 /* Send it out remotely, generate no reply yet */
 203                 TreeServer* s = Utils->FindServerMask(parameters[0]);
 204                 if (s)
 205                         Utils->DoOneToOne(user->nick, "MOTD", params, s->GetName());
 206                 else
 207                         user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
 208                 return 1;
 209         }
 210         return 0;
 211 }
 212
 213 int ModuleSpanningTree::HandleAdmin(const char** parameters, int pcnt, userrec* user)
 214 {
 215         if (pcnt > 0)
 216         {
 217                 if (match(ServerInstance->Config->ServerName, parameters[0]))
 218                         return 1;
 219
 220                 /* Remote ADMIN, the server is within the 1st parameter */
 221                 std::deque<std::string> params;
 222                 params.push_back(parameters[0]);
 223                 /* Send it out remotely, generate no reply yet */
 224                 TreeServer* s = Utils->FindServerMask(parameters[0]);
 225                 if (s)
 226                         Utils->DoOneToOne(user->nick, "ADMIN", params, s->GetName());
 227                 else
 228                         user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
 229                 return 1;
 230         }
 231         return 0;
 232 }
 233
 234 int ModuleSpanningTree::HandleModules(const char** parameters, int pcnt, userrec* user)
 235 {
 236         if (match(ServerInstance->Config->ServerName, parameters[0]))
 237                 return 1;
 238
 239         std::deque<std::string> params;
 240         params.push_back(parameters[0]);
 241         TreeServer* s = Utils->FindServerMask(parameters[0]);
 242         if (s)
 243                 Utils->DoOneToOne(user->nick, "MODULES", params, s->GetName());
 244         else
 245                 user->WriteServ( "402 %s %s :No such server", user->nick, parameters[0]);
 246         return 1;
 247 }
 248
 249 int ModuleSpanningTree::HandleStats(const char** parameters, int pcnt, userrec* user)
 250 {
 251         if (pcnt > 1)
 252         {
 253                 if (match(ServerInstance->Config->ServerName, parameters[1]))
 254                         return 0;
 255
 256                 /* Remote STATS, the server is within the 2nd parameter */
 257                 std::deque<std::string> params;
 258                 params.push_back(parameters[0]);
 259                 params.push_back(parameters[1]);
 260                 /* Send it out remotely, generate no reply yet */
 261
 262                 TreeServer* s = Utils->FindServerMask(parameters[1]);
 263                 if (s)
 264                 {
 265                         params[1] = s->GetName();
 266                         Utils->DoOneToOne(user->nick, "STATS", params, s->GetName());
 267                 }
 268                 else
 269                 {
 270                         user->WriteServ( "402 %s %s :No such server", user->nick, parameters[1]);
 271                 }
 272                 return 1;
 273         }
 274         return 0;
 275 }
 276
 277 // Ok, prepare to be confused.
 278 // After much mulling over how to approach this, it struck me that
 279 // the 'usual' way of doing a /MAP isnt the best way. Instead of
 280 // keeping track of a ton of ascii characters, and line by line
 281 // under recursion working out where to place them using multiplications
 282 // and divisons, we instead render the map onto a backplane of characters
 283 // (a character matrix), then draw the branches as a series of "L" shapes
 284 // from the nodes. This is not only friendlier on CPU it uses less stack.
 285 void ModuleSpanningTree::HandleMap(const char** parameters, int pcnt, userrec* user)
 286 {
 287         // This array represents a virtual screen which we will
 288         // "scratch" draw to, as the console device of an irc
 289         // client does not provide for a proper terminal.
 290         float totusers = 0;
 291         float totservers = 0;
 292         char matrix[128][80];
 293         for (unsigned int t = 0; t < 128; t++)
 294         {
 295                 matrix[t][0] = '\0';
 296         }
 297         line = 0;
 298         // The only recursive bit is called here.
 299         ShowMap(Utils->TreeRoot,user,0,matrix,totusers,totservers);
 300         // Process each line one by one. The algorithm has a limit of
 301         // 128 servers (which is far more than a spanning tree should have
 302         // anyway, so we're ok). This limit can be raised simply by making
 303         // the character matrix deeper, 128 rows taking 10k of memory.
 304         for (int l = 1; l < line; l++)
 305         {
 306                 // scan across the line looking for the start of the
 307                 // servername (the recursive part of the algorithm has placed
 308                 // the servers at indented positions depending on what they
 309                 // are related to)
 310                 int first_nonspace = 0;
 311                 while (matrix[l][first_nonspace] == ' ')
 312                 {
 313                         first_nonspace++;
 314                 }
 315                 first_nonspace--;
 316                 // Draw the `- (corner) section: this may be overwritten by
 317                 // another L shape passing along the same vertical pane, becoming
 318                 // a |- (branch) section instead.
 319                 matrix[l][first_nonspace] = '-';
 320                 matrix[l][first_nonspace-1] = '`';
 321                 int l2 = l - 1;
 322                 // Draw upwards until we hit the parent server, causing possibly
 323                 // other corners (`-) to become branches (|-)
 324                 while ((matrix[l2][first_nonspace-1] == ' ') || (matrix[l2][first_nonspace-1] == '`'))
 325                 {
 326                         matrix[l2][first_nonspace-1] = '|';
 327                         l2--;
 328                 }
 329         }
 330         // dump the whole lot to the user. This is the easy bit, honest.
 331         for (int t = 0; t < line; t++)
 332         {
 333                 user->WriteServ("006 %s :%s",user->nick,&matrix[t][0]);
 334         }
 335         float avg_users = totusers / totservers;
 336         user->WriteServ("270 %s :%.0f server%s and %.0f user%s, average %.2f users per server",user->nick,totservers,(totservers > 1 ? "s" : ""),totusers,(totusers > 1 ? "s" : ""),avg_users);
 337         user->WriteServ("007 %s :End of /MAP",user->nick);
 338         return;
 339 }
 340
 341 int ModuleSpanningTree::HandleSquit(const char** parameters, int pcnt, userrec* user)
 342 {
 343         TreeServer* s = Utils->FindServerMask(parameters[0]);
 344         if (s)
 345         {
 346                 if (s == Utils->TreeRoot)
 347                 {
 348                         user->WriteServ("NOTICE %s :*** SQUIT: Foolish mortal, you cannot make a server SQUIT itself! (%s matches local server name)",user->nick,parameters[0]);
 349                         return 1;
 350                 }
 351                 TreeSocket* sock = s->GetSocket();
 352                 if (sock)
 353                 {
 354                         ServerInstance->SNO->WriteToSnoMask('l',"SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
 355                         sock->Squit(s,std::string("Server quit by ") + user->GetFullRealHost());
 356                         ServerInstance->SE->DelFd(sock);
 357                         sock->Close();
 358                         delete sock;
 359                 }
 360                 else
 361                 {
 362                         /* route it */
 363                         std::deque<std::string> params;
 364                         params.push_back(parameters[0]);
 365                         params.push_back(std::string(":Server quit by ") + user->GetFullRealHost());
 366                         Utils->DoOneToOne(user->nick, "RSQUIT", params, parameters[0]);
 367                 }
 368         }
 369         else
 370         {
 371                  user->WriteServ("NOTICE %s :*** SQUIT: The server \002%s\002 does not exist on the network.",user->nick,parameters[0]);
 372         }
 373         return 1;
 374 }
 375
 376 int ModuleSpanningTree::HandleTime(const char** parameters, int pcnt, userrec* user)
 377 {
 378         if ((IS_LOCAL(user)) && (pcnt))
 379         {
 380                 TreeServer* found = Utils->FindServerMask(parameters[0]);
 381                 if (found)
 382                 {
 383                         // we dont' override for local server
 384                         if (found == Utils->TreeRoot)
 385                                 return 0;
 386
 387                         std::deque<std::string> params;
 388                         params.push_back(found->GetName());
 389                         params.push_back(user->nick);
 390                         Utils->DoOneToOne(ServerInstance->Config->ServerName,"TIME",params,found->GetName());
 391                 }
 392                 else
 393                 {
 394                         user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]);
 395                 }
 396         }
 397         return 1;
 398 }
 399
 400 int ModuleSpanningTree::HandleRemoteWhois(const char** parameters, int pcnt, userrec* user)
 401 {
 402         if ((IS_LOCAL(user)) && (pcnt > 1))
 403         {
 404                 userrec* remote = ServerInstance->FindNick(parameters[1]);
 405                 if ((remote) && (remote->GetFd() < 0))
 406                 {
 407                         std::deque<std::string> params;
 408                         params.push_back(parameters[1]);
 409                         Utils->DoOneToOne(user->nick,"IDLE",params,remote->server);
 410                         return 1;
 411                 }
 412                 else if (!remote)
 413                 {
 414                         user->WriteServ("401 %s %s :No such nick/channel",user->nick, parameters[1]);
 415                         user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, parameters[1]);
 416                         return 1;
 417                 }
 418         }
 419         return 0;
 420 }
 421
 422 void ModuleSpanningTree::DoPingChecks(time_t curtime)
 423 {
 424         for (unsigned int j = 0; j < Utils->TreeRoot->ChildCount(); j++)
 425         {
 426                 TreeServer* serv = Utils->TreeRoot->GetChild(j);
 427                 TreeSocket* sock = serv->GetSocket();
 428                 if (sock)
 429                 {
 430                         if (curtime >= serv->NextPingTime())
 431                         {
 432                                 if (serv->AnsweredLastPing())
 433                                 {
 434                                         sock->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" PING "+serv->GetName());
 435                                         serv->SetNextPingTime(curtime + 60);
 436                                 }
 437                                 else
 438                                 {
 439                                         // they didnt answer, boot them
 440                                         ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 pinged out",serv->GetName().c_str());
 441                                         sock->Squit(serv,"Ping timeout");
 442                                         ServerInstance->SE->DelFd(sock);
 443                                         sock->Close();
 444                                         delete sock;
 445                                         return;
 446                                 }
 447                         }
 448                 }
 449         }
 450 }
 451
 452 void ModuleSpanningTree::ConnectServer(Link* x)
 453 {
 454         bool ipvalid = true;
 455         QueryType start_type = DNS_QUERY_A;
 456 #ifdef IPV6
 457         start_type = DNS_QUERY_AAAA;
 458         if (strchr(x->IPAddr.c_str(),':'))
 459         {
 460                 in6_addr n;
 461                 if (inet_pton(AF_INET6, x->IPAddr.c_str(), &n) < 1)
 462                         ipvalid = false;
 463         }
 464         else
 465         {
 466                 in_addr n;
 467                 if (inet_aton(x->IPAddr.c_str(),&n) < 1)
 468                         ipvalid = false;
 469         }
 470 #else
 471                 in_addr n;
 472                 if (inet_aton(x->IPAddr.c_str(),&n) < 1)
 473                         ipvalid = false;
 474 #endif
 475
 476         /* Do we already have an IP? If so, no need to resolve it. */
 477         if (ipvalid)
 478         {
 479                 /* Gave a hook, but it wasnt one we know */
 480                 if ((!x->Hook.empty()) && (Utils->hooks.find(x->Hook.c_str()) == Utils->hooks.end()))
 481                         return;
 482                 TreeSocket* newsocket = new TreeSocket(Utils, ServerInstance, x->IPAddr,x->Port,false,x->Timeout ? x->Timeout : 10,x->Name.c_str(), x->Bind, x->Hook.empty() ? NULL : Utils->hooks[x->Hook.c_str()]);
 483                 if (newsocket->GetFd() > -1)
 484                 {
 485                         /* Handled automatically on success */
 486                 }
 487                 else
 488                 {
 489                         ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
 490                         delete newsocket;
 491                         Utils->DoFailOver(x);
 492                 }
 493         }
 494         else
 495         {
 496                 try
 497                 {
 498                         bool cached;
 499                         ServernameResolver* snr = new ServernameResolver((Module*)this, Utils, ServerInstance,x->IPAddr, *x, cached, start_type);
 500                         ServerInstance->AddResolver(snr, cached);
 501                 }
 502                 catch (ModuleException& e)
 503                 {
 504                         ServerInstance->SNO->WriteToSnoMask('l',"CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(), e.GetReason());
 505                         Utils->DoFailOver(x);
 506                 }
 507         }
 508 }
 509
 510 void ModuleSpanningTree::AutoConnectServers(time_t curtime)
 511 {
 512         for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 513         {
 514                 if ((x->AutoConnect) && (curtime >= x->NextConnectTime))
 515                 {
 516                         x->NextConnectTime = curtime + x->AutoConnect;
 517                         TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
 518                         if (x->FailOver.length())
 519                         {
 520                                 TreeServer* CheckFailOver = Utils->FindServer(x->FailOver.c_str());
 521                                 if (CheckFailOver)
 522                                 {
 523                                         /* The failover for this server is currently a member of the network.
 524                                          * The failover probably succeeded, where the main link did not.
 525                                          * Don't try the main link until the failover is gone again.
 526                                          */
 527                                         continue;
 528                                 }
 529                         }
 530                         if (!CheckDupe)
 531                         {
 532                                 // an autoconnected server is not connected. Check if its time to connect it
 533                                 ServerInstance->SNO->WriteToSnoMask('l',"AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
 534                                 this->ConnectServer(&(*x));
 535                         }
 536                 }
 537         }
 538 }
 539
 540 int ModuleSpanningTree::HandleVersion(const char** parameters, int pcnt, userrec* user)
 541 {
 542         // we've already checked if pcnt > 0, so this is safe
 543         TreeServer* found = Utils->FindServerMask(parameters[0]);
 544         if (found)
 545         {
 546                 std::string Version = found->GetVersion();
 547                 user->WriteServ("351 %s :%s",user->nick,Version.c_str());
 548                 if (found == Utils->TreeRoot)
 549                 {
 550                         ServerInstance->Config->Send005(user);
 551                 }
 552         }
 553         else
 554         {
 555                 user->WriteServ("402 %s %s :No such server",user->nick,parameters[0]);
 556         }
 557         return 1;
 558 }
 559
 560 int ModuleSpanningTree::HandleConnect(const char** parameters, int pcnt, userrec* user)
 561 {
 562         for (std::vector<Link>::iterator x = Utils->LinkBlocks.begin(); x < Utils->LinkBlocks.end(); x++)
 563         {
 564                 if (ServerInstance->MatchText(x->Name.c_str(),parameters[0]))
 565                 {
 566                         TreeServer* CheckDupe = Utils->FindServer(x->Name.c_str());
 567                         if (!CheckDupe)
 568                         {
 569                                 user->WriteServ("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);
 570                                 ConnectServer(&(*x));
 571                                 return 1;
 572                         }
 573                         else
 574                         {
 575                                 user->WriteServ("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());
 576                                 return 1;
 577                         }
 578                 }
 579         }
 580         user->WriteServ("NOTICE %s :*** CONNECT: No server matching \002%s\002 could be found in the config file.",user->nick,parameters[0]);
 581         return 1;
 582 }
 583
 584 void ModuleSpanningTree::BroadcastTimeSync()
 585 {
 586         if (Utils->MasterTime)
 587         {
 588                 std::deque<std::string> params;
 589                 params.push_back(ConvToStr(ServerInstance->Time(false)));
 590                 params.push_back("FORCE");
 591                 Utils->DoOneToMany(Utils->TreeRoot->GetName(), "TIMESET", params);
 592         }
 593 }
 594
 595 int ModuleSpanningTree::OnStats(char statschar, userrec* user, string_list &results)
 596 {
 597         if ((statschar == 'c') || (statschar == 'n'))
 598         {
 599                 for (unsigned int i = 0; i < Utils->LinkBlocks.size(); i++)
 600                 {
 601                         results.push_back(std::string(ServerInstance->Config->ServerName)+" 213 "+user->nick+" "+statschar+" *@"+(Utils->LinkBlocks[i].HiddenFromStats ? "<hidden>" : Utils->LinkBlocks[i].IPAddr)+" * "+Utils->LinkBlocks[i].Name.c_str()+" "+ConvToStr(Utils->LinkBlocks[i].Port)+" "+(Utils->LinkBlocks[i].Hook.empty() ? "plaintext" : Utils->LinkBlocks[i].Hook)+" "+(Utils->LinkBlocks[i].AutoConnect ? 'a' : '-')+'s');
 602                         if (statschar == 'c')
 603                                 results.push_back(std::string(ServerInstance->Config->ServerName)+" 244 "+user->nick+" H * * "+Utils->LinkBlocks[i].Name.c_str());
 604                 }
 605                 results.push_back(std::string(ServerInstance->Config->ServerName)+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
 606                 ServerInstance->SNO->WriteToSnoMask('t',"%s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
 607                 return 1;
 608         }
 609         return 0;
 610 }
 611
 612 int ModuleSpanningTree::OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated, const std::string &original_line)
 613 {
 614         /* If the command doesnt appear to be valid, we dont want to mess with it. */
 615         if (!validated)
 616                 return 0;
 617
 618         if (command == "CONNECT")
 619         {
 620                 return this->HandleConnect(parameters,pcnt,user);
 621         }
 622         else if (command == "STATS")
 623         {
 624                 return this->HandleStats(parameters,pcnt,user);
 625         }
 626         else if (command == "MOTD")
 627         {
 628                 return this->HandleMotd(parameters,pcnt,user);
 629         }
 630         else if (command == "ADMIN")
 631         {
 632                 return this->HandleAdmin(parameters,pcnt,user);
 633         }
 634         else if (command == "SQUIT")
 635         {
 636                 return this->HandleSquit(parameters,pcnt,user);
 637         }
 638         else if (command == "MAP")
 639         {
 640                 this->HandleMap(parameters,pcnt,user);
 641                 return 1;
 642         }
 643         else if ((command == "TIME") && (pcnt > 0))
 644         {
 645                 return this->HandleTime(parameters,pcnt,user);
 646         }
 647         else if (command == "LUSERS")
 648         {
 649                 this->HandleLusers(parameters,pcnt,user);
 650                 return 1;
 651         }
 652         else if (command == "LINKS")
 653         {
 654                 this->HandleLinks(parameters,pcnt,user);
 655                 return 1;
 656         }
 657         else if (command == "WHOIS")
 658         {
 659                 if (pcnt > 1)
 660                 {
 661                         // remote whois
 662                         return this->HandleRemoteWhois(parameters,pcnt,user);
 663                 }
 664         }
 665         else if ((command == "VERSION") && (pcnt > 0))
 666         {
 667                 this->HandleVersion(parameters,pcnt,user);
 668                 return 1;
 669         }
 670         else if ((command == "MODULES") && (pcnt > 0))
 671         {
 672                 return this->HandleModules(parameters,pcnt,user);
 673         }
 674         return 0;
 675 }
 676
 677 void ModuleSpanningTree::OnPostCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, CmdResult result, const std::string &original_line)
 678 {
 679         if ((result == CMD_SUCCESS) && (ServerInstance->IsValidModuleCommand(command, pcnt, user)))
 680         {
 681                 // this bit of code cleverly routes all module commands
 682                 // to all remote severs *automatically* so that modules
 683                 // can just handle commands locally, without having
 684                 // to have any special provision in place for remote
 685                 // commands and linking protocols.
 686                 std::deque<std::string> params;
 687                 params.clear();
 688                 for (int j = 0; j < pcnt; j++)
 689                 {
 690                         if (strchr(parameters[j],' '))
 691                         {
 692                                 params.push_back(":" + std::string(parameters[j]));
 693                         }
 694                         else
 695                         {
 696                                 params.push_back(std::string(parameters[j]));
 697                         }
 698                 }
 699                 Utils->DoOneToMany(user->nick,command,params);
 700         }
 701 }
 702
 703 void ModuleSpanningTree::OnGetServerDescription(const std::string &servername,std::string &description)
 704 {
 705         TreeServer* s = Utils->FindServer(servername);
 706         if (s)
 707         {
 708                 description = s->GetDesc();
 709         }
 710 }
 711
 712 void ModuleSpanningTree::OnUserInvite(userrec* source,userrec* dest,chanrec* channel)
 713 {
 714         if (IS_LOCAL(source))
 715         {
 716                 std::deque<std::string> params;
 717                 params.push_back(dest->nick);
 718                 params.push_back(channel->name);
 719                 Utils->DoOneToMany(source->nick,"INVITE",params);
 720         }
 721 }
 722
 723 void ModuleSpanningTree::OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic)
 724 {
 725         std::deque<std::string> params;
 726         params.push_back(chan->name);
 727         params.push_back(":"+topic);
 728         Utils->DoOneToMany(user->nick,"TOPIC",params);
 729 }
 730
 731 void ModuleSpanningTree::OnWallops(userrec* user, const std::string &text)
 732 {
 733         if (IS_LOCAL(user))
 734         {
 735                 std::deque<std::string> params;
 736                 params.push_back(":"+text);
 737                 Utils->DoOneToMany(user->nick,"WALLOPS",params);
 738         }
 739 }
 740
 741 void ModuleSpanningTree::OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
 742 {
 743         if (target_type == TYPE_USER)
 744         {
 745                 userrec* d = (userrec*)dest;
 746                 if ((d->GetFd() < 0) && (IS_LOCAL(user)))
 747                 {
 748                         std::deque<std::string> params;
 749                         params.clear();
 750                         params.push_back(d->nick);
 751                         params.push_back(":"+text);
 752                         Utils->DoOneToOne(user->nick,"NOTICE",params,d->server);
 753                 }
 754         }
 755         else if (target_type == TYPE_CHANNEL)
 756         {
 757                 if (IS_LOCAL(user))
 758                 {
 759                         chanrec *c = (chanrec*)dest;
 760                         if (c)
 761                         {
 762                                 std::string cname = c->name;
 763                                 if (status)
 764                                         cname = status + cname;
 765                                 TreeServerList list;
 766                                 Utils->GetListOfServersForChannel(c,list,status,exempt_list);
 767                                 for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
 768                                 {
 769                                         TreeSocket* Sock = i->second->GetSocket();
 770                                         if (Sock)
 771                                                 Sock->WriteLine(":"+std::string(user->nick)+" NOTICE "+cname+" :"+text);
 772                                 }
 773                         }
 774                 }
 775         }
 776         else if (target_type == TYPE_SERVER)
 777         {
 778                 if (IS_LOCAL(user))
 779                 {
 780                         char* target = (char*)dest;
 781                         std::deque<std::string> par;
 782                         par.push_back(target);
 783                         par.push_back(":"+text);
 784                         Utils->DoOneToMany(user->nick,"NOTICE",par);
 785                 }
 786         }
 787 }
 788
 789 void ModuleSpanningTree::OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status, const CUList &exempt_list)
 790 {
 791         if (target_type == TYPE_USER)
 792         {
 793                 // route private messages which are targetted at clients only to the server
 794                 // which needs to receive them
 795                 userrec* d = (userrec*)dest;
 796                 if ((d->GetFd() < 0) && (IS_LOCAL(user)))
 797                 {
 798                         std::deque<std::string> params;
 799                         params.clear();
 800                         params.push_back(d->nick);
 801                         params.push_back(":"+text);
 802                         Utils->DoOneToOne(user->nick,"PRIVMSG",params,d->server);
 803                 }
 804         }
 805         else if (target_type == TYPE_CHANNEL)
 806         {
 807                 if (IS_LOCAL(user))
 808                 {
 809                         chanrec *c = (chanrec*)dest;
 810                         if (c)
 811                         {
 812                                 std::string cname = c->name;
 813                                 if (status)
 814                                         cname = status + cname;
 815                                 TreeServerList list;
 816                                 Utils->GetListOfServersForChannel(c,list,status,exempt_list);
 817                                 for (TreeServerList::iterator i = list.begin(); i != list.end(); i++)
 818                                 {
 819                                         TreeSocket* Sock = i->second->GetSocket();
 820                                         if (Sock)
 821                                                 Sock->WriteLine(":"+std::string(user->nick)+" PRIVMSG "+cname+" :"+text);
 822                                 }
 823                         }
 824                 }
 825         }
 826         else if (target_type == TYPE_SERVER)
 827         {
 828                 if (IS_LOCAL(user))
 829                 {
 830                         char* target = (char*)dest;
 831                         std::deque<std::string> par;
 832                         par.push_back(target);
 833                         par.push_back(":"+text);
 834                         Utils->DoOneToMany(user->nick,"PRIVMSG",par);
 835                 }
 836         }
 837 }
 838
 839 void ModuleSpanningTree::OnBackgroundTimer(time_t curtime)
 840 {
 841         AutoConnectServers(curtime);
 842         DoPingChecks(curtime);
 843 }
 844
 845 void ModuleSpanningTree::OnUserJoin(userrec* user, chanrec* channel)
 846 {
 847         // Only do this for local users
 848         if (IS_LOCAL(user))
 849         {
 850                 if (channel->GetUserCounter() == 1)
 851                 {
 852                         std::deque<std::string> params;
 853                         // set up their permissions and the channel TS with FJOIN.
 854                         // All users are FJOINed now, because a module may specify
 855                         // new joining permissions for the user.
 856                         params.push_back(channel->name);
 857                         params.push_back(ConvToStr(channel->age));
 858                         params.push_back(std::string(channel->GetAllPrefixChars(user))+","+std::string(user->nick));
 859                         Utils->DoOneToMany(ServerInstance->Config->ServerName,"FJOIN",params);
 860                         /* First user in, sync the modes for the channel */
 861                         params.pop_back();
 862                         /* This is safe, all inspircd servers default to +nt */
 863                         params.push_back("+nt");
 864                         Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",params);
 865                 }
 866                 else
 867                 {
 868                         std::deque<std::string> params;
 869                         params.push_back(channel->name);
 870                         params.push_back(ConvToStr(channel->age));
 871                         Utils->DoOneToMany(user->nick,"JOIN",params);
 872                 }
 873         }
 874 }
 875
 876 void ModuleSpanningTree::OnChangeHost(userrec* user, const std::string &newhost)
 877 {
 878         // only occurs for local clients
 879         if (user->registered != REG_ALL)
 880                 return;
 881         std::deque<std::string> params;
 882         params.push_back(newhost);
 883         Utils->DoOneToMany(user->nick,"FHOST",params);
 884 }
 885
 886 void ModuleSpanningTree::OnChangeName(userrec* user, const std::string &gecos)
 887 {
 888         // only occurs for local clients
 889         if (user->registered != REG_ALL)
 890                 return;
 891         std::deque<std::string> params;
 892         params.push_back(gecos);
 893         Utils->DoOneToMany(user->nick,"FNAME",params);
 894 }
 895
 896 void ModuleSpanningTree::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage)
 897 {
 898         if (IS_LOCAL(user))
 899         {
 900                 std::deque<std::string> params;
 901                 params.push_back(channel->name);
 902                 if (partmessage != "")
 903                         params.push_back(":"+partmessage);
 904                 Utils->DoOneToMany(user->nick,"PART",params);
 905         }
 906 }
 907
 908 void ModuleSpanningTree::OnUserConnect(userrec* user)
 909 {
 910         char agestr[MAXBUF];
 911         if (IS_LOCAL(user))
 912         {
 913                 std::deque<std::string> params;
 914                 snprintf(agestr,MAXBUF,"%lu",(unsigned long)user->age);
 915                 params.push_back(agestr);
 916                 params.push_back(user->nick);
 917                 params.push_back(user->host);
 918                 params.push_back(user->dhost);
 919                 params.push_back(user->ident);
 920                 params.push_back("+"+std::string(user->FormatModes()));
 921                 params.push_back(user->GetIPString());
 922                 params.push_back(":"+std::string(user->fullname));
 923                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"NICK",params);
 924                 // User is Local, change needs to be reflected!
 925                 TreeServer* SourceServer = Utils->FindServer(user->server);
 926                 if (SourceServer)
 927                 {
 928                         SourceServer->AddUserCount();
 929                 }
 930         }
 931 }
 932
 933 void ModuleSpanningTree::OnUserQuit(userrec* user, const std::string &reason, const std::string &oper_message)
 934 {
 935         if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
 936         {
 937                 std::deque<std::string> params;
 938
 939                 if (oper_message != reason)
 940                 {
 941                         params.push_back(":"+oper_message);
 942                         Utils->DoOneToMany(user->nick,"OPERQUIT",params);
 943                 }
 944                 params.clear();
 945                 params.push_back(":"+reason);
 946                 Utils->DoOneToMany(user->nick,"QUIT",params);
 947         }
 948         // Regardless, We need to modify the user Counts..
 949         TreeServer* SourceServer = Utils->FindServer(user->server);
 950         if (SourceServer)
 951         {
 952                 SourceServer->DelUserCount();
 953         }
 954 }
 955
 956 void ModuleSpanningTree::OnUserPostNick(userrec* user, const std::string &oldnick)
 957 {
 958         if (IS_LOCAL(user))
 959         {
 960                 std::deque<std::string> params;
 961                 params.push_back(user->nick);
 962                 Utils->DoOneToMany(oldnick,"NICK",params);
 963         }
 964 }
 965
 966 void ModuleSpanningTree::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason)
 967 {
 968         if ((source) && (IS_LOCAL(source)))
 969         {
 970                 std::deque<std::string> params;
 971                 params.push_back(chan->name);
 972                 params.push_back(user->nick);
 973                 params.push_back(":"+reason);
 974                 Utils->DoOneToMany(source->nick,"KICK",params);
 975         }
 976         else if (!source)
 977         {
 978                 std::deque<std::string> params;
 979                 params.push_back(chan->name);
 980                 params.push_back(user->nick);
 981                 params.push_back(":"+reason);
 982                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"KICK",params);
 983         }
 984 }
 985
 986 void ModuleSpanningTree::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason)
 987 {
 988         std::deque<std::string> params;
 989         params.push_back(dest->nick);
 990         params.push_back(":"+reason);
 991         Utils->DoOneToMany(source->nick,"KILL",params);
 992 }
 993
 994 void ModuleSpanningTree::OnRehash(userrec* user, const std::string &parameter)
 995 {
 996         if (parameter != "")
 997         {
 998                 std::deque<std::string> params;
 999                 params.push_back(parameter);
1000                 Utils->DoOneToMany(user ? user->nick : ServerInstance->Config->ServerName, "REHASH", params);
1001                 // check for self
1002                 if (ServerInstance->MatchText(ServerInstance->Config->ServerName,parameter))
1003                 {
1004                         ServerInstance->WriteOpers("*** Remote rehash initiated locally by \002%s\002", user ? user->nick : ServerInstance->Config->ServerName);
1005                         ServerInstance->RehashServer();
1006                 }
1007         }
1008         Utils->ReadConfiguration(false);
1009         InitializeDisabledCommands(ServerInstance->Config->DisabledCommands, ServerInstance);
1010 }
1011
1012 // note: the protocol does not allow direct umode +o except
1013 // via NICK with 8 params. sending OPERTYPE infers +o modechange
1014 // locally.
1015 void ModuleSpanningTree::OnOper(userrec* user, const std::string &opertype)
1016 {
1017         if (IS_LOCAL(user))
1018         {
1019                 std::deque<std::string> params;
1020                 params.push_back(opertype);
1021                 Utils->DoOneToMany(user->nick,"OPERTYPE",params);
1022         }
1023 }
1024
1025 void ModuleSpanningTree::OnLine(userrec* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason)
1026 {
1027         if (!source)
1028         {
1029                 /* Server-set lines */
1030                 char data[MAXBUF];
1031                 snprintf(data,MAXBUF,"%c %s %s %lu %lu :%s", linetype, host.c_str(), ServerInstance->Config->ServerName, (unsigned long)ServerInstance->Time(false),
1032                                 (unsigned long)duration, reason.c_str());
1033                 std::deque<std::string> params;
1034                 params.push_back(data);
1035                 Utils->DoOneToMany(ServerInstance->Config->ServerName, "ADDLINE", params);
1036         }
1037         else
1038         {
1039                 if (IS_LOCAL(source))
1040                 {
1041                         char type[8];
1042                         snprintf(type,8,"%cLINE",linetype);
1043                         std::string stype = type;
1044                         if (adding)
1045                         {
1046                                 char sduration[MAXBUF];
1047                                 snprintf(sduration,MAXBUF,"%ld",duration);
1048                                 std::deque<std::string> params;
1049                                 params.push_back(host);
1050                                 params.push_back(sduration);
1051                                 params.push_back(":"+reason);
1052                                 Utils->DoOneToMany(source->nick,stype,params);
1053                         }
1054                         else
1055                         {
1056                                 std::deque<std::string> params;
1057                                 params.push_back(host);
1058                                 Utils->DoOneToMany(source->nick,stype,params);
1059                         }
1060                 }
1061         }
1062 }
1063
1064 void ModuleSpanningTree::OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask)
1065 {
1066         OnLine(source,hostmask,true,'G',duration,reason);
1067 }
1068
1069 void ModuleSpanningTree::OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask)
1070 {
1071         OnLine(source,ipmask,true,'Z',duration,reason);
1072 }
1073
1074 void ModuleSpanningTree::OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask)
1075 {
1076         OnLine(source,nickmask,true,'Q',duration,reason);
1077 }
1078
1079 void ModuleSpanningTree::OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask)
1080 {
1081         OnLine(source,hostmask,true,'E',duration,reason);
1082 }
1083
1084 void ModuleSpanningTree::OnDelGLine(userrec* source, const std::string &hostmask)
1085 {
1086         OnLine(source,hostmask,false,'G',0,"");
1087 }
1088
1089 void ModuleSpanningTree::OnDelZLine(userrec* source, const std::string &ipmask)
1090 {
1091         OnLine(source,ipmask,false,'Z',0,"");
1092 }
1093
1094 void ModuleSpanningTree::OnDelQLine(userrec* source, const std::string &nickmask)
1095 {
1096         OnLine(source,nickmask,false,'Q',0,"");
1097 }
1098
1099 void ModuleSpanningTree::OnDelELine(userrec* source, const std::string &hostmask)
1100 {
1101         OnLine(source,hostmask,false,'E',0,"");
1102 }
1103
1104 void ModuleSpanningTree::OnMode(userrec* user, void* dest, int target_type, const std::string &text)
1105 {
1106         if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
1107         {
1108                 std::deque<std::string> params;
1109                 std::string command;
1110
1111                 if (target_type == TYPE_USER)
1112                 {
1113                         userrec* u = (userrec*)dest;
1114                         params.push_back(u->nick);
1115                         params.push_back(text);
1116                         command = "MODE";
1117                 }
1118                 else
1119                 {
1120                         chanrec* c = (chanrec*)dest;
1121                         params.push_back(c->name);
1122                         params.push_back(ConvToStr(c->age));
1123                         params.push_back(text);
1124                         command = "FMODE";
1125                 }
1126                 Utils->DoOneToMany(user->nick, command, params);
1127         }
1128 }
1129
1130 void ModuleSpanningTree::OnSetAway(userrec* user)
1131 {
1132         if (IS_LOCAL(user))
1133         {
1134                 std::deque<std::string> params;
1135                 params.push_back(":"+std::string(user->awaymsg));
1136                 Utils->DoOneToMany(user->nick,"AWAY",params);
1137         }
1138 }
1139
1140 void ModuleSpanningTree::OnCancelAway(userrec* user)
1141 {
1142         if (IS_LOCAL(user))
1143         {
1144                 std::deque<std::string> params;
1145                 params.clear();
1146                 Utils->DoOneToMany(user->nick,"AWAY",params);
1147         }
1148 }
1149
1150 void ModuleSpanningTree::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline)
1151 {
1152         TreeSocket* s = (TreeSocket*)opaque;
1153         if (target)
1154         {
1155                 if (target_type == TYPE_USER)
1156                 {
1157                         userrec* u = (userrec*)target;
1158                         s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+u->nick+" "+ConvToStr(u->age)+" "+modeline);
1159                 }
1160                 else
1161                 {
1162                         chanrec* c = (chanrec*)target;
1163                         s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" FMODE "+c->name+" "+ConvToStr(c->age)+" "+modeline);
1164                 }
1165         }
1166 }
1167
1168 void ModuleSpanningTree::ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata)
1169 {
1170         TreeSocket* s = (TreeSocket*)opaque;
1171         if (target)
1172         {
1173                 if (target_type == TYPE_USER)
1174                 {
1175                         userrec* u = (userrec*)target;
1176                         s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+u->nick+" "+extname+" :"+extdata);
1177                 }
1178                 else if (target_type == TYPE_CHANNEL)
1179                 {
1180                         chanrec* c = (chanrec*)target;
1181                         s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA "+c->name+" "+extname+" :"+extdata);
1182                 }
1183         }
1184         if (target_type == TYPE_OTHER)
1185         {
1186                 s->WriteLine(std::string(":")+ServerInstance->Config->ServerName+" METADATA * "+extname+" :"+extdata);
1187         }
1188 }
1189
1190 void ModuleSpanningTree::OnEvent(Event* event)
1191 {
1192         std::deque<std::string>* params = (std::deque<std::string>*)event->GetData();
1193         if (event->GetEventID() == "send_metadata")
1194         {
1195                 if (params->size() < 3)
1196                         return;
1197                 (*params)[2] = ":" + (*params)[2];
1198                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"METADATA",*params);
1199         }
1200         else if (event->GetEventID() == "send_topic")
1201         {
1202                 if (params->size() < 2)
1203                         return;
1204                 (*params)[1] = ":" + (*params)[1];
1205                 params->insert(params->begin() + 1,ServerInstance->Config->ServerName);
1206                 params->insert(params->begin() + 1,ConvToStr(ServerInstance->Time(true)));
1207                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"FTOPIC",*params);
1208         }
1209         else if (event->GetEventID() == "send_mode")
1210         {
1211                 if (params->size() < 2)
1212                         return;
1213                 // Insert the TS value of the object, either userrec or chanrec
1214                 time_t ourTS = 0;
1215                 userrec* a = ServerInstance->FindNick((*params)[0]);
1216                 if (a)
1217                 {
1218                         ourTS = a->age;
1219                 }
1220                 else
1221                 {
1222                         chanrec* a = ServerInstance->FindChan((*params)[0]);
1223                         if (a)
1224                         {
1225                                 ourTS = a->age;
1226                         }
1227                 }
1228                 params->insert(params->begin() + 1,ConvToStr(ourTS));
1229                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"FMODE",*params);
1230         }
1231         else if (event->GetEventID() == "send_mode_explicit")
1232         {
1233                 if (params->size() < 2)
1234                         return;
1235                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODE",*params);
1236         }
1237         else if (event->GetEventID() == "send_opers")
1238         {
1239                 if (params->size() < 1)
1240                         return;
1241                 (*params)[0] = ":" + (*params)[0];
1242                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"OPERNOTICE",*params);
1243         }
1244         else if (event->GetEventID() == "send_modeset")
1245         {
1246                 if (params->size() < 2)
1247                         return;
1248                 (*params)[1] = ":" + (*params)[1];
1249                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"MODENOTICE",*params);
1250         }
1251         else if (event->GetEventID() == "send_snoset")
1252         {
1253                 if (params->size() < 2)
1254                         return;
1255                 (*params)[1] = ":" + (*params)[1];
1256                 Utils->DoOneToMany(ServerInstance->Config->ServerName,"SNONOTICE",*params);
1257         }
1258         else if (event->GetEventID() == "send_push")
1259         {
1260                 if (params->size() < 2)
1261                         return;
1262
1263                 userrec *a = ServerInstance->FindNick((*params)[0]);
1264
1265                 if (!a)
1266                         return;
1267
1268                 (*params)[1] = ":" + (*params)[1];
1269                 Utils->DoOneToOne(ServerInstance->Config->ServerName, "PUSH", *params, a->server);
1270         }
1271 }
1272
1273 ModuleSpanningTree::~ModuleSpanningTree()
1274 {
1275         /* This will also free the listeners */
1276         delete Utils;
1277         if (SyncTimer)
1278                 ServerInstance->Timers->DelTimer(SyncTimer);
1279
1280         ServerInstance->DoneWithInterface("InspSocketHook");
1281 }
1282
1283 Version ModuleSpanningTree::GetVersion()
1284 {
1285         return Version(1,1,0,2,VF_VENDOR,API_VERSION);
1286 }
1287
1288 void ModuleSpanningTree::Implements(char* List)
1289 {
1290         List[I_OnPreCommand] = List[I_OnGetServerDescription] = List[I_OnUserInvite] = List[I_OnPostLocalTopicChange] = 1;
1291         List[I_OnWallops] = List[I_OnUserNotice] = List[I_OnUserMessage] = List[I_OnBackgroundTimer] = 1;
1292         List[I_OnUserJoin] = List[I_OnChangeHost] = List[I_OnChangeName] = List[I_OnUserPart] = List[I_OnUserConnect] = 1;
1293         List[I_OnUserQuit] = List[I_OnUserPostNick] = List[I_OnUserKick] = List[I_OnRemoteKill] = List[I_OnRehash] = 1;
1294         List[I_OnOper] = List[I_OnAddGLine] = List[I_OnAddZLine] = List[I_OnAddQLine] = List[I_OnAddELine] = 1;
1295         List[I_OnDelGLine] = List[I_OnDelZLine] = List[I_OnDelQLine] = List[I_OnDelELine] = List[I_ProtoSendMode] = List[I_OnMode] = 1;
1296         List[I_OnStats] = List[I_ProtoSendMetaData] = List[I_OnEvent] = List[I_OnSetAway] = List[I_OnCancelAway] = List[I_OnPostCommand] = 1;
1297 }
1298
1299 /* It is IMPORTANT that m_spanningtree is the last module in the chain
1300  * so that any activity it sees is FINAL, e.g. we arent going to send out
1301  * a NICK message before m_cloaking has finished putting the +x on the user,
1302  * etc etc.
1303  * Therefore, we return PRIORITY_LAST to make sure we end up at the END of
1304  * the module call queue.
1305  */
1306 Priority ModuleSpanningTree::Prioritize()
1307 {
1308         return PRIORITY_LAST;
1309 }
1310
1311 class ModuleSpanningTreeFactory : public ModuleFactory
1312 {
1313  public:
1314         ModuleSpanningTreeFactory()
1315         {
1316         }
1317
1318         ~ModuleSpanningTreeFactory()
1319         {
1320         }
1321
1322         virtual Module * CreateModule(InspIRCd* Me)
1323         {
1324                 return new ModuleSpanningTree(Me);
1325         }
1326
1327 };
1328
1329
1330 extern "C" void * init_module( void )
1331 {
1332         return new ModuleSpanningTreeFactory;
1333 }