X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fcoreuserinputhandler.cpp;h=0b6e5b73995b48e45e6ccf09f26143f5da240f02;hp=4f551f1c42ad6fac35105d117f5cd16f72f6590b;hb=HEAD;hpb=40601ae070413b727a68e35e5b8c619176c661b1

diff --git a/src/core/coreuserinputhandler.cpp b/src/core/coreuserinputhandler.cpp
index 4f551f1c..5c6f388f 100644
--- a/src/core/coreuserinputhandler.cpp
+++ b/src/core/coreuserinputhandler.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2014 by the Quassel Project                        *
+ *   Copyright (C) 2005-2022 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -20,23 +20,20 @@
 
 #include "coreuserinputhandler.h"
 
-#include "util.h"
+#include <QRegExp>
 
 #include "ctcpparser.h"
-
-#include <QRegExp>
+#include "util.h"
 
 #ifdef HAVE_QCA2
-#  include "cipher.h"
+#    include "cipher.h"
 #endif
 
-CoreUserInputHandler::CoreUserInputHandler(CoreNetwork *parent)
+CoreUserInputHandler::CoreUserInputHandler(CoreNetwork* parent)
     : CoreBasicHandler(parent)
-{
-}
+{}
 
-
-void CoreUserInputHandler::handleUserInput(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleUserInput(const BufferInfo& bufferInfo, const QString& msg)
 {
     if (msg.isEmpty())
         return;
@@ -50,39 +47,45 @@ void CoreUserInputHandler::handleUserInput(const BufferInfo &bufferInfo, const Q
     }
 }
 
-
 // ====================
 //  Public Slots
 // ====================
-void CoreUserInputHandler::handleAway(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleAway(const BufferInfo& bufferInfo, const QString& msg, const bool skipFormatting)
 {
     Q_UNUSED(bufferInfo)
     if (msg.startsWith("-all")) {
         if (msg.length() == 4) {
-            coreSession()->globalAway();
+            coreSession()->globalAway(QString(), skipFormatting);
             return;
         }
         Q_ASSERT(msg.length() > 4);
         if (msg[4] == ' ') {
-            coreSession()->globalAway(msg.mid(5));
+            coreSession()->globalAway(msg.mid(5), skipFormatting);
             return;
         }
     }
-    issueAway(msg);
+    issueAway(msg, true /* force away */, skipFormatting);
 }
 
-
-void CoreUserInputHandler::issueAway(const QString &msg, bool autoCheck)
+void CoreUserInputHandler::issueAway(const QString& msg, bool autoCheck, const bool skipFormatting)
 {
     QString awayMsg = msg;
-    IrcUser *me = network()->me();
+    IrcUser* me = network()->me();
+
+    // Only apply timestamp formatting when requested
+    // This avoids re-processing any existing away message when the core restarts, so chained escape
+    // percent signs won't get down-processed.
+    if (!skipFormatting) {
+        // Apply the timestamp formatting to the away message (if empty, nothing will happen)
+        awayMsg = formatCurrentDateTimeInString(awayMsg);
+    }
 
     // if there is no message supplied we have to check if we are already away or not
     if (autoCheck && msg.isEmpty()) {
         if (me && !me->isAway()) {
-            Identity *identity = network()->identityPtr();
+            Identity* identity = network()->identityPtr();
             if (identity) {
-                awayMsg = identity->awayReason();
+                awayMsg = formatCurrentDateTimeInString(identity->awayReason());
             }
             if (awayMsg.isEmpty()) {
                 awayMsg = tr("away");
@@ -95,20 +98,17 @@ void CoreUserInputHandler::issueAway(const QString &msg, bool autoCheck)
     putCmd("AWAY", serverEncode(awayMsg));
 }
 
-
-void CoreUserInputHandler::handleBan(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleBan(const BufferInfo& bufferInfo, const QString& msg)
 {
     banOrUnban(bufferInfo, msg, true);
 }
 
-
-void CoreUserInputHandler::handleUnban(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleUnban(const BufferInfo& bufferInfo, const QString& msg)
 {
     banOrUnban(bufferInfo, msg, false);
 }
 
-
-void CoreUserInputHandler::banOrUnban(const BufferInfo &bufferInfo, const QString &msg, bool ban)
+void CoreUserInputHandler::banOrUnban(const BufferInfo& bufferInfo, const QString& msg, bool ban)
 {
     QString banChannel;
     QString banUser;
@@ -122,26 +122,36 @@ void CoreUserInputHandler::banOrUnban(const BufferInfo &bufferInfo, const QStrin
         banChannel = bufferInfo.bufferName();
     }
     else {
-        emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", QString("Error: channel unknown in command: /BAN %1").arg(msg));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            BufferInfo::StatusBuffer,
+            "",
+            QString("Error: channel unknown in command: /BAN %1").arg(msg)
+        ));
         return;
     }
 
     if (!params.isEmpty() && !params.contains("!") && network()->ircUser(params[0])) {
-        IrcUser *ircuser = network()->ircUser(params[0]);
+        IrcUser* ircuser = network()->ircUser(params[0]);
         // generalizedHost changes <nick> to  *!ident@*.sld.tld.
         QString generalizedHost = ircuser->host();
         if (generalizedHost.isEmpty()) {
-            emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", QString("Error: host unknown in command: /BAN %1").arg(msg));
+            emit displayMsg(NetworkInternalMessage(
+                Message::Error,
+                BufferInfo::StatusBuffer,
+                "",
+                QString("Error: host unknown in command: /BAN %1").arg(msg)
+            ));
             return;
         }
 
-        static QRegExp ipAddress("\\d+\\.\\d+\\.\\d+\\.\\d+");
-        if (ipAddress.exactMatch(generalizedHost))    {
+        static QRegExp ipAddress(R"(\d+\.\d+\.\d+\.\d+)");
+        if (ipAddress.exactMatch(generalizedHost)) {
             int lastDotPos = generalizedHost.lastIndexOf('.') + 1;
             generalizedHost.replace(lastDotPos, generalizedHost.length() - lastDotPos, '*');
         }
-        else if (generalizedHost.lastIndexOf(".") != -1 && generalizedHost.lastIndexOf(".", generalizedHost.lastIndexOf(".")-1) != -1) {
-            int secondLastPeriodPosition = generalizedHost.lastIndexOf(".", generalizedHost.lastIndexOf(".")-1);
+        else if (generalizedHost.lastIndexOf(".") != -1 && generalizedHost.lastIndexOf(".", generalizedHost.lastIndexOf(".") - 1) != -1) {
+            int secondLastPeriodPosition = generalizedHost.lastIndexOf(".", generalizedHost.lastIndexOf(".") - 1);
             generalizedHost.replace(0, secondLastPeriodPosition, "*");
         }
         banUser = QString("*!%1@%2").arg(ircuser->user(), generalizedHost);
@@ -155,8 +165,7 @@ void CoreUserInputHandler::banOrUnban(const BufferInfo &bufferInfo, const QStrin
     emit putRawLine(serverEncode(banMsg));
 }
 
-
-void CoreUserInputHandler::handleCtcp(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleCtcp(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
 
@@ -169,20 +178,24 @@ void CoreUserInputHandler::handleCtcp(const BufferInfo &bufferInfo, const QStrin
     QString verboseMessage = tr("sending CTCP-%1 request to %2").arg(ctcpTag).arg(nick);
 
     if (ctcpTag == "PING") {
-#if QT_VERSION >= 0x040700
         message = QString::number(QDateTime::currentMSecsSinceEpoch());
-#else
-        message = QString::number(QDateTime::currentDateTime().toTime_t());
-#endif
     }
 
     // FIXME make this a proper event
     coreNetwork()->coreSession()->ctcpParser()->query(coreNetwork(), nick, ctcpTag, message);
-    emit displayMsg(Message::Action, BufferInfo::StatusBuffer, "", verboseMessage, network()->myNick());
+    if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+        emit displayMsg(NetworkInternalMessage(
+            Message::Action,
+            BufferInfo::StatusBuffer,
+            "",
+            verboseMessage,
+            network()->myNick(),
+            Message::Flag::Self
+        ));
+    }
 }
 
-
-void CoreUserInputHandler::handleDelkey(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleDelkey(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString bufname = bufferInfo.bufferName().isNull() ? "" : bufferInfo.bufferName();
 #ifdef HAVE_QCA2
@@ -190,7 +203,12 @@ void CoreUserInputHandler::handleDelkey(const BufferInfo &bufferInfo, const QStr
         return;
 
     if (!Cipher::neededFeaturesAvailable()) {
-        emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            typeByTarget(bufname),
+            bufname,
+            tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin.")
+        ));
         return;
     }
 
@@ -200,98 +218,119 @@ void CoreUserInputHandler::handleDelkey(const BufferInfo &bufferInfo, const QStr
         parms.prepend(bufferInfo.bufferName());
 
     if (parms.isEmpty()) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname,
-            tr("[usage] /delkey <nick|channel> deletes the encryption key for nick or channel or just /delkey when in a channel or query."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("[usage] /delkey <nick|channel> deletes the encryption key for nick or channel or just /delkey when in a "
+               "channel or query.")
+        ));
         return;
     }
 
     QString target = parms.at(0);
 
     if (network()->cipherKey(target).isEmpty()) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("No key has been set for %1.").arg(target));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("No key has been set for %1.").arg(target)
+        ));
         return;
     }
 
     network()->setCipherKey(target, QByteArray());
-    emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("The key for %1 has been deleted.").arg(target));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Info,
+        typeByTarget(bufname),
+        bufname,
+        tr("The key for %1 has been deleted.").arg(target)
+    ));
 
 #else
     Q_UNUSED(msg)
-    emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: Setting an encryption key requires Quassel to have been built "
-                                                                    "with support for the Qt Cryptographic Architecture (QCA2) library. "
-                                                                    "Contact your distributor about a Quassel package with QCA2 "
-                                                                    "support, or rebuild Quassel with QCA2 present."));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Error,
+        typeByTarget(bufname),
+        bufname,
+        tr("Error: Setting an encryption key requires Quassel to have been built "
+           "with support for the Qt Cryptographic Architecture (QCA2) library. "
+           "Contact your distributor about a Quassel package with QCA2 "
+           "support, or rebuild Quassel with QCA2 present.")
+    ));
 #endif
 }
 
