Include explicit parameter list in ProtocolInterface::SendMode

Also leave the strings split into deque, there's no need to pack it into a
string just to unpack it during the translate.

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@11181 e03df62e-2008-0410-955e-edbf42e46eb7

diff --git a/include/command_parse.h b/include/command_parse.h
index 21dae89dd91b2bcf9919abe39aca60705dcd9ecd..6f6b96ca120f73f29a2266b8bc2b5adf64e0fe56 100644 (file)
--- a/include/command_parse.h
+++ b/include/command_parse.h
@@ -203,7 +203,7 @@ class CoreExport CommandParser : public classbase
         */
        int TranslateUIDs(TranslateType to, const std::string &source, std::string &dest);
 
-       int TranslateUIDs(const std::vector<TranslateType> to, const std::string &source, std::string &dest);
+       int TranslateUIDs(const std::deque<TranslateType> to, const std::deque<std::string> &source, std::string &dest);
 };
 
 /** Command handler class for the RELOAD command.

diff --git a/include/inspircd.h b/include/inspircd.h
index fcd6849d5a5d3f184b3951b15bb2c3462591864c..5461adcca2064e8192f4a2bd278b2aa4e51eaba0 100644 (file)
--- a/include/inspircd.h
+++ b/include/inspircd.h
@@ -721,7 +721,6 @@ class CoreExport InspIRCd : public classbase
         * The parameters provided are identical to that sent to the
         * handler for class cmd_mode.
         * @param parameters The mode parameters
-        * @param pcnt The number of items you have given in the first parameter
         * @param user The user to send error messages to
         */
        void SendMode(const std::vector<std::string>& parameters, User *user);

diff --git a/include/mode.h b/include/mode.h
index 525a262082e371b10cbe6660ee1f2ff00c77da19..94d9f3dfe2695bce688742c4490a239db346d9b8 100644 (file)
--- a/include/mode.h
+++ b/include/mode.h
@@ -445,6 +445,8 @@ class CoreExport ModeParser : public classbase
         * Use GetLastParse() to get this value, to be used for  display purposes.
         */
        std::string LastParse;
+       std::deque<std::string> LastParseParams;
+       std::deque<TranslateType> LastParseTranslate;
 
        unsigned int sent[256];
 
@@ -486,6 +488,8 @@ class CoreExport ModeParser : public classbase
         * @return Last parsed string, as seen by users.
         */
        const std::string& GetLastParse();
+       const std::deque<std::string>& GetLastParseParams() { return LastParseParams; }
+       const std::deque<TranslateType>& GetLastParseTranslate() { return LastParseTranslate; }
        /** Add a mode to the mode parser.
         * @return True if the mode was successfully added.
         */

diff --git a/include/modules.h b/include/modules.h
index 90aeb178e3a89c35adcfd766341372e4bea50217..b58cbbc206e55307a54e81786bfde4637974d39d 100644 (file)
--- a/include/modules.h
+++ b/include/modules.h
@@ -741,7 +741,7 @@ class CoreExport Module : public Extensible
         * @param text The actual modes and their parameters if any
         * @param translate The translation types of the mode parameters
         */
-       virtual void OnMode(User* user, void* dest, int target_type, const std::string &text, const std::vector<TranslateType> &translate);
+       virtual void OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate);
 
        /** Allows modules to alter or create server descriptions
         * Whenever a module requires a server description, for example for display in
@@ -850,7 +850,7 @@ class CoreExport Module : public Extensible
         * @param modeline The modes and parameters to be sent
         * @param translate The translation types of the mode parameters
         */
-       virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::string &modeline, const std::vector<TranslateType> &translate);
+       virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate);
 
        /** Implemented by modules which provide the ability to link servers.
         * These modules will implement this method, which allows metadata (extra data added to

diff --git a/include/protocol.h b/include/protocol.h
index 4d6f8f27d006a0121cc42c6fbb56f4adf1f01bb3..d9a2ce25d02c1030e857ae9df278463e71e0b5f3 100644 (file)
--- a/include/protocol.h
+++ b/include/protocol.h
@@ -68,7 +68,7 @@ class ProtocolInterface : public Extensible
         * @param target The channel name or user to send mode changes for.
         * @param The mode changes to send.
         */
