X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_spanningtree%2Fcommands.h;h=67e2d43d66d0e8497ba8cf8dc160a93c2761ca33;hb=daa907cb09e394cb88737ddef9299d0c4ba5ee98;hp=dd54b5b6bd2bad3117d6d9690be544751ad3fb5e;hpb=8790551dc182cd8804ee7d8ef89ccb31067cc2a4;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_spanningtree/commands.h b/src/modules/m_spanningtree/commands.h index dd54b5b6b..67e2d43d6 100644 --- a/src/modules/m_spanningtree/commands.h +++ b/src/modules/m_spanningtree/commands.h @@ -19,140 +19,343 @@ #pragma once -#include "main.h" +#include "servercommand.h" +#include "commandbuilder.h" /** Handle /RCONNECT */ class CommandRConnect : public Command { - SpanningTreeUtilities* Utils; /* Utility class */ public: - CommandRConnect (Module* Callback, SpanningTreeUtilities* Util); - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters); + CommandRConnect(Module* Creator); + CmdResult Handle(const std::vector& parameters, User* user); + RouteDescriptor GetRouting(User* user, const std::vector& parameters); }; class CommandRSQuit : public Command { - SpanningTreeUtilities* Utils; /* Utility class */ public: - CommandRSQuit(Module* Callback, SpanningTreeUtilities* Util); - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters); + CommandRSQuit(Module* Creator); + CmdResult Handle(const std::vector& parameters, User* user); + RouteDescriptor GetRouting(User* user, const std::vector& parameters); +}; + +class CommandMap : public Command +{ + public: + CommandMap(Module* Creator); + CmdResult Handle(const std::vector& parameters, User* user); + RouteDescriptor GetRouting(User* user, const std::vector& parameters); }; -class CommandSVSJoin : public Command +class CommandSVSJoin : public ServerCommand { public: - CommandSVSJoin(Module* Creator) : Command(Creator, "SVSJOIN", 2) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); + CommandSVSJoin(Module* Creator) : ServerCommand(Creator, "SVSJOIN", 2) { } + CmdResult Handle(User* user, std::vector& params); RouteDescriptor GetRouting(User* user, const std::vector& parameters); }; -class CommandSVSPart : public Command + +class CommandSVSPart : public ServerCommand { public: - CommandSVSPart(Module* Creator) : Command(Creator, "SVSPART", 2) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); + CommandSVSPart(Module* Creator) : ServerCommand(Creator, "SVSPART", 2) { } + CmdResult Handle(User* user, std::vector& params); RouteDescriptor GetRouting(User* user, const std::vector& parameters); }; -class CommandSVSNick : public Command + +class CommandSVSNick : public ServerCommand { public: - CommandSVSNick(Module* Creator) : Command(Creator, "SVSNICK", 3) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); + CommandSVSNick(Module* Creator) : ServerCommand(Creator, "SVSNICK", 3) { } + CmdResult Handle(User* user, std::vector& params); RouteDescriptor GetRouting(User* user, const std::vector& parameters); }; -class CommandMetadata : public Command + +class CommandMetadata : public ServerCommand { public: - CommandMetadata(Module* Creator) : Command(Creator, "METADATA", 2) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandMetadata(Module* Creator) : ServerCommand(Creator, "METADATA", 2) { } + CmdResult Handle(User* user, std::vector& params); + + class Builder : public CmdBuilder + { + public: + Builder(User* user, const std::string& key, const std::string& val); + Builder(Channel* chan, const std::string& key, const std::string& val); + Builder(const std::string& key, const std::string& val); + }; }; -class CommandUID : public Command + +class CommandUID : public ServerOnlyServerCommand { public: - CommandUID(Module* Creator) : Command(Creator, "UID", 10) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandUID(Module* Creator) : ServerOnlyServerCommand(Creator, "UID", 10) { } + CmdResult HandleServer(TreeServer* server, std::vector& params); + + class Builder : public CmdBuilder + { + public: + Builder(User* user); + }; }; -class CommandOpertype : public Command + +class CommandOpertype : public UserOnlyServerCommand { public: - CommandOpertype(Module* Creator) : Command(Creator, "OPERTYPE", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandOpertype(Module* Creator) : UserOnlyServerCommand(Creator, "OPERTYPE", 1) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& params); + + class Builder : public CmdBuilder + { + public: + Builder(User* user); + }; }; + class TreeSocket; -class CommandFJoin : public Command +class CommandFJoin : public ServerCommand { /** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes. * This does not update the timestamp of the target channel, this must be done seperately. */ static void RemoveStatus(Channel* c); static void ApplyModeStack(User* srcuser, Channel* c, irc::modestacker& stack); - bool ProcessModeUUIDPair(const std::string& item, TreeSocket* src_socket, Channel* chan, irc::modestacker* modestack); + + /** + * Lowers the TS on the given channel: removes all modes, unsets all extensions, + * clears the topic and removes all pending invites. + * @param chan The target channel whose TS to lower + * @param TS The new TS to set + * @param newname The new name of the channel; must be the same or a case change of the current name + */ + static void LowerTS(Channel* chan, time_t TS, const std::string& newname); + void ProcessModeUUIDPair(const std::string& item, TreeSocket* src_socket, Channel* chan, irc::modestacker* modestack); + public: + CommandFJoin(Module* Creator) : ServerCommand(Creator, "FJOIN", 3) { } + CmdResult Handle(User* user, std::vector& params); + + class Builder : public CmdBuilder + { + /** Maximum possible Membership::Id length in decimal digits, used for determining whether a user will fit into + * a message or not + */ + static const size_t membid_max_digits = 20; + static const size_t maxline = 480; + std::string::size_type pos; + + public: + Builder(Channel* chan); + void add(Membership* memb); + bool has_room(Membership* memb) const; + void clear(); + const std::string& finalize(); + }; +}; + +class CommandFMode : public ServerCommand +{ public: - CommandFJoin(Module* Creator) : Command(Creator, "FJOIN", 3) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandFMode(Module* Creator) : ServerCommand(Creator, "FMODE", 3) { } + CmdResult Handle(User* user, std::vector& params); }; -class CommandFMode : public Command + +class CommandFTopic : public ServerCommand +{ + public: + CommandFTopic(Module* Creator) : ServerCommand(Creator, "FTOPIC", 4, 5) { } + CmdResult Handle(User* user, std::vector& params); + + class Builder : public CmdBuilder + { + public: + Builder(Channel* chan); + Builder(User* user, Channel* chan); + }; +}; + +class CommandFHost : public UserOnlyServerCommand +{ + public: + CommandFHost(Module* Creator) : UserOnlyServerCommand(Creator, "FHOST", 1) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& params); +}; + +class CommandFIdent : public UserOnlyServerCommand +{ + public: + CommandFIdent(Module* Creator) : UserOnlyServerCommand(Creator, "FIDENT", 1) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& params); +}; + +class CommandFName : public UserOnlyServerCommand { public: - CommandFMode(Module* Creator) : Command(Creator, "FMODE", 3) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandFName(Module* Creator) : UserOnlyServerCommand(Creator, "FNAME", 1) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& params); }; -class CommandFTopic : public Command + +class CommandIJoin : public UserOnlyServerCommand { public: - CommandFTopic(Module* Creator) : Command(Creator, "FTOPIC", 5) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandIJoin(Module* Creator) : UserOnlyServerCommand(Creator, "IJOIN", 2) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& params); }; -class CommandFHost : public Command + +class CommandResync : public ServerOnlyServerCommand { public: - CommandFHost(Module* Creator) : Command(Creator, "FHOST", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandResync(Module* Creator) : ServerOnlyServerCommand(Creator, "RESYNC", 1) { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_LOCALONLY; } }; -class CommandFIdent : public Command + +class CommandAway : public UserOnlyServerCommand { public: - CommandFIdent(Module* Creator) : Command(Creator, "FIDENT", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandAway(Module* Creator) : UserOnlyServerCommand(Creator, "AWAY", 0, 2) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& parameters); + + class Builder : public CmdBuilder + { + public: + Builder(User* user); + Builder(User* user, const std::string& msg); + }; }; -class CommandFName : public Command + +class XLine; +class CommandAddLine : public ServerCommand { public: - CommandFName(Module* Creator) : Command(Creator, "FNAME", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult Handle (const std::vector& parameters, User *user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandAddLine(Module* Creator) : ServerCommand(Creator, "ADDLINE", 6, 6) { } + CmdResult Handle(User* user, std::vector& parameters); + + class Builder : public CmdBuilder + { + public: + Builder(XLine* xline, User* user = ServerInstance->FakeClient); + }; }; -class CommandIJoin : public SplitCommand +class CommandDelLine : public ServerCommand { public: - CommandIJoin(Module* Creator) : SplitCommand(Creator, "IJOIN", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult HandleRemote(const std::vector& parameters, RemoteUser* user); - RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_BROADCAST; } + CommandDelLine(Module* Creator) : ServerCommand(Creator, "DELLINE", 2, 2) { } + CmdResult Handle(User* user, std::vector& parameters); }; -class CommandResync : public SplitCommand +class CommandEncap : public ServerCommand { public: - CommandResync(Module* Creator) : SplitCommand(Creator, "RESYNC", 1) { flags_needed = FLAG_SERVERONLY; } - CmdResult HandleServer(const std::vector& parameters, FakeUser* user); + CommandEncap(Module* Creator) : ServerCommand(Creator, "ENCAP", 2) { } + CmdResult Handle(User* user, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters); +}; + +class CommandIdle : public UserOnlyServerCommand +{ + public: + CommandIdle(Module* Creator) : UserOnlyServerCommand(Creator, "IDLE", 1) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_UNICAST(parameters[0]); } +}; + +class CommandNick : public UserOnlyServerCommand +{ + public: + CommandNick(Module* Creator) : UserOnlyServerCommand(Creator, "NICK", 2) { } + CmdResult HandleRemote(RemoteUser* user, std::vector& parameters); +}; + +class CommandPing : public ServerCommand +{ + public: + CommandPing(Module* Creator) : ServerCommand(Creator, "PING", 1) { } + CmdResult Handle(User* user, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_UNICAST(parameters[0]); } +}; + +class CommandPong : public ServerOnlyServerCommand +{ + public: + CommandPong(Module* Creator) : ServerOnlyServerCommand(Creator, "PONG", 1) { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_UNICAST(parameters[0]); } +}; + +class CommandPush : public ServerCommand +{ + public: + CommandPush(Module* Creator) : ServerCommand(Creator, "PUSH", 2) { } + CmdResult Handle(User* user, std::vector& parameters); + RouteDescriptor GetRouting(User* user, const std::vector& parameters) { return ROUTE_UNICAST(parameters[0]); } +}; + +class CommandSave : public ServerCommand +{ + public: + CommandSave(Module* Creator) : ServerCommand(Creator, "SAVE", 2) { } + CmdResult Handle(User* user, std::vector& parameters); +}; + +class CommandServer : public ServerOnlyServerCommand +{ + public: + CommandServer(Module* Creator) : ServerOnlyServerCommand(Creator, "SERVER", 5) { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); + + class Builder : public CmdBuilder + { + public: + Builder(TreeServer* server); + }; +}; + +class CommandSQuit : public ServerOnlyServerCommand +{ + public: + CommandSQuit(Module* Creator) : ServerOnlyServerCommand(Creator, "SQUIT", 2) { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); +}; + +class CommandSNONotice : public ServerCommand +{ + public: + CommandSNONotice(Module* Creator) : ServerCommand(Creator, "SNONOTICE", 2) { } + CmdResult Handle(User* user, std::vector& parameters); +}; + +class CommandBurst : public ServerOnlyServerCommand +{ + public: + CommandBurst(Module* Creator) : ServerOnlyServerCommand(Creator, "BURST") { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); +}; + +class CommandEndBurst : public ServerOnlyServerCommand +{ + public: + CommandEndBurst(Module* Creator) : ServerOnlyServerCommand(Creator, "ENDBURST") { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); +}; + +class CommandSInfo : public ServerOnlyServerCommand +{ + public: + CommandSInfo(Module* Creator) : ServerOnlyServerCommand(Creator, "SINFO", 2) { } + CmdResult HandleServer(TreeServer* server, std::vector& parameters); + + class Builder : public CmdBuilder + { + public: + Builder(TreeServer* server, const char* type, const std::string& value); + }; }; class SpanningTreeCommands { public: - CommandRConnect rconnect; - CommandRSQuit rsquit; CommandSVSJoin svsjoin; CommandSVSPart svspart; CommandSVSNick svsnick; @@ -167,5 +370,21 @@ class SpanningTreeCommands CommandFHost fhost; CommandFIdent fident; CommandFName fname; + CommandAway away; + CommandAddLine addline; + CommandDelLine delline; + CommandEncap encap; + CommandIdle idle; + CommandNick nick; + CommandPing ping; + CommandPong pong; + CommandPush push; + CommandSave save; + CommandServer server; + CommandSQuit squit; + CommandSNONotice snonotice; + CommandBurst burst; + CommandEndBurst endburst; + CommandSInfo sinfo; SpanningTreeCommands(ModuleSpanningTree* module); };