-void CoreUserInputHandler::doMode(const BufferInfo &bufferInfo, const QChar& addOrRemove, const QChar& mode, const QString &nicks)
+void CoreUserInputHandler::doMode(const BufferInfo& bufferInfo, const QChar& addOrRemove, const QChar& mode, const QString& nicks)
 {
-    QString m;
     bool isNumber;
     int maxModes = network()->support("MODES").toInt(&isNumber);
-    if (!isNumber || maxModes == 0) maxModes = 1;
+    if (!isNumber || maxModes == 0)
+        maxModes = 1;
 
     QStringList nickList;
-    if (nicks == "*") { // All users in channel
+    if (nicks == "*" && bufferInfo.type() == BufferInfo::ChannelBuffer) {  // All users in channel
         const QList<IrcUser*> users = network()->ircChannel(bufferInfo.bufferName())->ircUsers();
-        foreach(IrcUser *user, users) {
+        for (IrcUser* user : users) {
             if ((addOrRemove == '+' && !network()->ircChannel(bufferInfo.bufferName())->userModes(user).contains(mode))
                 || (addOrRemove == '-' && network()->ircChannel(bufferInfo.bufferName())->userModes(user).contains(mode)))
                 nickList.append(user->nick());
         }
-    } else {
+    }
+    else {
         nickList = nicks.split(' ', QString::SkipEmptyParts);
     }
 
-    if (nickList.count() == 0) return;
+    if (nickList.count() == 0)
+        return;
 
     while (!nickList.isEmpty()) {
         int amount = qMin(nickList.count(), maxModes);
-        QString m = addOrRemove; for(int i = 0; i < amount; i++) m += mode;
+        QString m = addOrRemove;
+        for (int i = 0; i < amount; i++)
+            m += mode;
         QStringList params;
         params << bufferInfo.bufferName() << m;
-        for(int i = 0; i < amount; i++) params << nickList.takeFirst();
+        for (int i = 0; i < amount; i++)
+            params << nickList.takeFirst();
         emit putCmd("MODE", serverEncode(params));
     }
 }
 
-
-void CoreUserInputHandler::handleDeop(const BufferInfo &bufferInfo, const QString &nicks)
+void CoreUserInputHandler::handleDeop(const BufferInfo& bufferInfo, const QString& nicks)
 {
     doMode(bufferInfo, '-', 'o', nicks);
 }
 
-
-void CoreUserInputHandler::handleDehalfop(const BufferInfo &bufferInfo, const QString &nicks)
+void CoreUserInputHandler::handleDehalfop(const BufferInfo& bufferInfo, const QString& nicks)
 {
     doMode(bufferInfo, '-', 'h', nicks);
 }
 
-
-void CoreUserInputHandler::handleDevoice(const BufferInfo &bufferInfo, const QString &nicks)
+void CoreUserInputHandler::handleDevoice(const BufferInfo& bufferInfo, const QString& nicks)
 {
     doMode(bufferInfo, '-', 'v', nicks);
 }
 
-void CoreUserInputHandler::handleHalfop(const BufferInfo &bufferInfo, const QString &nicks)
+void CoreUserInputHandler::handleHalfop(const BufferInfo& bufferInfo, const QString& nicks)
 {
     doMode(bufferInfo, '+', 'h', nicks);
 }
 
-void CoreUserInputHandler::handleOp(const BufferInfo &bufferInfo, const QString &nicks) {
-  doMode(bufferInfo, '+', 'o', nicks);
+void CoreUserInputHandler::handleOp(const BufferInfo& bufferInfo, const QString& nicks)
+{
+    doMode(bufferInfo, '+', 'o', nicks);
 }
 
-
-void CoreUserInputHandler::handleInvite(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleInvite(const BufferInfo& bufferInfo, const QString& msg)
 {
     QStringList params;
     params << msg << bufferInfo.bufferName();
     emit putCmd("INVITE", serverEncode(params));
 }
 
-
-void CoreUserInputHandler::handleJoin(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleJoin(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo);
 
@@ -318,7 +357,7 @@ void CoreUserInputHandler::handleJoin(const BufferInfo &bufferInfo, const QStrin
         }
     }
 
-    static const char *cmd = "JOIN";
+    static const char* cmd = "JOIN";
     i = 0;
     QStringList joinChans, joinKeys;
     int slicesize = chans.count();
@@ -352,8 +391,7 @@ void CoreUserInputHandler::handleJoin(const BufferInfo &bufferInfo, const QStrin
     }
 }
 
-
-void CoreUserInputHandler::handleKeyx(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleKeyx(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString bufname = bufferInfo.bufferName().isNull() ? "" : bufferInfo.bufferName();
 #ifdef HAVE_QCA2
@@ -361,7 +399,12 @@ void CoreUserInputHandler::handleKeyx(const BufferInfo &bufferInfo, const QStrin
         return;
 
     if (!Cipher::neededFeaturesAvailable()) {
-        emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            typeByTarget(bufname),
+            bufname,
+            tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin.")
+        ));
         return;
     }
 
@@ -370,42 +413,65 @@ void CoreUserInputHandler::handleKeyx(const BufferInfo &bufferInfo, const QStrin
     if (parms.count() == 0 && !bufferInfo.bufferName().isEmpty() && bufferInfo.acceptsRegularMessages())
         parms.prepend(bufferInfo.bufferName());
     else if (parms.count() != 1) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname,
-            tr("[usage] /keyx [<nick>] Initiates a DH1080 key exchange with the target."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("[usage] /keyx [<nick>] Initiates a DH1080 key exchange with the target.")
+        ));
         return;
     }
 
     QString target = parms.at(0);
 
     if (network()->isChannelName(target)) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("It is only possible to exchange keys in a query buffer."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("It is only possible to exchange keys in a query buffer.")
+        ));
         return;
     }
 
-    Cipher *cipher = network()->cipher(target);
-    if (!cipher) // happens when there is no CoreIrcChannel for the target
+    Cipher* cipher = network()->cipher(target);
+    if (!cipher)  // happens when there is no CoreIrcChannel for the target
         return;
 
     QByteArray pubKey = cipher->initKeyExchange();
     if (pubKey.isEmpty())
-        emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Failed to initiate key exchange with %1.").arg(target));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            typeByTarget(bufname),
+            bufname,
+            tr("Failed to initiate key exchange with %1.").arg(target)
+        ));
     else {
         QList<QByteArray> params;
         params << serverEncode(target) << serverEncode("DH1080_INIT ") + pubKey;
         emit putCmd("NOTICE", params);
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("Initiated key exchange with %1.").arg(target));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("Initiated key exchange with %1.").arg(target)
+        ));
     }
 #else
     Q_UNUSED(msg)
