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