-       virtual void SendMode(const std::string &target, parameterlist &modedata) { }
+       virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &translate) { }
 
        /** Convenience function, string wrapper around the above.
          */
@@ -76,10 +76,14 @@ class ProtocolInterface : public Extensible
        {
                irc::spacesepstream x(modeline);
                parameterlist n;
+               std::deque<TranslateType> types;
                std::string v;
                while (x.GetToken(v))
+               {
                        n.push_back(v);
-               SendMode(target, n);
+                       types.push_back(TR_TEXT);
+               }
+               SendMode(target, n, types);
        }
 
        /** Send a notice to users with a given mode(s).

diff --git a/include/u_listmode.h b/include/u_listmode.h
index 88b5fb3eea17c66a4643903147af900f1a9da925..1e7d1cceb21f7a8e18e0a11fca76b3e8c2f68774 100644 (file)
--- a/include/u_listmode.h
+++ b/include/u_listmode.h
@@ -423,21 +423,19 @@ class ListModeBase : public ModeHandler
                chan->GetExt(infokey, mlist);
                irc::modestacker modestack(ServerInstance, true);
                std::deque<std::string> stackresult;
-               std::vector<TranslateType> types;
+               std::deque<TranslateType> types;
                types.push_back(TR_TEXT);
                if (mlist)
                {
                        for (modelist::iterator it = mlist->begin(); it != mlist->end(); it++)
                        {
                                modestack.Push(std::string(1, mode)[0], it->mask);
-                               types.push_back(this->GetTranslateType());
                        }
                }
                while (modestack.GetStackedLine(stackresult))
                {
-                       irc::stringjoiner mode_join(" ", stackresult, 0, stackresult.size() - 1);
-                       std::string line = mode_join.GetJoined();
-                       proto->ProtoSendMode(opaque, TYPE_CHANNEL, chan, line, types);
+                       types.assign(stackresult.size(), this->GetTranslateType());
+                       proto->ProtoSendMode(opaque, TYPE_CHANNEL, chan, stackresult, types);
                }
        }
 

diff --git a/src/command_parse.cpp b/src/command_parse.cpp
index d0b1148165815f494225d1dcff3986643876f7d6..92428fd32b5842f32a3abf48f40edbdc6480c86f 100644 (file)
--- a/src/command_parse.cpp
+++ b/src/command_parse.cpp
@@ -609,19 +609,20 @@ void CommandParser::SetupCommandTable()
                this->CreateCommand(new CommandReload(ServerInstance));
 }
 
-int CommandParser::TranslateUIDs(const std::vector<TranslateType> to, const std::string &source, std::string &dest)
+int CommandParser::TranslateUIDs(const std::deque<TranslateType> to, const std::deque<std::string> &source, std::string &dest)
 {
-       irc::spacesepstream items(source);
-       std::vector<TranslateType>::const_iterator types = to.begin();
+       std::deque<std::string>::const_iterator items = source.begin();
+       std::deque<TranslateType>::const_iterator types = to.begin();
        User* user = NULL;
-       std::string item;
        int translations = 0;
        dest.clear();
 
-       while (items.GetToken(item))
+       while (items != source.end() && types != to.end())
        {
                TranslateType t = *types;
+               std::string item = *items;
                types++;
+               items++;
 
                switch (t)
                {

diff --git a/src/mode.cpp b/src/mode.cpp
index da8f10294ff89149f9e8f445774b7dc7f17db028..40bd7096371679ce3b95a884296f30ab757da0e5 100644 (file)
--- a/src/mode.cpp
+++ b/src/mode.cpp
@@ -371,6 +371,8 @@ void ModeParser::Process(const std::vector<std::string>& parameters, User *user,
        User* targetuser  = ServerInstance->FindNick(parameters[0]);
 
        LastParse.clear();
+       LastParseParams.clear();
+       LastParseTranslate.clear();
 
        /* Special case for displaying the list for listmodes,
         * e.g. MODE #chan b, or MODE #chan +b without a parameter
@@ -503,14 +505,13 @@ void ModeParser::Process(const std::vector<std::string>& parameters, User *user,
                std::string mode_sequence = parameters[1];
                std::string parameter;
                std::ostringstream parameter_list;
-               std::vector<TranslateType> parameter_xlate;
-               parameter_xlate.push_back(TR_TEXT);
                std::string output_sequence;
                bool adding = true, state_change = false;
                unsigned char handler_id = 0;
                unsigned int parameter_counter = 2; /* Index of first parameter */
                unsigned int parameter_count = 0;
                bool last_successful_state_change = false;
