src/modules/m_spanningtree/utils.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2010 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include "socket.h"
  16 #include "xline.h"
  17 #include "socketengine.h"
  18
  19 #include "main.h"
  20 #include "utils.h"
  21 #include "treeserver.h"
  22 #include "link.h"
  23 #include "treesocket.h"
  24 #include "resolvers.h"
  25
  26 /* Create server sockets off a listener. */
  27 ModResult ModuleSpanningTree::OnAcceptConnection(int newsock, ListenSocket* from, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* server)
  28 {
  29         if (from->bind_tag->getString("type") != "servers")
  30                 return MOD_RES_PASSTHRU;
  31
  32         std::string incomingip = client->addr();
  33
  34         for (std::vector<std::string>::iterator i = Utils->ValidIPs.begin(); i != Utils->ValidIPs.end(); i++)
  35         {
  36                 if (*i == "*" || *i == incomingip || irc::sockets::cidr_mask(*i).match(*client))
  37                 {
  38                         /* we don't need to do anything with the pointer, creating it stores it in the necessary places */
  39                         new TreeSocket(Utils, newsock, from, client, server);
  40                         return MOD_RES_ALLOW;
  41                 }
  42         }
  43         ServerInstance->SNO->WriteToSnoMask('l', "Server connection from %s denied (no link blocks with that IP address)", incomingip.c_str());
  44         return MOD_RES_DENY;
  45 }
  46
  47 /** Yay for fast searches!
  48  * This is hundreds of times faster than recursion
  49  * or even scanning a linked list, especially when
  50  * there are more than a few servers to deal with.
  51  * (read as: lots).
  52  */
  53 TreeServer* SpanningTreeUtilities::FindServer(const std::string &ServerName)
  54 {
  55         if (ServerInstance->IsSID(ServerName))
  56                 return this->FindServerID(ServerName);
  57
  58         server_hash::iterator iter = serverlist.find(ServerName.c_str());
  59         if (iter != serverlist.end())
  60         {
  61                 return iter->second;
  62         }
  63         else
  64         {
  65                 return NULL;
  66         }
  67 }
  68
  69 /** Returns the locally connected server we must route a
  70  * message through to reach server 'ServerName'. This
  71  * only applies to one-to-one and not one-to-many routing.
  72  * See the comments for the constructor of TreeServer
  73  * for more details.
  74  */
  75 TreeServer* SpanningTreeUtilities::BestRouteTo(const std::string &ServerName)
  76 {
  77         if (ServerName.c_str() == TreeRoot->GetName() || ServerName == ServerInstance->Config->GetSID())
  78                 return NULL;
  79         TreeServer* Found = FindServer(ServerName);
  80         if (Found)
  81         {
  82                 return Found->GetRoute();
  83         }
  84         else
  85         {
  86                 // Cheat a bit. This allows for (better) working versions of routing commands with nick based prefixes, without hassle
  87                 User *u = ServerInstance->FindNick(ServerName);
  88                 if (u)
  89                 {
  90                         Found = FindServer(u->server);
  91                         if (Found)
  92                                 return Found->GetRoute();
  93                 }
  94
  95                 return NULL;
  96         }
  97 }
  98
  99 /** Find the first server matching a given glob mask.
 100  * Theres no find-using-glob method of hash_map [awwww :-(]
 101  * so instead, we iterate over the list using an iterator
 102  * and match each one until we get a hit. Yes its slow,
 103  * deal with it.
 104  */
 105 TreeServer* SpanningTreeUtilities::FindServerMask(const std::string &ServerName)
 106 {
 107         for (server_hash::iterator i = serverlist.begin(); i != serverlist.end(); i++)
 108         {
 109                 if (InspIRCd::Match(i->first,ServerName))
 110                         return i->second;
 111         }
 112         return NULL;
 113 }
 114
 115 TreeServer* SpanningTreeUtilities::FindServerID(const std::string &id)
 116 {
 117         server_hash::iterator iter = sidlist.find(id);
 118         if (iter != sidlist.end())
 119                 return iter->second;
 120         else
 121                 return NULL;
 122 }
 123
 124 /* A convenient wrapper that returns true if a server exists */
 125 bool SpanningTreeUtilities::IsServer(const std::string &ServerName)
 126 {
 127         return (FindServer(ServerName) != NULL);
 128 }
 129
 130 SpanningTreeUtilities::SpanningTreeUtilities(ModuleSpanningTree* C) : Creator(C)
 131 {
 132         ServerInstance->Logs->Log("m_spanningtree",DEBUG,"***** Using SID for hash: %s *****", ServerInstance->Config->GetSID().c_str());
 133
 134         this->TreeRoot = new TreeServer(this, ServerInstance->Config->ServerName, ServerInstance->Config->ServerDesc, ServerInstance->Config->GetSID());
 135         this->ReadConfiguration();
 136 }
 137
 138 CullResult SpanningTreeUtilities::cull()
 139 {
 140         while (TreeRoot->ChildCount())
 141         {
 142                 TreeServer* child_server = TreeRoot->GetChild(0);
 143                 if (child_server)
 144                 {
 145                         TreeSocket* sock = child_server->GetSocket();
 146                         sock->Close();
 147                 }
 148         }
 149
 150         for(std::map<TreeSocket*, std::pair<std::string, int> >::iterator i = timeoutlist.begin(); i != timeoutlist.end(); ++i)
 151         {
 152                 TreeSocket* s = i->first;
 153                 s->Close();
 154         }
 155         TreeRoot->cull();
 156
 157         return classbase::cull();
 158 }
 159
 160 SpanningTreeUtilities::~SpanningTreeUtilities()
 161 {
 162         delete TreeRoot;
 163 }
 164
 165 void SpanningTreeUtilities::AddThisServer(TreeServer* server, TreeServerList &list)
 166 {
 167         if (list.find(server) == list.end())
 168                 list[server] = server;
 169 }
 170
 171 /* returns a list of DIRECT servernames for a specific channel */
 172 void SpanningTreeUtilities::GetListOfServersForChannel(Channel* c, TreeServerList &list, char status, const CUList &exempt_list)
 173 {
 174         const UserMembList *ulist = c->GetUsers();
 175
 176         for (UserMembCIter i = ulist->begin(); i != ulist->end(); i++)
 177         {
 178                 if (IS_LOCAL(i->first))
 179                         continue;
 180
 181                 if (status && !strchr(c->GetAllPrefixChars(i->first), status))
 182                         continue;
 183
 184                 if (exempt_list.find(i->first) == exempt_list.end())
 185                 {
 186                         TreeServer* best = this->BestRouteTo(i->first->server);
 187                         if (best)
 188                                 AddThisServer(best,list);
 189                 }
 190         }
 191         return;
 192 }
 193
 194 bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, parameterlist &params)
 195 {
 196         TreeServer* omitroute = this->BestRouteTo(omit);
 197         unsigned int items =this->TreeRoot->ChildCount();
 198         for (unsigned int x = 0; x < items; x++)
 199         {
 200                 TreeServer* Route = this->TreeRoot->GetChild(x);
 201                 if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
 202                 {
 203                         TreeSocket* Sock = Route->GetSocket();
 204                         if (Sock)
 205                                 Sock->WriteLine(data);
 206                 }
 207         }
 208         return true;
 209 }
 210
 211 bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, parameterlist &params, std::string omit)
 212 {
 213         TreeServer* omitroute = this->BestRouteTo(omit);
 214         std::string FullLine = ":" + prefix + " " + command;
 215         unsigned int words = params.size();
 216         for (unsigned int x = 0; x < words; x++)
 217         {
 218                 FullLine = FullLine + " " + params[x];
 219         }
 220         unsigned int items = this->TreeRoot->ChildCount();
 221         for (unsigned int x = 0; x < items; x++)
 222         {
 223                 TreeServer* Route = this->TreeRoot->GetChild(x);
 224                 // Send the line IF:
 225                 // The route has a socket (its a direct connection)
 226                 // The route isnt the one to be omitted
 227                 // The route isnt the path to the one to be omitted
 228                 if ((Route) && (Route->GetSocket()) && (Route->GetName() != omit) && (omitroute != Route))
 229                 {
 230                         TreeSocket* Sock = Route->GetSocket();
 231                         if (Sock)
 232                                 Sock->WriteLine(FullLine);
 233                 }
 234         }
 235         return true;
 236 }
 237
 238 bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, parameterlist &params)
 239 {
 240         std::string FullLine = ":" + prefix + " " + command;
 241         unsigned int words = params.size();
 242         for (unsigned int x = 0; x < words; x++)
 243         {
 244                 FullLine = FullLine + " " + params[x];
 245         }
 246         unsigned int items = this->TreeRoot->ChildCount();
 247         for (unsigned int x = 0; x < items; x++)
 248         {
 249                 TreeServer* Route = this->TreeRoot->GetChild(x);
 250                 if (Route && Route->GetSocket())
 251                 {
 252                         TreeSocket* Sock = Route->GetSocket();
 253                         if (Sock)
 254                                 Sock->WriteLine(FullLine);
 255                 }
 256         }
 257         return true;
 258 }
 259
 260 bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, parameterlist &params)
 261 {
 262         std::string spfx = prefix;
 263         std::string scmd = command;
 264         return this->DoOneToMany(spfx, scmd, params);
 265 }
 266
 267 bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, parameterlist &params, std::string omit)
 268 {
 269         std::string spfx = prefix;
 270         std::string scmd = command;
 271         return this->DoOneToAllButSender(spfx, scmd, params, omit);
 272 }
 273
 274 bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, parameterlist &params, std::string target)
 275 {
 276         TreeServer* Route = this->BestRouteTo(target);
 277         if (Route)
 278         {
 279                 std::string FullLine = ":" + prefix + " " + command;
 280                 unsigned int words = params.size();
 281                 for (unsigned int x = 0; x < words; x++)
 282                 {
 283                         FullLine = FullLine + " " + params[x];
 284                 }
 285                 if (Route && Route->GetSocket())
 286                 {
 287                         TreeSocket* Sock = Route->GetSocket();
 288                         if (Sock)
 289                                 Sock->WriteLine(FullLine);
 290                 }
 291                 return true;
 292         }
 293         else
 294         {
 295                 return false;
 296         }
 297 }
 298
 299 void SpanningTreeUtilities::RefreshIPCache()
 300 {
 301         ValidIPs.clear();
 302         for (std::vector<reference<Link> >::iterator i = LinkBlocks.begin(); i != LinkBlocks.end(); ++i)
 303         {
 304                 Link* L = *i;
 305                 if (L->IPAddr.empty() || L->RecvPass.empty() || L->SendPass.empty() || L->Name.empty() || !L->Port)
 306                 {
 307                         if (L->Name.empty())
 308                         {
 309                                 ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"m_spanningtree: Ignoring a malformed link block (all link blocks require a name!)");
 310                         }
 311                         else
 312                         {
 313                                 ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"m_spanningtree: Ignoring a link block missing recvpass, sendpass, port or ipaddr.");
 314                         }
 315
 316                         /* Invalid link block */
 317                         continue;
 318                 }
 319
 320                 if (L->AllowMask.length())
 321                         ValidIPs.push_back(L->AllowMask);
 322
 323                 irc::sockets::sockaddrs dummy;
 324                 bool ipvalid = irc::sockets::aptosa(L->IPAddr, L->Port, dummy);
 325                 if (ipvalid)
 326                         ValidIPs.push_back(L->IPAddr);
 327                 else
 328                 {
 329                         try
 330                         {
 331                                 bool cached;
 332                                 SecurityIPResolver* sr = new SecurityIPResolver(Creator, this, L->IPAddr, L, cached, DNS_QUERY_AAAA);
 333                                 ServerInstance->AddResolver(sr, cached);
 334                         }
 335                         catch (...)
 336                         {
 337                         }
 338                 }
 339         }
 340 }
 341
 342 void SpanningTreeUtilities::ReadConfiguration()
 343 {
 344         ConfigReader Conf;
 345
 346         FlatLinks = Conf.ReadFlag("security","flatlinks",0);
 347         HideULines = Conf.ReadFlag("security","hideulines",0);
 348         AnnounceTSChange = Conf.ReadFlag("options","announcets",0);
 349         AllowOptCommon = Conf.ReadFlag("options", "allowmismatch", 0);
 350         ChallengeResponse = !Conf.ReadFlag("security", "disablehmac", 0);
 351         quiet_bursts = Conf.ReadFlag("performance", "quietbursts", 0);
 352         PingWarnTime = Conf.ReadInteger("options", "pingwarning", 0, true);
 353         PingFreq = Conf.ReadInteger("options", "serverpingfreq", 0, true);
 354
 355         if (PingFreq == 0)
 356                 PingFreq = 60;
 357
 358         if (PingWarnTime < 0 || PingWarnTime > PingFreq - 1)
 359                 PingWarnTime = 0;
 360
 361         AutoconnectBlocks.clear();
 362         LinkBlocks.clear();
 363         ValidIPs.clear();
 364         ConfigTagList tags = ServerInstance->Config->ConfTags("link");
 365         for(ConfigIter i = tags.first; i != tags.second; ++i)
 366         {
 367                 ConfigTag* tag = i->second;
 368                 reference<Link> L = new Link(tag);
 369                 L->Name = tag->getString("name").c_str();
 370                 L->AllowMask = tag->getString("allowmask");
 371                 L->IPAddr = tag->getString("ipaddr");
 372                 L->Port = tag->getInt("port");
 373                 L->SendPass = tag->getString("sendpass", tag->getString("password"));
 374                 L->RecvPass = tag->getString("recvpass", tag->getString("password"));
 375                 L->Fingerprint = tag->getString("fingerprint");
 376                 L->HiddenFromStats = tag->getBool("statshidden");
 377                 L->Timeout = tag->getInt("timeout");
 378                 L->Hook = tag->getString("ssl");
 379                 L->Bind = tag->getString("bind");
 380                 L->Hidden = tag->getBool("hidden");
 381
 382                 if (L->Name.find('.') == std::string::npos)
 383                         throw CoreException("The link name '"+assign(L->Name)+"' is invalid and must contain at least one '.' character");
 384
 385                 if (L->Name.length() > 64)
 386                         throw CoreException("The link name '"+assign(L->Name)+"' is longer than 64 characters!");
 387
 388                 if (L->Fingerprint.find(':') != std::string::npos)
 389                 {
 390                         std::string tmp = L->Fingerprint;
 391                         L->Fingerprint.clear();
 392                         for(unsigned int j=0; j < tmp.length(); j++)
 393                                 if (tmp[j] != ':')
 394                                         L->Fingerprint.push_back(tmp[j]);
 395                 }
 396
 397                 if ((!L->IPAddr.empty()) && (!L->RecvPass.empty()) && (!L->SendPass.empty()) && (!L->Name.empty()) && (L->Port))
 398                 {
 399                         ValidIPs.push_back(L->IPAddr);
 400                 }
 401                 else
 402                 {
 403                         if (L->IPAddr.empty())
 404                         {
 405                                 L->IPAddr = "*";
 406                                 ValidIPs.push_back("*");
 407                                 ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"Configuration warning: Link block " + assign(L->Name) + " has no IP defined! This will allow any IP to connect as this server, and MAY not be what you want.");
 408                         }
 409
 410                         if (L->RecvPass.empty())
 411                         {
 412                                 throw CoreException("Invalid configuration for server '"+assign(L->Name)+"', recvpass not defined!");
 413                         }
 414
 415                         if (L->SendPass.empty())
 416                         {
 417                                 throw CoreException("Invalid configuration for server '"+assign(L->Name)+"', sendpass not defined!");
 418                         }
 419
 420                         if (L->Name.empty())
 421                         {
 422                                 throw CoreException("Invalid configuration, link tag without a name! IP address: "+L->IPAddr);
 423                         }
 424
 425                         if (!L->Port)
 426                         {
 427                                 ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"Configuration warning: Link block " + assign(L->Name) + " has no port defined, you will not be able to /connect it.");
 428                         }
 429                 }
 430
 431                 LinkBlocks.push_back(L);
 432         }
 433
 434         tags = ServerInstance->Config->ConfTags("autoconnect");
 435         for(ConfigIter i = tags.first; i != tags.second; ++i)
 436         {
 437                 ConfigTag* tag = i->second;
 438                 reference<Autoconnect> A = new Autoconnect(tag);
 439                 A->Period = tag->getInt("period");
 440                 A->NextConnectTime = ServerInstance->Time() + A->Period;
 441                 A->position = -1;
 442                 irc::spacesepstream ss(tag->getString("server"));
 443                 std::string server;
 444                 while (ss.GetToken(server))
 445                 {
 446                         A->servers.push_back(server);
 447                 }
 448
 449                 if (A->Period <= 0)
 450                 {
 451                         throw CoreException("Invalid configuration for autoconnect, period not a positive integer!");
 452                 }
 453
 454                 if (A->servers.empty())
 455                 {
 456                         throw CoreException("Invalid configuration for autoconnect, server cannot be empty!");
 457                 }
 458
 459                 AutoconnectBlocks.push_back(A);
 460         }
 461
 462         RefreshIPCache();
 463 }
 464
 465 Link* SpanningTreeUtilities::FindLink(const std::string& name)
 466 {
 467         for (std::vector<reference<Link> >::iterator i = LinkBlocks.begin(); i != LinkBlocks.end(); ++i)
 468         {
 469                 Link* x = *i;
 470                 if (InspIRCd::Match(x->Name.c_str(), name.c_str()))
 471                 {
 472                         return x;
 473                 }
 474         }
 475         return NULL;
 476 }