Release v3.0.0 alpha 8.

[user/henk/code/inspircd.git] / src / users.cpp

diff --git a/src/users.cpp b/src/users.cpp
index b3546a134c9890f6380b71e10d634a301f46e05a..1e2554107b1905c1d1a9bb1f30918e2c85330ebb 100644 (file)
--- a/src/users.cpp
+++ b/src/users.cpp
@@ -227,37 +227,56 @@ void UserIOHandler::OnDataReady()
                        user->nick.c_str(), (unsigned long)recvq.length(), user->MyClass->GetRecvqMax());
                return;
        }
+
        unsigned long sendqmax = ULONG_MAX;
        if (!user->HasPrivPermission("users/flood/increased-buffers"))
                sendqmax = user->MyClass->GetSendqSoftMax();
+
        unsigned long penaltymax = ULONG_MAX;
        if (!user->HasPrivPermission("users/flood/no-fakelag"))
                penaltymax = user->MyClass->GetPenaltyThreshold() * 1000;
 
+       // The maximum size of an IRC message minus the terminating CR+LF.
+       const size_t maxmessage = ServerInstance->Config->Limits.MaxLine - 2;
+       std::string line;
+       line.reserve(maxmessage);
+
+       bool eol_found;
+       std::string::size_type qpos;
+
        while (user->CommandFloodPenalty < penaltymax && getSendQSize() < sendqmax)
        {
-               std::string line;
-               line.reserve(ServerInstance->Config->Limits.MaxLine);
-               std::string::size_type qpos = 0;
-               while (qpos < recvq.length())
+               qpos = 0;
+               eol_found = false;
+
+               const size_t qlen = recvq.length();
+               while (qpos < qlen)
                {
                        char c = recvq[qpos++];
                        switch (c)
                        {
-                       case '\0':
-                               c = ' ';
-                               break;
-                       case '\r':
-                               continue;
-                       case '\n':
-                               goto eol_found;
+                               case '\0':
+                                       c = ' ';
+                                       break;
+                               case '\r':
+                                       continue;
+                               case '\n':
+                                       eol_found = true;
+                                       break;
                        }
-                       if (line.length() < ServerInstance->Config->Limits.MaxLine - 2)
+
+                       if (eol_found)
+                               break;
+
+                       if (line.length() < maxmessage)
                                line.push_back(c);
                }
-               // if we got here, the recvq ran out before we found a newline
-               return;
-eol_found:
+
+               // if we return here, we haven't found a newline and make no modifications to recvq
+               // so we can wait for more data
+               if (!eol_found)
+                       return;
+
                // just found a newline. Terminate the string, and pull it out of recvq
                recvq.erase(0, qpos);
 
@@ -269,7 +288,11 @@ eol_found:
                ServerInstance->Parser.ProcessBuffer(line, user);
                if (user->quitting)
                        return;
+
+               // clear() does not reclaim memory associated with the string, so our .reserve() call is safe
+               line.clear();
        }
+
        if (user->CommandFloodPenalty >= penaltymax && !user->MyClass->fakelag)
                ServerInstance->Users->QuitUser(user, "Excess Flood");
 }
@@ -435,6 +458,7 @@ void User::UnOper()
 
        ModeHandler* opermh = ServerInstance->Modes->FindMode('o', MODETYPE_USER);
        this->SetMode(opermh, false);
+       FOREACH_MOD(OnPostDeoper, (this));
 }
 
 /*
@@ -622,8 +646,8 @@ bool User::ChangeNick(const std::string& newnick, time_t newts)
        }
 
        if (this->registered == REG_ALL)
-               this->WriteCommon("NICK %s",newnick.c_str());
-       std::string oldnick = nick;
+               this->WriteCommon("NICK %s", newnick.c_str());
+       const std::string oldnick = nick;
        nick = newnick;
 
        InvalidateCache();
@@ -648,14 +672,7 @@ void LocalUser::OverruleNick()
 
 int LocalUser::GetServerPort()
 {
-       switch (this->server_sa.sa.sa_family)
-       {
-               case AF_INET6:
-                       return htons(this->server_sa.in6.sin6_port);
-               case AF_INET:
-                       return htons(this->server_sa.in4.sin_port);
-       }
-       return 0;
+       return this->server_sa.port();
 }
 
 const std::string& User::GetIPString()
@@ -751,10 +768,12 @@ void LocalUser::Write(const std::string& text)
        if (!SocketEngine::BoundsCheckFd(&eh))
                return;
 
-       if (text.length() > ServerInstance->Config->Limits.MaxLine - 2)
+       // The maximum size of an IRC message minus the terminating CR+LF.
+       const size_t maxmessage = ServerInstance->Config->Limits.MaxLine - 2;
+       if (text.length() > maxmessage)
        {
-               // this should happen rarely or never. Crop the string at 512 and try again.
-               std::string try_again(text, 0, ServerInstance->Config->Limits.MaxLine - 2);
+               // This should happen rarely or never. Crop the string at MaxLine and try again.
+               std::string try_again(text, 0, maxmessage);
                Write(try_again);
                return;
        }
@@ -764,8 +783,9 @@ void LocalUser::Write(const std::string& text)
        eh.AddWriteBuf(text);
        eh.AddWriteBuf(wide_newline);
 
-       ServerInstance->stats.Sent += text.length() + 2;
-       this->bytes_out += text.length() + 2;
+       const size_t bytessent = text.length() + 2;
+       ServerInstance->stats.Sent += bytessent;
+       this->bytes_out += bytessent;
        this->cmds_out++;
 }
 
@@ -1018,15 +1038,27 @@ bool User::ChangeDisplayedHost(const std::string& shost)
 
 void User::ChangeRealHost(const std::string& host, bool resetdisplay)
 {
-       if (displayhost == host)
+       // If the real host is the new host and we are not resetting the
+       // display host then we have nothing to do.
+       const bool changehost = (realhost != host);
+       if (!changehost && !resetdisplay)
                return;
        
+       // If the displayhost is not set and we are not resetting it then
+       // we need to copy it to the displayhost field.
        if (displayhost.empty() && !resetdisplay)
                displayhost = realhost;
 
+       // If the displayhost is the new host or we are resetting it then
+       // we clear its contents to save memory.
        else if (displayhost == host || resetdisplay)
                displayhost.clear();
 
+       // If we are just resetting the display host then we don't need to
+       // do anything else.
+       if (!changehost)
+               return;
+
        realhost = host;
        this->InvalidateCache();
 }