src/modules/m_spanningtree/commands.h

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2010 Daniel De Graaf <danieldg@inspircd.org>
   5  *
   6  * This file is part of InspIRCd.  InspIRCd is free software: you can
   7  * redistribute it and/or modify it under the terms of the GNU General Public
   8  * License as published by the Free Software Foundation, version 2.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  13  * details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #pragma once
  21
  22 #include "servercommand.h"
  23 #include "commandbuilder.h"
  24 #include "remoteuser.h"
  25
  26 namespace SpanningTree
  27 {
  28         class CommandAway;
  29         class CommandNick;
  30         class CommandPing;
  31         class CommandPong;
  32         class CommandServer;
  33 }
  34
  35 using SpanningTree::CommandAway;
  36 using SpanningTree::CommandNick;
  37 using SpanningTree::CommandPing;
  38 using SpanningTree::CommandPong;
  39 using SpanningTree::CommandServer;
  40
  41 /** Handle /RCONNECT
  42  */
  43 class CommandRConnect : public Command
  44 {
  45  public:
  46         CommandRConnect(Module* Creator);
  47         CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
  48         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  49 };
  50
  51 class CommandRSQuit : public Command
  52 {
  53  public:
  54         CommandRSQuit(Module* Creator);
  55         CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
  56         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  57 };
  58
  59 class CommandMap : public Command
  60 {
  61  public:
  62         CommandMap(Module* Creator);
  63         CmdResult Handle(User* user, const Params& parameters) CXX11_OVERRIDE;
  64         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  65 };
  66
  67 class CommandSVSJoin : public ServerCommand
  68 {
  69  public:
  70         CommandSVSJoin(Module* Creator) : ServerCommand(Creator, "SVSJOIN", 2) { }
  71         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
  72         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  73 };
  74
  75 class CommandSVSPart : public ServerCommand
  76 {
  77  public:
  78         CommandSVSPart(Module* Creator) : ServerCommand(Creator, "SVSPART", 2) { }
  79         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
  80         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  81 };
  82
  83 class CommandSVSNick : public ServerCommand
  84 {
  85  public:
  86         CommandSVSNick(Module* Creator) : ServerCommand(Creator, "SVSNICK", 3) { }
  87         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
  88         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
  89 };
  90
  91 class CommandMetadata : public ServerCommand
  92 {
  93  public:
  94         CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { }
  95         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
  96
  97         class Builder : public CmdBuilder
  98         {
  99          public:
 100                 Builder(User* user, const std::string& key, const std::string& val);
 101                 Builder(Channel* chan, const std::string& key, const std::string& val);
 102                 Builder(const std::string& key, const std::string& val);
 103         };
 104 };
 105
 106 class CommandUID : public ServerOnlyServerCommand<CommandUID>
 107 {
 108  public:
 109         CommandUID(Module* Creator) : ServerOnlyServerCommand<CommandUID>(Creator, "UID", 10) { }
 110         CmdResult HandleServer(TreeServer* server, CommandBase::Params& params);
 111
 112         class Builder : public CmdBuilder
 113         {
 114          public:
 115                 Builder(User* user);
 116         };
 117 };
 118
 119 class CommandOpertype : public UserOnlyServerCommand<CommandOpertype>
 120 {
 121  public:
 122         CommandOpertype(Module* Creator) : UserOnlyServerCommand<CommandOpertype>(Creator, "OPERTYPE", 1) { }
 123         CmdResult HandleRemote(RemoteUser* user, Params& params);
 124
 125         class Builder : public CmdBuilder
 126         {
 127          public:
 128                 Builder(User* user);
 129         };
 130 };
 131
 132 class TreeSocket;
 133 class FwdFJoinBuilder;
 134 class CommandFJoin : public ServerCommand
 135 {
 136         /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
 137          * This does not update the timestamp of the target channel, this must be done seperately.
 138          */
 139         static void RemoveStatus(Channel* c);
 140
 141         /**
 142          * Lowers the TS on the given channel: removes all modes, unsets all extensions,
 143          * clears the topic and removes all pending invites.
 144          * @param chan The target channel whose TS to lower
 145          * @param TS The new TS to set
 146          * @param newname The new name of the channel; must be the same or a case change of the current name
 147          */
 148         static void LowerTS(Channel* chan, time_t TS, const std::string& newname);
 149         void ProcessModeUUIDPair(const std::string& item, TreeServer* sourceserver, Channel* chan, Modes::ChangeList* modechangelist, FwdFJoinBuilder& fwdfjoin);
 150  public:
 151         CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { }
 152         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
 153         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
 154
 155         class Builder : public CmdBuilder
 156         {
 157                 /** Maximum possible Membership::Id length in decimal digits, used for determining whether a user will fit into
 158                  * a message or not
 159                  */
 160                 static const size_t membid_max_digits = 20;
 161                 static const size_t maxline = 510;
 162                 std::string::size_type pos;
 163
 164         protected:
 165                 void add(Membership* memb, std::string::const_iterator mbegin, std::string::const_iterator mend);
 166                 bool has_room(std::string::size_type nummodes) const;
 167
 168          public:
 169                 Builder(Channel* chan, TreeServer* source = Utils->TreeRoot);
 170                 void add(Membership* memb)
 171                 {
 172                         add(memb, memb->modes.begin(), memb->modes.end());
 173                 }
 174
 175                 bool has_room(Membership* memb) const
 176                 {
 177                         return has_room(memb->modes.size());
 178                 }
 179
 180                 void clear();
 181                 const std::string& finalize();
 182         };
 183 };
 184
 185 class CommandFMode : public ServerCommand
 186 {
 187  public:
 188         CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { }
 189         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
 190 };
 191
 192 class CommandFTopic : public ServerCommand
 193 {
 194  public:
 195         CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 4, 5) { }
 196         CmdResult Handle(User* user, Params& params) CXX11_OVERRIDE;
 197
 198         class Builder : public CmdBuilder
 199         {
 200          public:
 201                 Builder(Channel* chan);
 202                 Builder(User* user, Channel* chan);
 203         };
 204 };
 205
 206 class CommandFHost : public UserOnlyServerCommand<CommandFHost>
 207 {
 208  public:
 209         CommandFHost(Module* Creator) : UserOnlyServerCommand<CommandFHost>(Creator, "FHOST", 1) { }
 210         CmdResult HandleRemote(RemoteUser* user, Params& params);
 211 };
 212
 213 class CommandFIdent : public UserOnlyServerCommand<CommandFIdent>
 214 {
 215  public:
 216         CommandFIdent(Module* Creator) : UserOnlyServerCommand<CommandFIdent>(Creator, "FIDENT", 1) { }
 217         CmdResult HandleRemote(RemoteUser* user, Params& params);
 218 };
 219
 220 class CommandFName : public UserOnlyServerCommand<CommandFName>
 221 {
 222  public:
 223         CommandFName(Module* Creator) : UserOnlyServerCommand<CommandFName>(Creator, "FNAME", 1) { }
 224         CmdResult HandleRemote(RemoteUser* user, Params& params);
 225 };
 226
 227 class CommandIJoin : public UserOnlyServerCommand<CommandIJoin>
 228 {
 229  public:
 230         CommandIJoin(Module* Creator) : UserOnlyServerCommand<CommandIJoin>(Creator, "IJOIN", 2) { }
 231         CmdResult HandleRemote(RemoteUser* user, Params& params);
 232 };
 233
 234 class CommandResync : public ServerOnlyServerCommand<CommandResync>
 235 {
 236  public:
 237         CommandResync(Module* Creator) : ServerOnlyServerCommand<CommandResync>(Creator, "RESYNC", 1) { }
 238         CmdResult HandleServer(TreeServer* server, Params& parameters);
 239         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_LOCALONLY; }
 240 };
 241
 242 class SpanningTree::CommandAway : public UserOnlyServerCommand<SpanningTree::CommandAway>
 243 {
 244  public:
 245         CommandAway(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandAway>(Creator, "AWAY", 0, 2) { }
 246         CmdResult HandleRemote(::RemoteUser* user, Params& parameters);
 247
 248         class Builder : public CmdBuilder
 249         {
 250          public:
 251                 Builder(User* user);
 252                 Builder(User* user, const std::string& msg);
 253         };
 254 };
 255
 256 class XLine;
 257 class CommandAddLine : public ServerCommand
 258 {
 259  public:
 260         CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { }
 261         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 262
 263         class Builder : public CmdBuilder
 264         {
 265          public:
 266                 Builder(XLine* xline, User* user = ServerInstance->FakeClient);
 267         };
 268 };
 269
 270 class CommandDelLine : public ServerCommand
 271 {
 272  public:
 273         CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { }
 274         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 275 };
 276
 277 class CommandEncap : public ServerCommand
 278 {
 279  public:
 280         CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { }
 281         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 282         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
 283 };
 284
 285 class CommandIdle : public UserOnlyServerCommand<CommandIdle>
 286 {
 287  public:
 288         CommandIdle(Module* Creator) : UserOnlyServerCommand<CommandIdle>(Creator, "IDLE", 1) { }
 289         CmdResult HandleRemote(RemoteUser* user, Params& parameters);
 290         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
 291 };
 292
 293 class SpanningTree::CommandNick : public UserOnlyServerCommand<SpanningTree::CommandNick>
 294 {
 295  public:
 296         CommandNick(Module* Creator) : UserOnlyServerCommand<SpanningTree::CommandNick>(Creator, "NICK", 2) { }
 297         CmdResult HandleRemote(::RemoteUser* user, Params& parameters);
 298 };
 299
 300 class SpanningTree::CommandPing : public ServerCommand
 301 {
 302  public:
 303         CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { }
 304         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 305         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
 306 };
 307
 308 class SpanningTree::CommandPong : public ServerOnlyServerCommand<SpanningTree::CommandPong>
 309 {
 310  public:
 311         CommandPong(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandPong>(Creator, "PONG", 1) { }
 312         CmdResult HandleServer(TreeServer* server, Params& parameters);
 313         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE { return ROUTE_UNICAST(parameters[0]); }
 314 };
 315
 316 class CommandSave : public ServerCommand
 317 {
 318  public:
 319         /** Timestamp of the uuid nick of all users who collided and got their nick changed to uuid
 320          */
 321         static const time_t SavedTimestamp = 100;
 322
 323         CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { }
 324         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 325 };
 326
 327 class SpanningTree::CommandServer : public ServerOnlyServerCommand<SpanningTree::CommandServer>
 328 {
 329         static void HandleExtra(TreeServer* newserver, Params& params);
 330
 331  public:
 332         CommandServer(Module* Creator) : ServerOnlyServerCommand<SpanningTree::CommandServer>(Creator, "SERVER", 3) { }
 333         CmdResult HandleServer(TreeServer* server, Params& parameters);
 334
 335         class Builder : public CmdBuilder
 336         {
 337                 void push_property(const char* key, const std::string& val)
 338                 {
 339                         push(key).push_raw('=').push_raw(val);
 340                 }
 341          public:
 342                 Builder(TreeServer* server);
 343         };
 344 };
 345
 346 class CommandSQuit : public ServerOnlyServerCommand<CommandSQuit>
 347 {
 348  public:
 349         CommandSQuit(Module* Creator) : ServerOnlyServerCommand<CommandSQuit>(Creator, "SQUIT", 2) { }
 350         CmdResult HandleServer(TreeServer* server, Params& parameters);
 351 };
 352
 353 class CommandSNONotice : public ServerCommand
 354 {
 355  public:
 356         CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { }
 357         CmdResult Handle(User* user, Params& parameters) CXX11_OVERRIDE;
 358 };
 359
 360 class CommandEndBurst : public ServerOnlyServerCommand<CommandEndBurst>
 361 {
 362  public:
 363         CommandEndBurst(Module* Creator) : ServerOnlyServerCommand<CommandEndBurst>(Creator, "ENDBURST") { }
 364         CmdResult HandleServer(TreeServer* server, Params& parameters);
 365 };
 366
 367 class CommandSInfo : public ServerOnlyServerCommand<CommandSInfo>
 368 {
 369  public:
 370         CommandSInfo(Module* Creator) : ServerOnlyServerCommand<CommandSInfo>(Creator, "SINFO", 2) { }
 371         CmdResult HandleServer(TreeServer* server, Params& parameters);
 372
 373         class Builder : public CmdBuilder
 374         {
 375          public:
 376                 Builder(TreeServer* server, const char* type, const std::string& value);
 377         };
 378 };
 379
 380 class CommandNum : public ServerOnlyServerCommand<CommandNum>
 381 {
 382  public:
 383         CommandNum(Module* Creator) : ServerOnlyServerCommand<CommandNum>(Creator, "NUM", 3) { }
 384         CmdResult HandleServer(TreeServer* server, Params& parameters);
 385         RouteDescriptor GetRouting(User* user, const Params& parameters) CXX11_OVERRIDE;
 386
 387         class Builder : public CmdBuilder
 388         {
 389          public:
 390                 Builder(SpanningTree::RemoteUser* target, const Numeric::Numeric& numeric);
 391         };
 392 };
 393
 394 class SpanningTreeCommands
 395 {
 396  public:
 397         CommandSVSJoin svsjoin;
 398         CommandSVSPart svspart;
 399         CommandSVSNick svsnick;
 400         CommandMetadata metadata;
 401         CommandUID uid;
 402         CommandOpertype opertype;
 403         CommandFJoin fjoin;
 404         CommandIJoin ijoin;
 405         CommandResync resync;
 406         CommandFMode fmode;
 407         CommandFTopic ftopic;
 408         CommandFHost fhost;
 409         CommandFIdent fident;
 410         CommandFName fname;
 411         SpanningTree::CommandAway away;
 412         CommandAddLine addline;
 413         CommandDelLine delline;
 414         CommandEncap encap;
 415         CommandIdle idle;
 416         SpanningTree::CommandNick nick;
 417         SpanningTree::CommandPing ping;
 418         SpanningTree::CommandPong pong;
 419         CommandSave save;
 420         SpanningTree::CommandServer server;
 421         CommandSQuit squit;
 422         CommandSNONotice snonotice;
 423         CommandEndBurst endburst;
 424         CommandSInfo sinfo;
 425         CommandNum num;
 426         SpanningTreeCommands(ModuleSpanningTree* module);
 427 };