+               LastParseTranslate.push_back(TR_TEXT);
 
                /* A mode sequence that doesnt start with + or -. Assume +. - Thanks for the suggestion spike (bug#132) */
                if ((*mode_sequence.begin() != '+') && (*mode_sequence.begin() != '-'))
@@ -717,7 +718,8 @@ void ModeParser::Process(const std::vector<std::string>& parameters, User *user,
                                                                if ((modehandlers[handler_id]->GetNumParams(adding)) && (!parameter.empty()))
                                                                {
                                                                        parameter_list << " " << parameter;
-                                                                       parameter_xlate.push_back(modehandlers[handler_id]->GetTranslateType());
+                                                                       LastParseParams.push_back(parameter);
+                                                                       LastParseTranslate.push_back(modehandlers[handler_id]->GetTranslateType());
                                                                        parameter_count++;
                                                                        /* Does this mode have a prefix? */
                                                                        if (modehandlers[handler_id]->GetPrefix() && targetchannel)
@@ -773,16 +775,17 @@ void ModeParser::Process(const std::vector<std::string>& parameters, User *user,
                        }
                        else
                        {
+                               LastParseParams.push_front(output_sequence);
                                if (type == MODETYPE_CHANNEL)
                                {
                                        targetchannel->WriteChannel(user, "MODE %s %s%s", targetchannel->name.c_str(), output_sequence.c_str(), parameter_list.str().c_str());
-                                       FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, output_sequence + parameter_list.str(), parameter_xlate));
+                                       FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, LastParseParams, LastParseTranslate));
                                        this->LastParse = targetchannel->name;
                                }
                                else
                                {
                                        user->WriteTo(targetuser, "MODE %s %s%s", targetuser->nick.c_str(), output_sequence.c_str(), parameter_list.str().c_str());
-                                       FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, output_sequence + parameter_list.str(), parameter_xlate));
+                                       FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, LastParseParams, LastParseTranslate));
                                        this->LastParse = targetuser->nick;
                                }
                        }

diff --git a/src/modules.cpp b/src/modules.cpp
index 2d8c9387f5cbd49db8a50116d983772b669a76d4..7bce6161b81e3a20da0dff8b35f04818cb0feb07 100644 (file)
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -116,7 +116,7 @@ void                Module::OnPostJoin(User*, Channel*) { }
 void           Module::OnUserPart(User*, Channel*, std::string&, bool&) { }
 void           Module::OnRehash(User*, const std::string&) { }
 int            Module::OnUserPreJoin(User*, Channel*, const char*, std::string&, const std::string&) { return 0; }
-void           Module::OnMode(User*, void*, int, const std::string&, const std::vector<TranslateType>&) { }
+void           Module::OnMode(User*, void*, int, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
 Version                Module::GetVersion() { return Version("Misconfigured", VF_VENDOR, -1); }
 void           Module::OnOper(User*, const std::string&) { }
 void           Module::OnPostOper(User*, const std::string&, const std::string &) { }
@@ -170,7 +170,7 @@ void                Module::OnPostLocalTopicChange(User*, Channel*, const std::string&) { }
 void           Module::OnGetServerDescription(const std::string&, std::string&) { }
 void           Module::OnSyncUser(User*, Module*, void*) { }
 void           Module::OnSyncChannel(Channel*, Module*, void*) { }
-void           Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::string&, const std::vector<TranslateType>&) { }
+void           Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
 void           Module::OnSyncChannelMetaData(Channel*, Module*, void*, const std::string&, bool) { }
 void           Module::OnSyncUserMetaData(User*, Module*, void*, const std::string&, bool) { }
 void           Module::OnSyncOtherMetaData(Module*, void*, bool) { }