-    emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: Setting an encryption key requires Quassel to have been built "
-                                                                "with support for the Qt Cryptographic Architecture (QCA) library. "
-                                                                "Contact your distributor about a Quassel package with QCA "
-                                                                "support, or rebuild Quassel with QCA present."));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Error,
+        typeByTarget(bufname),
+        bufname,
+        tr("Error: Setting an encryption key requires Quassel to have been built "
+           "with support for the Qt Cryptographic Architecture (QCA) library. "
+           "Contact your distributor about a Quassel package with QCA "
+           "support, or rebuild Quassel with QCA present.")
+    ));
 #endif
 }
 
-
-void CoreUserInputHandler::handleKick(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleKick(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString nick = msg.section(' ', 0, 0, QString::SectionSkipEmpty);
     QString reason = msg.section(' ', 1, -1, QString::SectionSkipEmpty).trimmed();
@@ -417,8 +483,7 @@ void CoreUserInputHandler::handleKick(const BufferInfo &bufferInfo, const QStrin
     emit putCmd("KICK", params);
 }
 
-
-void CoreUserInputHandler::handleKill(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleKill(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     QString nick = msg.section(' ', 0, 0, QString::SectionSkipEmpty);
@@ -428,93 +493,127 @@ void CoreUserInputHandler::handleKill(const BufferInfo &bufferInfo, const QStrin
     emit putCmd("KILL", params);
 }
 
-
-void CoreUserInputHandler::handleList(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleList(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putCmd("LIST", serverEncode(msg.split(' ', QString::SkipEmptyParts)));
 }
 
-
-void CoreUserInputHandler::handleMe(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleMe(const BufferInfo& bufferInfo, const QString& msg)
 {
     if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages())
         return;  // server buffer
     // FIXME make this a proper event
-    coreNetwork()->coreSession()->ctcpParser()->query(coreNetwork(), bufferInfo.bufferName(), "ACTION", msg);
-    emit displayMsg(Message::Action, bufferInfo.type(), bufferInfo.bufferName(), msg, network()->myNick(), Message::Self);
-}
 
+    // Split apart messages at line feeds.  The IRC protocol uses those to separate commands, so
+    // they need to be split into multiple messages.
+    QStringList messages = msg.split(QChar::LineFeed);
+
+    for (const auto& message : messages) {
+        // Handle each separated message independently
+        coreNetwork()->coreSession()->ctcpParser()->query(coreNetwork(), bufferInfo.bufferName(), "ACTION", message);
+        if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+            emit displayMsg(NetworkInternalMessage(
+                Message::Action,
+                bufferInfo.type(),
+                bufferInfo.bufferName(),
+                message,
+                network()->myNick(),
+                Message::Self
+            ));
+        }
+    }
+}
 
-void CoreUserInputHandler::handleMode(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleMode(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
 
     QStringList params = msg.split(' ', QString::SkipEmptyParts);
-    // if the first argument is neither a channel nor us (user modes are only to oneself) the current buffer is assumed to be the target
     if (!params.isEmpty()) {
-        if (!network()->isChannelName(params[0]) && !network()->isMyNick(params[0]))
-            params.prepend(bufferInfo.bufferName());
-        if (network()->isMyNick(params[0]) && params.count() == 2)
-            network()->updateIssuedModes(params[1]);
         if (params[0] == "-reset" && params.count() == 1) {
-            // FIXME: give feedback to the user (I don't want to add new strings right now)
             network()->resetPersistentModes();
+            emit displayMsg(NetworkInternalMessage(
+                Message::Info,
+                BufferInfo::StatusBuffer,
+                "",
+                tr("Your persistent modes have been reset.")
+            ));
             return;
         }
+        if (!network()->isChannelName(params[0]) && !network()->isMyNick(params[0]))
+            // If the first argument is neither a channel nor us (user modes are only to oneself)
+            // the current buffer is assumed to be the target.
+            // If the current buffer returns no name (e.g. status buffer), assume target is us.
+            params.prepend(!bufferInfo.bufferName().isEmpty() ? bufferInfo.bufferName() : network()->myNick());
+        if (network()->isMyNick(params[0]) && params.count() == 2)
+            network()->updateIssuedModes(params[1]);
     }
 
     // TODO handle correct encoding for buffer modes (channelEncode())
     emit putCmd("MODE", serverEncode(params));
 }
 
-
 // TODO: show privmsgs
-void CoreUserInputHandler::handleMsg(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleMsg(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo);
     if (!msg.contains(' '))
         return;
 
     QString target = msg.section(' ', 0, 0);
-    QByteArray encMsg = userEncode(target, msg.section(' ', 1));
+    QString msgSection = msg.section(' ', 1);
+
+    std::function<QByteArray(const QString&, const QString&)> encodeFunc =
+        [this](const QString& target, const QString& message) -> QByteArray { return userEncode(target, message); };
 
 #ifdef HAVE_QCA2
-    putPrivmsg(serverEncode(target), encMsg, network()->cipher(target));
+    putPrivmsg(target, msgSection, encodeFunc, network()->cipher(target));
 #else
-    putPrivmsg(serverEncode(target), encMsg);
+    putPrivmsg(target, msgSection, encodeFunc);
 #endif
 }
 
-
-void CoreUserInputHandler::handleNick(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleNick(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     QString nick = msg.section(' ', 0, 0);
     emit putCmd("NICK", serverEncode(nick));
 }
 
-
-void CoreUserInputHandler::handleNotice(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleNotice(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString bufferName = msg.section(' ', 0, 0);
-    QString payload = msg.section(' ', 1);
     QList<QByteArray> params;
-    params << serverEncode(bufferName) << channelEncode(bufferInfo.bufferName(), payload);
-    emit putCmd("NOTICE", params);
-    emit displayMsg(Message::Notice, typeByTarget(bufferName), bufferName, payload, network()->myNick(), Message::Self);
+    // Split apart messages at line feeds.  The IRC protocol uses those to separate commands, so
+    // they need to be split into multiple messages.
+    QStringList messages = msg.section(' ', 1).split(QChar::LineFeed);
+
+    for (const auto& message : messages) {
+        // Handle each separated message independently
+        params.clear();
+        params << serverEncode(bufferName) << channelEncode(bufferInfo.bufferName(), message);
+        emit putCmd("NOTICE", params);
+        if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+            emit displayMsg(NetworkInternalMessage(
+                Message::Notice,
+                typeByTarget(bufferName),
+                bufferName,
+                message,
+                network()->myNick(),
+                Message::Self
+            ));
+        }
+    }
 }
 
-
-
-void CoreUserInputHandler::handleOper(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleOper(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putRawLine(serverEncode(QString("OPER %1").arg(msg)));
 }
 
-
-void CoreUserInputHandler::handlePart(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handlePart(const BufferInfo& bufferInfo, const QString& msg)
 {
     QList<QByteArray> params;
     QString partReason;
@@ -536,8 +635,7 @@ void CoreUserInputHandler::handlePart(const BufferInfo &bufferInfo, const QStrin
     emit putCmd("PART", params);
 }
 
-
-void CoreUserInputHandler::handlePing(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handlePing(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
 
@@ -545,60 +643,116 @@ void CoreUserInputHandler::handlePing(const BufferInfo &bufferInfo, const QStrin
     if (param.isEmpty())
         param = QTime::currentTime().toString("hh:mm:ss.zzz");
 
-    putCmd("PING", serverEncode(param));
+    // Take priority so this won't get stuck behind other queued messages.
+    putCmd("PING", serverEncode(param), {}, {}, true);
 }
 
+void CoreUserInputHandler::handlePrint(const BufferInfo& bufferInfo, const QString& msg)
+{
+    if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages())
+        return;  // server buffer
+
+    QByteArray encMsg = channelEncode(bufferInfo.bufferName(), msg);
+    emit displayMsg(NetworkInternalMessage(
+        Message::Info,
+        bufferInfo.type(),
+        bufferInfo.bufferName(),
+        msg,
+        network()->myNick(),
+        Message::Self
+    ));
+}
 
 // TODO: implement queries
-void CoreUserInputHandler::handleQuery(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleQuery(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     QString target = msg.section(' ', 0, 0);
-    QString message = msg.section(' ', 1);
-    if (message.isEmpty())
-        emit displayMsg(Message::Server, BufferInfo::QueryBuffer, target, tr("Starting query with %1").arg(target), network()->myNick(), Message::Self);
-    else
-        emit displayMsg(Message::Plain, BufferInfo::QueryBuffer, target, message, network()->myNick(), Message::Self);
-    handleMsg(bufferInfo, msg);
+    // Split apart messages at line feeds.  The IRC protocol uses those to separate commands, so
+    // they need to be split into multiple messages.
+    QStringList messages = msg.section(' ', 1).split(QChar::LineFeed);
+
+    for (const auto& message : messages) {
+        // Handle each separated message independently
+        if (message.isEmpty()) {
+            emit displayMsg(NetworkInternalMessage(
+                Message::Server,
+                BufferInfo::QueryBuffer,
+                target,
+                tr("Starting query with %1").arg(target),
+                network()->myNick(),
+                Message::Self
+            ));
+            // handleMsg is a no-op if message is empty
+        }
+        else {
+            if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+                emit displayMsg(NetworkInternalMessage(
+                    Message::Plain,
+                    BufferInfo::QueryBuffer,
+                    target,
+                    message,
+                    network()->myNick(),
+                    Message::Self
+                ));
+            }
+            // handleMsg needs the target specified at the beginning of the message
+            handleMsg(bufferInfo, target + " " + message);
+        }
+    }
 }
 
-
-void CoreUserInputHandler::handleQuit(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleQuit(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     network()->disconnectFromIrc(true, msg);
 }
 
-
-void CoreUserInputHandler::issueQuit(const QString &reason)
+void CoreUserInputHandler::issueQuit(const QString& reason, bool forceImmediate)
 {
-    emit putCmd("QUIT", serverEncode(reason));
+    // If needing an immediate QUIT (e.g. core shutdown), prepend this to the queue
+    emit putCmd("QUIT", serverEncode(reason), {}, {}, forceImmediate);
 }
 
-
-void CoreUserInputHandler::handleQuote(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleQuote(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putRawLine(serverEncode(msg));
 }
 
-
-void CoreUserInputHandler::handleSay(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleSay(const BufferInfo& bufferInfo, const QString& msg)
 {
     if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages())
         return;  // server buffer
 
-    QByteArray encMsg = channelEncode(bufferInfo.bufferName(), msg);
+    std::function<QByteArray(const QString&, const QString&)> encodeFunc =
+        [this](const QString& target, const QString& message) -> QByteArray { return channelEncode(target, message); };
+
+    // Split apart messages at line feeds.  The IRC protocol uses those to separate commands, so
+    // they need to be split into multiple messages.
+    QStringList messages = msg.split(QChar::LineFeed, QString::SkipEmptyParts);
+
+    for (const auto& message : messages) {
+        // Handle each separated message independently
 #ifdef HAVE_QCA2
-    putPrivmsg(serverEncode(bufferInfo.bufferName()), encMsg, network()->cipher(bufferInfo.bufferName()));
+        putPrivmsg(bufferInfo.bufferName(), message, encodeFunc, network()->cipher(bufferInfo.bufferName()));
 #else
-    putPrivmsg(serverEncode(bufferInfo.bufferName()), encMsg);
+        putPrivmsg(bufferInfo.bufferName(), message, encodeFunc);
 #endif
-    emit displayMsg(Message::Plain, bufferInfo.type(), bufferInfo.bufferName(), msg, network()->myNick(), Message::Self);
+        if (!network()->capEnabled(IrcCap::ECHO_MESSAGE)) {
+            emit displayMsg(NetworkInternalMessage(
+                Message::Plain,
+                bufferInfo.type(),
+                bufferInfo.bufferName(),
+                message,
+                network()->myNick(),
+                Message::Self
+            ));
+        }
+    }
 }
 
-
-void CoreUserInputHandler::handleSetkey(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleSetkey(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString bufname = bufferInfo.bufferName().isNull() ? "" : bufferInfo.bufferName();
 #ifdef HAVE_QCA2
@@ -606,7 +760,12 @@ void CoreUserInputHandler::handleSetkey(const BufferInfo &bufferInfo, const QStr
         return;
 
     if (!Cipher::neededFeaturesAvailable()) {
-        emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            typeByTarget(bufname),
+            bufname,
+            tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin.")
+        ));
         return;
     }
 
@@ -615,9 +774,14 @@ void CoreUserInputHandler::handleSetkey(const BufferInfo &bufferInfo, const QStr
     if (parms.count() == 1 && !bufferInfo.bufferName().isEmpty() && bufferInfo.acceptsRegularMessages())
         parms.prepend(bufferInfo.bufferName());
     else if (parms.count() != 2) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname,
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
             tr("[usage] /setkey <nick|channel> <key> sets the encryption key for nick or channel. "
-               "/setkey <key> when in a channel or query buffer sets the key for it."));
+               "/setkey <key> when in a channel or query buffer sets the key for it. "
+               "Prefix <key> by cbc: or ebc: to explicitly set the encryption mode respectively. Default is CBC.")
+        ));
         return;
     }
 
@@ -625,18 +789,33 @@ void CoreUserInputHandler::handleSetkey(const BufferInfo &bufferInfo, const QStr
     QByteArray key = parms.at(1).toLocal8Bit();
     network()->setCipherKey(target, key);
 
-    emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("The key for %1 has been set.").arg(target));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Info,
+        typeByTarget(bufname),
+        bufname,
+        tr("The key for %1 has been set.").arg(target)
+    ));
 #else
     Q_UNUSED(msg)
-    emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: Setting an encryption key requires Quassel to have been built "
-                                                                "with support for the Qt Cryptographic Architecture (QCA) library. "
-                                                                "Contact your distributor about a Quassel package with QCA "
-                                                                "support, or rebuild Quassel with QCA present."));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Error,
+        typeByTarget(bufname),
+        bufname,
+        tr("Error: Setting an encryption key requires Quassel to have been built "
+           "with support for the Qt Cryptographic Architecture (QCA) library. "
+           "Contact your distributor about a Quassel package with QCA "
+           "support, or rebuild Quassel with QCA present.")
+    ));
 #endif
 }
 
+void CoreUserInputHandler::handleSetname(const BufferInfo& bufferInfo, const QString& msg)
+{
+    Q_UNUSED(bufferInfo)
+    emit putCmd("SETNAME", serverEncode(msg));
+}
 
-void CoreUserInputHandler::handleShowkey(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleShowkey(const BufferInfo& bufferInfo, const QString& msg)
 {
     QString bufname = bufferInfo.bufferName().isNull() ? "" : bufferInfo.bufferName();
 #ifdef HAVE_QCA2
@@ -644,7 +823,12 @@ void CoreUserInputHandler::handleShowkey(const BufferInfo &bufferInfo, const QSt
         return;
 
     if (!Cipher::neededFeaturesAvailable()) {
-        emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Error,
+            typeByTarget(bufname),
+            bufname,
+            tr("Error: QCA provider plugin not found. It is usually provided by the qca-ossl plugin.")
+        ));
         return;
     }
 
@@ -654,7 +838,13 @@ void CoreUserInputHandler::handleShowkey(const BufferInfo &bufferInfo, const QSt
         parms.prepend(bufferInfo.bufferName());
 
     if (parms.isEmpty()) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("[usage] /showkey <nick|channel> shows the encryption key for nick or channel or just /showkey when in a channel or query."));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("[usage] /showkey <nick|channel> shows the encryption key for nick or channel or just /showkey when in a "
+               "channel or query.")
+        ));
         return;
     }
 
