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 "main.h"
  23
  24 /** Handle /RCONNECT
  25  */
  26 class CommandRConnect : public Command
  27 {
  28  public:
  29         CommandRConnect(Module* Creator);
  30         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  31                 RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
  32 };
  33
  34 class CommandRSQuit : public Command
  35 {
  36  public:
  37         CommandRSQuit(Module* Creator);
  38         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  39                 RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
  40 };
  41
  42 class CommandSVSJoin : public Command
  43 {
  44  public:
  45         CommandSVSJoin(Module* Creator) : Command(Creator, "SVSJOIN", 2) { flags_needed = FLAG_SERVERONLY; }
  46         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  47         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
  48 };
  49 class CommandSVSPart : public Command
  50 {
  51  public:
  52         CommandSVSPart(Module* Creator) : Command(Creator, "SVSPART", 2) { flags_needed = FLAG_SERVERONLY; }
  53         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  54         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
  55 };
  56 class CommandSVSNick : public Command
  57 {
  58  public:
  59         CommandSVSNick(Module* Creator) : Command(Creator, "SVSNICK", 3) { flags_needed = FLAG_SERVERONLY; }
  60         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  61         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters);
  62 };
  63 class CommandMetadata : public Command
  64 {
  65  public:
  66         CommandMetadata(Module* Creator) : Command(Creator, "METADATA", 2) { flags_needed = FLAG_SERVERONLY; }
  67         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  68         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
  69 };
  70 class CommandUID : public Command
  71 {
  72  public:
  73         CommandUID(Module* Creator) : Command(Creator, "UID", 10) { flags_needed = FLAG_SERVERONLY; }
  74         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  75         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
  76 };
  77 class CommandOpertype : public Command
  78 {
  79  public:
  80         CommandOpertype(Module* Creator) : Command(Creator, "OPERTYPE", 1) { flags_needed = FLAG_SERVERONLY; }
  81         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  82         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
  83 };
  84 class TreeSocket;
  85 class CommandFJoin : public Command
  86 {
  87         /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
  88          * This does not update the timestamp of the target channel, this must be done seperately.
  89          */
  90         static void RemoveStatus(Channel* c);
  91         static void ApplyModeStack(User* srcuser, Channel* c, irc::modestacker& stack);
  92         bool ProcessModeUUIDPair(const std::string& item, TreeSocket* src_socket, Channel* chan, irc::modestacker* modestack);
  93  public:
  94         CommandFJoin(Module* Creator) : Command(Creator, "FJOIN", 3) { flags_needed = FLAG_SERVERONLY; }
  95         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
  96         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
  97 };
  98 class CommandFMode : public Command
  99 {
 100  public:
 101         CommandFMode(Module* Creator) : Command(Creator, "FMODE", 3) { flags_needed = FLAG_SERVERONLY; }
 102         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
 103         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 104 };
 105 class CommandFTopic : public Command
 106 {
 107  public:
 108         CommandFTopic(Module* Creator) : Command(Creator, "FTOPIC", 5) { flags_needed = FLAG_SERVERONLY; }
 109         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
 110         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 111 };
 112 class CommandFHost : public Command
 113 {
 114  public:
 115         CommandFHost(Module* Creator) : Command(Creator, "FHOST", 1) { flags_needed = FLAG_SERVERONLY; }
 116         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
 117         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 118 };
 119 class CommandFIdent : public Command
 120 {
 121  public:
 122         CommandFIdent(Module* Creator) : Command(Creator, "FIDENT", 1) { flags_needed = FLAG_SERVERONLY; }
 123         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
 124         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 125 };
 126 class CommandFName : public Command
 127 {
 128  public:
 129         CommandFName(Module* Creator) : Command(Creator, "FNAME", 1) { flags_needed = FLAG_SERVERONLY; }
 130         CmdResult Handle (const std::vector<std::string>& parameters, User *user);
 131         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 132 };
 133
 134 class CommandIJoin : public SplitCommand
 135 {
 136  public:
 137         CommandIJoin(Module* Creator) : SplitCommand(Creator, "IJOIN", 1) { flags_needed = FLAG_SERVERONLY; }
 138         CmdResult HandleRemote(const std::vector<std::string>& parameters, RemoteUser* user);
 139         RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters) { return ROUTE_BROADCAST; }
 140 };
 141
 142 class CommandResync : public SplitCommand
 143 {
 144  public:
 145         CommandResync(Module* Creator) : SplitCommand(Creator, "RESYNC", 1) { flags_needed = FLAG_SERVERONLY; }
 146         CmdResult HandleServer(const std::vector<std::string>& parameters, FakeUser* user);
 147 };
 148
 149 class SpanningTreeCommands
 150 {
 151  public:
 152         CommandRConnect rconnect;
 153         CommandRSQuit rsquit;
 154         CommandSVSJoin svsjoin;
 155         CommandSVSPart svspart;
 156         CommandSVSNick svsnick;
 157         CommandMetadata metadata;
 158         CommandUID uid;
 159         CommandOpertype opertype;
 160         CommandFJoin fjoin;
 161         CommandIJoin ijoin;
 162         CommandResync resync;
 163         CommandFMode fmode;
 164         CommandFTopic ftopic;
 165         CommandFHost fhost;
 166         CommandFIdent fident;
 167         CommandFName fname;
 168         SpanningTreeCommands(ModuleSpanningTree* module);
 169 };