diff --git a/src/modules/m_opermodes.cpp b/src/modules/m_opermodes.cpp
index 2e947809ac979ba0090a365030dce80a2cf663a6..f72f007c4b783b7f2acf315636b329be95995716 100644 (file)
--- a/src/modules/m_opermodes.cpp
+++ b/src/modules/m_opermodes.cpp
@@ -109,10 +109,14 @@ class ModuleModesOnOper : public Module
                }
 
                std::deque<std::string> n;
+               std::deque<TranslateType> t;
                for (unsigned int j = 1; j < tokens.size(); j++)
+               {
                        n.push_back(modes[j]);
+                       t.push_back(TR_TEXT);
+               }
 
-               ServerInstance->PI->SendMode(u->uuid, n);
+               ServerInstance->PI->SendMode(u->uuid, n, t);
                ServerInstance->SendMode(modes, u);
        }
 };

diff --git a/src/modules/m_samode.cpp b/src/modules/m_samode.cpp
index 82055dad3a611a869c26691ffb027d5d9d925f4d..fdc1074667df842a93fdad0f84e48cfafa3b36b2 100644 (file)
--- a/src/modules/m_samode.cpp
+++ b/src/modules/m_samode.cpp
@@ -37,20 +37,9 @@ class CommandSamode : public Command
                {
                        ServerInstance->SNO->WriteToSnoMask('A', std::string(user->nick) + " used SAMODE: " + ServerInstance->Modes->GetLastParse());
 
-                       std::deque<std::string> n;
-                       irc::spacesepstream spaced(ServerInstance->Modes->GetLastParse());
-                       std::string one;
-                       while (spaced.GetToken(one))
-                               n.push_back(one);
+                       std::string channel = parameters[0];
+                       ServerInstance->PI->SendMode(channel, ServerInstance->Modes->GetLastParseParams(), ServerInstance->Modes->GetLastParseTranslate());
 
-                       std::string channel = n[0];
-                       n.pop_front();
-                       ServerInstance->PI->SendMode(channel, n);
-
-                       /* XXX: Yes, this is right. We dont want to propagate the
-                        * actual SAMODE command, just the MODE command generated
-                        * by the Protocol Interface
-                        */
                        return CMD_LOCALONLY;
                }
                else

diff --git a/src/modules/m_spanningtree/main.cpp b/src/modules/m_spanningtree/main.cpp
index 51a9eb025535e215c8df936d50f267e82bc430f5..3d2056eb636aa40819a7dd28a59fb210cb9345d0 100644 (file)
--- a/src/modules/m_spanningtree/main.cpp
+++ b/src/modules/m_spanningtree/main.cpp
@@ -800,7 +800,7 @@ void ModuleSpanningTree::OnDelLine(User* user, XLine *x)
        }
 }
 
-void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const std::string &text, const std::vector<TranslateType> &translate)
+void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate)
 {
        if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
        {
@@ -851,7 +851,7 @@ int ModuleSpanningTree::OnSetAway(User* user, const std::string &awaymsg)
        return 0;
 }
 
-void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::string &modeline, const std::vector<TranslateType> &translate)
+void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate)
 {
        TreeSocket* s = (TreeSocket*)opaque;
        std::string output_text;

diff --git a/src/modules/m_spanningtree/main.h b/src/modules/m_spanningtree/main.h
index 19ec2d43c026475fb8be2fee773773ba8842f17b..a0900dd33d199ae137d5917a1fd8cfc2e153890c 100644 (file)
--- a/src/modules/m_spanningtree/main.h
+++ b/src/modules/m_spanningtree/main.h
@@ -174,10 +174,10 @@ class ModuleSpanningTree : public Module
        void OnLine(User* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason);
        virtual void OnAddLine(User *u, XLine *x);
        virtual void OnDelLine(User *u, XLine *x);
-       virtual void OnMode(User* user, void* dest, int target_type, const std::string &text, const std::vector<TranslateType> &translate);
+       virtual void OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate);
        virtual int OnStats(char statschar, User* user, string_list &results);
        virtual int OnSetAway(User* user, const std::string &awaymsg);