@@ -662,23 +852,37 @@ void CoreUserInputHandler::handleShowkey(const BufferInfo &bufferInfo, const QSt
     QByteArray key = network()->cipherKey(target);
 
     if (key.isEmpty()) {
-        emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("No key has been set for %1.").arg(target));
+        emit displayMsg(NetworkInternalMessage(
+            Message::Info,
+            typeByTarget(bufname),
+            bufname,
+            tr("No key has been set for %1.").arg(target)
+        ));
         return;
     }
 
-    emit displayMsg(Message::Info, typeByTarget(bufname), bufname, tr("The key for %1 is %2:%3").arg(target, network()->cipherUsesCBC(target) ? "CBC" : "ECB", QString(key)));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Info,
+        typeByTarget(bufname),
+        bufname,
+        tr("The key for %1 is %2:%3").arg(target, network()->cipherUsesCBC(target) ? "CBC" : "ECB", QString(key))
+    ));
 
 #else
     Q_UNUSED(msg)
-    emit displayMsg(Message::Error, typeByTarget(bufname), bufname, tr("Error: Setting an encryption key requires Quassel to have been built "
-                                                                    "with support for the Qt Cryptographic Architecture (QCA2) library. "
-                                                                    "Contact your distributor about a Quassel package with QCA2 "
-                                                                    "support, or rebuild Quassel with QCA2 present."));
+    emit displayMsg(NetworkInternalMessage(
+        Message::Error,
+        typeByTarget(bufname),
+        bufname,
+        tr("Error: Setting an encryption key requires Quassel to have been built "
+           "with support for the Qt Cryptographic Architecture (QCA2) library. "
+           "Contact your distributor about a Quassel package with QCA2 "
+           "support, or rebuild Quassel with QCA2 present.")
+    ));
 #endif
 }
 
