src/modules/m_spanningtree/commands.h

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