Convert a few missing

[user/henk/code/inspircd.git] / src / modules / m_spanningtree / fjoin.cpp

diff --git a/src/modules/m_spanningtree/fjoin.cpp b/src/modules/m_spanningtree/fjoin.cpp
index 0f33d65bdeebb753be2c70a0222a7fbbd572031f..070051a9c58768604e33c180ad0fd6fec1f054f9 100644 (file)
--- a/src/modules/m_spanningtree/fjoin.cpp
+++ b/src/modules/m_spanningtree/fjoin.cpp
@@ -21,7 +21,7 @@
 /* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
 
 
-/** FJOIN, similar to TS6 SJOIN, but not quite. */
+/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */
 bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &params)
 {
        /* 1.1 FJOIN works as follows:
@@ -57,23 +57,22 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
         * the losing side sends any modes for the channel which shouldnt win,
         * they wont as their timestamp will be too high :-)
         */
-
-       if (params.size() < 2)
+       if (params.size() < 3)
                return true;
 
        irc::modestacker modestack(true);                               /* Modes to apply from the users in the user list */
        User* who = NULL;                                               /* User we are currently checking */
        std::string channel = params[0];                                /* Channel name, as a string */
        time_t TS = atoi(params[1].c_str());                            /* Timestamp given to us for remote side */
-       irc::tokenstream users((params.size() > 2) ? params[2] : "");   /* users from the user list */
+       irc::tokenstream users((params.size() > 3) ? params[params.size() - 1] : "");   /* users from the user list */
        bool apply_other_sides_modes = true;                            /* True if we are accepting the other side's modes */
        Channel* chan = this->Instance->FindChan(channel);              /* The channel we're sending joins to */
        time_t ourTS = chan ? chan->age : Instance->Time()+600; /* The TS of our side of the link */
        bool created = !chan;                                           /* True if the channel doesnt exist here yet */
        std::string item;                                               /* One item in the list of nicks */
 
-       if (params.size() > 2)
-               params[2] = ":" + params[2];
+       if (params.size() > 3)
+               params[params.size() - 1] = ":" + params[params.size() - 1];
                
        Utils->DoOneToAllButSender(source,"FJOIN",params,source);
 
@@ -96,7 +95,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
        {
                std::deque<std::string> param_list;
                if (Utils->AnnounceTSChange && chan)
-                       chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, ourTS, TS);
+                       chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name, chan->name, (unsigned long) ourTS, (unsigned long) TS);
                ourTS = TS;
                if (!created)
                {
@@ -106,7 +105,26 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
                }
        }
 
-       /* Now, process every 'prefixes,nick' pair */
+       /* First up, apply their modes if they won the TS war */
+       if (apply_other_sides_modes)
+       {
+               unsigned int idx = 2;
+               int numpara = 1;
+               std::vector<std::string> modelist;
+
+               // Mode parser needs to know what channel to act on.
+               modelist[0] = params[0];
+
+               /* Remember, params[params.size() - 1] is nicklist, and we don't want to apply *that* */
+               for (idx = 2; idx != (params.size() - 1); idx++)
+               {
+                       modelist[numpara++] = params[idx];
+               }
+
+               this->Instance->SendMode(modelist, this->Instance->FakeClient);
+       }
+
+       /* Now, process every 'modes,nick' pair */
        while (users.GetToken(item))
        {
                const char* usr = item.c_str();
@@ -124,7 +142,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
                                        modes += *unparsedmodes;
                                else
                                {
-                                       this->SendError(std::string("Invalid prefix '")+(*unparsedmodes)+"' in FJOIN");
+                                       this->SendError(std::string("Unknown status mode '")+(*unparsedmodes)+"' in FJOIN");
                                        return false;
                                }
 
@@ -152,7 +170,7 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
                        }
                        else
                        {
-                               Instance->Logs->Log("m_spanningtree",SPARSE,"Warning! Invalid user %s in FJOIN to channel %s IGNORED", usr, channel.c_str());
+                               Instance->Logs->Log("m_spanningtree",SPARSE, "Ignored nonexistant user %s in fjoin to %s (probably quit?)", usr, channel.c_str());
                                continue;
                        }
                }
@@ -162,16 +180,16 @@ bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> &p
        if (apply_other_sides_modes)
        {
                std::deque<std::string> stackresult;
-               const char* mode_junk[MAXMODES+2];
-               mode_junk[0] = channel.c_str();
+               std::vector<std::string> mode_junk;
+               mode_junk[0] = channel;
 
                while (modestack.GetStackedLine(stackresult))
                {
                        for (size_t j = 0; j < stackresult.size(); j++)
                        {
-                               mode_junk[j+1] = stackresult[j].c_str();
+                               mode_junk[j+1] = stackresult[j];
                        }
-                       Instance->SendMode(mode_junk, stackresult.size() + 1, Instance->FakeClient);
+                       Instance->SendMode(mode_junk, Instance->FakeClient);
                }
        }
 
@@ -189,11 +207,29 @@ bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque<std::string>
 
        if (c)
        {
-               for (char modeletter = 'A'; modeletter <= 'z'; modeletter++)
+               irc::modestacker stack(false);
+               std::deque<std::string> stackresult;
+               std::vector<std::string> mode_junk;
+               mode_junk[0] = c->name;
+
+               for (char modeletter = 'A'; modeletter <= 'z'; ++modeletter)
                {
                        ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL);
+
+                       /* Passing a pointer to a modestacker here causes the mode to be put onto the mode stack,
+                        * rather than applied immediately. Module unloads require this to be done immediately,
+                        * for this function we require tidyness instead. Fixes bug #493
+                        */
                        if (mh)
-                               mh->RemoveMode(c);
+                               mh->RemoveMode(c, &stack);
+               }
+
+               while (stack.GetStackedLine(stackresult))
+               {
+                       for (size_t j = 0; j < stackresult.size(); j++)
+                               mode_junk[j+1] = stackresult[j];
+
+                       Instance->SendMode(mode_junk, Instance->FakeClient);
                }
        }
        return true;