-
-void CoreUserInputHandler::handleTopic(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleTopic(const BufferInfo& bufferInfo, const QString& msg)
 {
     if (bufferInfo.bufferName().isEmpty() || !bufferInfo.acceptsRegularMessages())
         return;
@@ -687,28 +891,28 @@ void CoreUserInputHandler::handleTopic(const BufferInfo &bufferInfo, const QStri
     params << serverEncode(bufferInfo.bufferName());
 
     if (!msg.isEmpty()) {
-#   ifdef HAVE_QCA2
+#ifdef HAVE_QCA2
         params << encrypt(bufferInfo.bufferName(), channelEncode(bufferInfo.bufferName(), msg));
-#   else
+#else
         params << channelEncode(bufferInfo.bufferName(), msg);
-#   endif
+#endif
     }
 
     emit putCmd("TOPIC", params);
 }
 
-
-void CoreUserInputHandler::handleVoice(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleVoice(const BufferInfo& bufferInfo, const QString& msg)
 {
     QStringList nicks = msg.split(' ', QString::SkipEmptyParts);
-    QString m = "+"; for (int i = 0; i < nicks.count(); i++) m += 'v';
+    QString m = "+";
+    for (int i = 0; i < nicks.count(); i++)
+        m += 'v';
     QStringList params;
     params << bufferInfo.bufferName() << m << nicks;
     emit putCmd("MODE", serverEncode(params));
 }
 
-
-void CoreUserInputHandler::handleWait(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleWait(const BufferInfo& bufferInfo, const QString& msg)
 {
     int splitPos = msg.indexOf(';');
     if (splitPos <= 0)
@@ -728,107 +932,74 @@ void CoreUserInputHandler::handleWait(const BufferInfo &bufferInfo, const QStrin
     _delayedCommands[startTimer(delay)] = Command(bufferInfo, command);
 }
 
-
-void CoreUserInputHandler::handleWho(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleWho(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putCmd("WHO", serverEncode(msg.split(' ')));
 }
 
-
-void CoreUserInputHandler::handleWhois(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleWhois(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putCmd("WHOIS", serverEncode(msg.split(' ')));
 }
 
-
-void CoreUserInputHandler::handleWhowas(const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::handleWhowas(const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo)
     emit putCmd("WHOWAS", serverEncode(msg.split(' ')));
 }
 
-
-void CoreUserInputHandler::defaultHandler(QString cmd, const BufferInfo &bufferInfo, const QString &msg)
+void CoreUserInputHandler::defaultHandler(QString cmd, const BufferInfo& bufferInfo, const QString& msg)
 {
     Q_UNUSED(bufferInfo);
     emit putCmd(serverEncode(cmd.toUpper()), serverEncode(msg.split(" ")));
 }
 
-
-void CoreUserInputHandler::putPrivmsg(const QByteArray &target, const QByteArray &message, Cipher *cipher)
+void CoreUserInputHandler::putPrivmsg(const QString& target,
+                                      const QString& message,
+                                      std::function<QByteArray(const QString&, const QString&)> encodeFunc,
+                                      Cipher* cipher)
 {
-    // Encrypted messages need special care. There's no clear relation between cleartext and encrypted message length,
-    // so we can't just compute the maxSplitPos. Instead, we need to loop through the splitpoints until the crypted
-    // version is short enough...
-    // TODO: check out how the various possible encryption methods behave length-wise and make
-    //       this clean by predicting the length of the crypted msg.
-    //       For example, blowfish-ebc seems to create 8-char chunks.
+    Q_UNUSED(cipher);
+    QString cmd("PRIVMSG");
+    QByteArray targetEnc = serverEncode(target);
 
-    static const char *cmd = "PRIVMSG";
-    static const char *splitter = " .,-";
+    std::function<QList<QByteArray>(QString&)> cmdGenerator = [&](QString& splitMsg) -> QList<QByteArray> {
+        QByteArray splitMsgEnc = encodeFunc(target, splitMsg);
 
-    int maxSplitPos = message.count();
-    int splitPos = maxSplitPos;
-    forever {
-        QByteArray crypted = message.left(splitPos);
-        bool isEncrypted = false;
 #ifdef HAVE_QCA2
-        if (cipher && !cipher->key().isEmpty() && !message.isEmpty()) {
-            isEncrypted = cipher->encrypt(crypted);
+        if (cipher && !cipher->key().isEmpty() && !splitMsg.isEmpty()) {
+            cipher->encrypt(splitMsgEnc);
         }
 #endif
-        int overrun = lastParamOverrun(cmd, QList<QByteArray>() << target << crypted);
-        if (overrun) {
-            // In case this is not an encrypted msg, we can just cut off at the end
-            if (!isEncrypted)
-                maxSplitPos = message.count() - overrun;
-
-            splitPos = -1;
-            for (const char *splitChar = splitter; *splitChar != 0; splitChar++) {
-                splitPos = qMax(splitPos, message.lastIndexOf(*splitChar, maxSplitPos) + 1); // keep split char on old line
-            }
-            if (splitPos <= 0 || splitPos > maxSplitPos)
-                splitPos = maxSplitPos;
-
-            maxSplitPos = splitPos - 1;
-            if (maxSplitPos <= 0) { // this should never happen, but who knows...
-                qWarning() << tr("[Error] Could not encrypt your message: %1").arg(message.data());
-                return;
-            }
-            continue; // we never come back here for !encrypted!
-        }
+        return QList<QByteArray>() << targetEnc << splitMsgEnc;
+    };
 
-        // now we have found a valid splitpos (or didn't need to split to begin with)
-        putCmd(cmd, QList<QByteArray>() << target << crypted);
-        if (splitPos < message.count())
-            putPrivmsg(target, message.mid(splitPos), cipher);
-
-        return;
-    }
+    putCmd(cmd, network()->splitMessage(cmd, message, cmdGenerator));
 }
 
-
 // returns 0 if the message will not be chopped by the irc server or number of chopped bytes if message is too long
-int CoreUserInputHandler::lastParamOverrun(const QString &cmd, const QList<QByteArray> &params)
+int CoreUserInputHandler::lastParamOverrun(const QString& cmd, const QList<QByteArray>& params)
 {
     // the server will pass our message truncated to 512 bytes including CRLF with the following format:
     // ":prefix COMMAND param0 param1 :lastparam"
     // where prefix = "nickname!user@host"
     // that means that the last message can be as long as:
-    // 512 - nicklen - userlen - hostlen - commandlen - sum(param[0]..param[n-1])) - 2 (for CRLF) - 4 (":!@" + 1space between prefix and command) - max(paramcount - 1, 0) (space for simple params) - 2 (space and colon for last param)
-    IrcUser *me = network()->me();
-    int maxLen = 480 - cmd.toLatin1().count(); // educated guess in case we don't know us (yet?)
+    // 512 - nicklen - userlen - hostlen - commandlen - sum(param[0]..param[n-1])) - 2 (for CRLF) - 4 (":!@" + 1space between prefix and
+    // command) - max(paramcount - 1, 0) (space for simple params) - 2 (space and colon for last param)
+    IrcUser* me = network()->me();
+    int maxLen = 480 - cmd.toLatin1().count();  // educated guess in case we don't know us (yet?)
 
     if (me)
-        maxLen = 512 - serverEncode(me->nick()).count() - serverEncode(me->user()).count() - serverEncode(me->host()).count() - cmd.toLatin1().count() - 6;
+        maxLen = 512 - serverEncode(me->nick()).count() - serverEncode(me->user()).count() - serverEncode(me->host()).count()
+                 - cmd.toLatin1().count() - 6;
 
     if (!params.isEmpty()) {
         for (int i = 0; i < params.count() - 1; i++) {
             maxLen -= (params[i].count() + 1);
         }
-        maxLen -= 2; // " :" last param separator;
+        maxLen -= 2;  // " :" last param separator;
 
         if (params.last().count() > maxLen) {
             return params.last().count() - maxLen;
@@ -842,9 +1013,8 @@ int CoreUserInputHandler::lastParamOverrun(const QString &cmd, const QList<QByte
     }
 }
 
-
 #ifdef HAVE_QCA2
-QByteArray CoreUserInputHandler::encrypt(const QString &target, const QByteArray &message_, bool *didEncrypt) const
+QByteArray CoreUserInputHandler::encrypt(const QString& target, const QByteArray& message_, bool* didEncrypt) const
 {
     if (didEncrypt)
         *didEncrypt = false;
@@ -855,7 +1025,7 @@ QByteArray CoreUserInputHandler::encrypt(const QString &target, const QByteArray
     if (!Cipher::neededFeaturesAvailable())
         return message_;
 
-    Cipher *cipher = network()->cipher(target);
+    Cipher* cipher = network()->cipher(target);
     if (!cipher || cipher->key().isEmpty())
         return message_;
 
@@ -867,10 +1037,9 @@ QByteArray CoreUserInputHandler::encrypt(const QString &target, const QByteArray
     return message;
 }
 
-
 #endif
 
-void CoreUserInputHandler::timerEvent(QTimerEvent *event)
+void CoreUserInputHandler::timerEvent(QTimerEvent* event)
 {
     if (!_delayedCommands.contains(event->timerId())) {
         QObject::timerEvent(event);
@@ -883,7 +1052,7 @@ void CoreUserInputHandler::timerEvent(QTimerEvent *event)
 
     // the stored command might be the result of an alias expansion, so we need to split it up again
     QStringList commands = rawCommand.split(QRegExp("; ?"));
-    foreach(QString command, commands) {
+    for (const QString& command : commands) {
         handleUserInput(bufferInfo, command);
     }
 }