src/modules/m_spanningtree/protocolinterface.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2008 Craig Edwards <craigedwards@brainbox.cc>
   6  *
   7  * This file is part of InspIRCd.  InspIRCd is free software: you can
   8  * redistribute it and/or modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation, version 2.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include "inspircd.h"
  22 #include "utils.h"
  23 #include "treeserver.h"
  24 #include "protocolinterface.h"
  25
  26 /*
  27  * For documentation on this class, see include/protocol.h.
  28  */
  29
  30 void SpanningTreeProtocolInterface::GetServerList(ProtoServerList &sl)
  31 {
  32         sl.clear();
  33         for (server_hash::iterator i = Utils->serverlist.begin(); i != Utils->serverlist.end(); i++)
  34         {
  35                 ProtoServer ps;
  36                 ps.servername = i->second->GetName();
  37                 TreeServer* s = i->second->GetParent();
  38                 ps.parentname = s ? s->GetName() : "";
  39                 ps.usercount = i->second->UserCount;
  40                 ps.opercount = i->second->OperCount;
  41                 ps.gecos = i->second->GetDesc();
  42                 ps.latencyms = i->second->rtt;
  43                 sl.push_back(ps);
  44         }
  45 }
  46
  47 bool SpanningTreeProtocolInterface::SendEncapsulatedData(const parameterlist &encap)
  48 {
  49         if (encap[0].find_first_of("*?") != std::string::npos)
  50         {
  51                 Utils->DoOneToMany(ServerInstance->Config->GetSID(), "ENCAP", encap);
  52                 return true;
  53         }
  54         return Utils->DoOneToOne(ServerInstance->Config->GetSID(), "ENCAP", encap, encap[0]);
  55 }
  56
  57 void SpanningTreeProtocolInterface::SendMetaData(Extensible* target, const std::string &key, const std::string &data)
  58 {
  59         parameterlist params;
  60
  61         User* u = dynamic_cast<User*>(target);
  62         Channel* c = dynamic_cast<Channel*>(target);
  63         if (u)
  64                 params.push_back(u->uuid);
  65         else if (c)
  66         {
  67                 params.push_back(c->name);
  68                 params.push_back(ConvToStr(c->age));
  69         }
  70         else
  71                 params.push_back("*");
  72
  73         params.push_back(key);
  74         params.push_back(":" + data);
  75
  76         Utils->DoOneToMany(ServerInstance->Config->GetSID(),"METADATA",params);
  77 }
  78
  79 void SpanningTreeProtocolInterface::SendTopic(Channel* channel, std::string &topic)
  80 {
  81         parameterlist params;
  82
  83         params.push_back(channel->name);
  84         params.push_back(ConvToStr(channel->age));
  85         params.push_back(ConvToStr(ServerInstance->Time()));
  86         params.push_back(ServerInstance->Config->ServerName);
  87         params.push_back(":" + topic);
  88
  89         Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC", params);
  90 }
  91
  92 void SpanningTreeProtocolInterface::SendMode(const std::string &target, const parameterlist &modedata, const std::vector<TranslateType> &translate)
  93 {
  94         if (modedata.empty())
  95                 return;
  96
  97         std::string outdata;
  98         ServerInstance->Parser->TranslateUIDs(translate, modedata, outdata);
  99
 100         std::string uidtarget;
 101         ServerInstance->Parser->TranslateUIDs(TR_NICK, target, uidtarget);
 102
 103         parameterlist outlist;
 104         outlist.push_back(uidtarget);
 105         outlist.push_back(outdata);
 106
 107         User* a = ServerInstance->FindNick(uidtarget);
 108         if (a)
 109         {
 110                 Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",outlist);
 111                 return;
 112         }
 113         else
 114         {
 115                 Channel* c = ServerInstance->FindChan(target);
 116                 if (c)
 117                 {
 118                         outlist.insert(outlist.begin() + 1, ConvToStr(c->age));
 119                         Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",outlist);
 120                 }
 121         }
 122 }
 123
 124 void SpanningTreeProtocolInterface::SendSNONotice(const std::string &snomask, const std::string &text)
 125 {
 126         parameterlist p;
 127         p.push_back(snomask);
 128         p.push_back(":" + text);
 129         Utils->DoOneToMany(ServerInstance->Config->GetSID(), "SNONOTICE", p);
 130 }
 131
 132 void SpanningTreeProtocolInterface::PushToClient(User* target, const std::string &rawline)
 133 {
 134         parameterlist p;
 135         p.push_back(target->uuid);
 136         p.push_back(":" + rawline);
 137         Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", p, target->server);
 138 }
 139
 140 void SpanningTreeProtocolInterface::SendChannelPrivmsg(Channel* target, char status, const std::string &text)
 141 {
 142         CUList exempt_list;
 143         Utils->SendChannelMessage(ServerInstance->Config->GetSID(), target, text, status, exempt_list, "PRIVMSG");
 144 }
 145
 146 void SpanningTreeProtocolInterface::SendChannelNotice(Channel* target, char status, const std::string &text)
 147 {
 148         CUList exempt_list;
 149         Utils->SendChannelMessage(ServerInstance->Config->GetSID(), target, text, status, exempt_list, "NOTICE");
 150 }
 151
 152 void SpanningTreeProtocolInterface::SendUserPrivmsg(User* target, const std::string &text)
 153 {
 154         parameterlist p;
 155         p.push_back(target->uuid);
 156         p.push_back(":" + text);
 157         Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PRIVMSG", p, target->server);
 158 }
 159
 160 void SpanningTreeProtocolInterface::SendUserNotice(User* target, const std::string &text)
 161 {
 162         parameterlist p;
 163         p.push_back(target->uuid);
 164         p.push_back(":" + text);
 165         Utils->DoOneToOne(ServerInstance->Config->GetSID(), "NOTICE", p, target->server);
 166 }