-       virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::string &modeline, const std::vector<TranslateType> &translate);
+       virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate);
        virtual void ProtoSendMetaData(void* opaque, TargetTypeFlags target_type, void* target, const std::string &extname, const std::string &extdata);
        virtual void OnEvent(Event* event);
        virtual void OnLoadModule(Module* mod,const std::string &name);

diff --git a/src/modules/m_spanningtree/protocolinterface.cpp b/src/modules/m_spanningtree/protocolinterface.cpp
index 9f32963a02c55adb1e645b8e9b32e675a882eff9..cfc9bbea7d58bcd83fc0b08388e2d3c121e29c67 100644 (file)
--- a/src/modules/m_spanningtree/protocolinterface.cpp
+++ b/src/modules/m_spanningtree/protocolinterface.cpp
@@ -68,28 +68,25 @@ void SpanningTreeProtocolInterface::SendTopic(Channel* channel, std::string &top
        Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC", params);
 }
 
-void SpanningTreeProtocolInterface::SendMode(const std::string &target, parameterlist &modedata)
+void SpanningTreeProtocolInterface::SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &translate)
 {
        if (modedata.empty())
                return;
 
        std::string outdata;
-
-       /* Warning: in-place translation is only safe for type TR_NICK */
-       for (size_t n = 0; n < modedata.size(); n++)
-       {
-               ServerInstance->Parser->TranslateUIDs(TR_NICK, modedata[n], outdata);
-               modedata[n] = outdata;
-       }
+       ServerInstance->Parser->TranslateUIDs(translate, modedata, outdata);
 
        std::string uidtarget;
        ServerInstance->Parser->TranslateUIDs(TR_NICK, target, uidtarget);
-       modedata.insert(modedata.begin(), uidtarget);
+
+       parameterlist outlist;
+       outlist.push_back(uidtarget);
+       outlist.push_back(outdata);
 
        User* a = ServerInstance->FindNick(uidtarget);
        if (a)
        {
-               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",modedata);
+               Utils->DoOneToMany(ServerInstance->Config->GetSID(),"MODE",outlist);
                return;
        }
        else
@@ -97,8 +94,8 @@ void SpanningTreeProtocolInterface::SendMode(const std::string &target, paramete
                Channel* c = ServerInstance->FindChan(target);
                if (c)
                {
-                       modedata.insert(modedata.begin() + 1, ConvToStr(c->age));
-                       Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",modedata);
+                       outlist.insert(outlist.begin() + 1, ConvToStr(c->age));
+                       Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FMODE",outlist);
                }
        }
 }

diff --git a/src/modules/m_spanningtree/protocolinterface.h b/src/modules/m_spanningtree/protocolinterface.h
index 50db7bf053c156e2e1634cca9c085d1b8b771fca..24b0cee2031bb596872b707b2aff7760cc9ade7a 100644 (file)
--- a/src/modules/m_spanningtree/protocolinterface.h
+++ b/src/modules/m_spanningtree/protocolinterface.h
@@ -16,7 +16,7 @@ class SpanningTreeProtocolInterface : public ProtocolInterface
        virtual void SendEncapsulatedData(parameterlist &encap);
        virtual void SendMetaData(void* target, TargetTypeFlags type, const std::string &key, const std::string &data);
        virtual void SendTopic(Channel* channel, std::string &topic);
-       virtual void SendMode(const std::string &target, parameterlist &modedata);
+       virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &types);
        virtual void SendModeNotice(const std::string &modes, const std::string &text);
        virtual void SendSNONotice(const std::string &snomask, const std::string &text);
        virtual void PushToClient(User* target, const std::string &rawline);