Fixing BR #39 (splitting long messages)

[quassel.git] / src / core / networkconnection.cpp

diff --git a/src/core/networkconnection.cpp b/src/core/networkconnection.cpp
index 530ee32..ab45311 100644 (file)
--- a/src/core/networkconnection.cpp
+++ b/src/core/networkconnection.cpp
@@ -45,6 +45,7 @@ NetworkConnection::NetworkConnection(Network *network, CoreSession *session)
     _userInputHandler(new UserInputHandler(this)),
     _ctcpHandler(new CtcpHandler(this)),
     _autoReconnectCount(0),
+    _quitRequested(false),
 
     _previousConnectionAttemptFailed(false),
     _lastUsedServerlistIndex(0),
@@ -54,7 +55,7 @@ NetworkConnection::NetworkConnection(Network *network, CoreSession *session)
     _autoWhoInterval(90),
     _autoWhoNickLimit(0), // unlimited
     _autoWhoDelay(3),
-    
+
     // TokenBucket to avaid sending too much at once
     _messagesPerSecond(1),
     _burstSize(5),
@@ -66,14 +67,13 @@ NetworkConnection::NetworkConnection(Network *network, CoreSession *session)
     _maxMsgSize(450)
 {
   _autoReconnectTimer.setSingleShot(true);
-
+  _socketCloseTimer.setSingleShot(true);
+  connect(&_socketCloseTimer, SIGNAL(timeout()), this, SLOT(socketCloseTimeout()));
+  
   _autoWhoTimer.setInterval(_autoWhoDelay * 1000);
-  _autoWhoTimer.setSingleShot(false);
   _autoWhoCycleTimer.setInterval(_autoWhoInterval * 1000);
-  _autoWhoCycleTimer.setSingleShot(false);
-
+  
   _tokenBucketTimer.start(_messagesPerSecond * 1000);
-  _tokenBucketTimer.setSingleShot(false);
 
   QHash<QString, QString> channels = coreSession()->persistentChannels(networkId());
   foreach(QString chan, channels.keys()) {
@@ -260,12 +260,13 @@ void NetworkConnection::disconnectFromIrc(bool requested) {
     setConnectionState(Network::Disconnected);
     socketDisconnected();
   } else {
-    socket.disconnectFromHost();
+    _socketCloseTimer.start(10000); // the irc server has 10 seconds to close the socket
   }
 
-  if(requested) {
-    emit quitRequested(networkId());
-  }
+  // this flag triggers quitRequested() once the socket is closed
+  // it is needed to determine whether or not the connection needs to be
+  // in the automatic session restore.
+  _quitRequested = requested;
 }
 
 void NetworkConnection::socketHasData() {
@@ -369,18 +370,26 @@ void NetworkConnection::socketStateChanged(QAbstractSocket::SocketState socketSt
   setConnectionState(state);
 }
 
+void NetworkConnection::socketCloseTimeout() {
+  socket.disconnectFromHost();
+}
+
 void NetworkConnection::socketDisconnected() {
   _autoWhoCycleTimer.stop();
   _autoWhoTimer.stop();
   _autoWhoQueue.clear();
   _autoWhoInProgress.clear();
 
+  _socketCloseTimer.stop();
+  
   network()->setConnected(false);
   emit disconnected(networkId());
   if(_autoReconnectCount != 0) {
     setConnectionState(Network::Reconnecting);
     if(_autoReconnectCount == network()->autoReconnectRetries()) doAutoReconnect(); // first try is immediate
     else _autoReconnectTimer.start();
+  } else if(_quitRequested) {
+    emit quitRequested(networkId());
   }
 }
 
@@ -424,17 +433,73 @@ void NetworkConnection::fillBucketAndProcessQueue() {
   }
 }
 
-void NetworkConnection::putCmd(const QString &cmd, const QVariantList &params, const QByteArray &prefix) {
+// returns 0 if the message will not be chopped by the irc server or number of chopped bytes if message is too long
+int NetworkConnection::lastParamOverrun(const QString &cmd, const QList<QByteArray> &params) {
+  //the server will pass our message that trunkated 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 = 512 - serverEncode(me->nick()).count() - serverEncode(me->user()).count() - serverEncode(me->host()).count() - cmd.toAscii().count() - 6;
+
+  if(!params.isEmpty()) {
+    for(int i = 0; i < params.count() - 1; i++) {
+      maxLen -= (params[i].count() + 1);
+    }
+    maxLen -= 2; // " :" last param separator;
+    
+    if(params.last().count() > maxLen) {
+      return params.last().count() - maxLen;
+    } else {
+      return 0;
+    }
+  } else {
+    return 0;
+  }
+}
+
+void NetworkConnection::putCmd(const QString &cmd, const QList<QByteArray> &params, const QByteArray &prefix) {
   QByteArray msg;
+  if(cmd == "PRIVMSG" && params.count() > 1) {
+    int overrun = lastParamOverrun(cmd, params);
+    if(overrun) {
+      QList<QByteArray> paramCopy1;
+      QList<QByteArray> paramCopy2;
+      for(int i = 0; i < params.count() - 1; i++) {
+       paramCopy1 << params[i];
+       paramCopy2 << params[i];
+      }
+
+      QByteArray lastPart = params.last();
+      QByteArray splitter(" .,-");
+      int maxSplitPos = params.last().count() - overrun;
+      int splitPos = -1;
+      for(int i = 0; i < splitter.size(); i++) {
+       splitPos = qMax(splitPos, lastPart.lastIndexOf(splitter[i], maxSplitPos));
+      }
+
+      if(splitPos == -1) {
+       splitPos = maxSplitPos;
+      }
+      
+      paramCopy1 << lastPart.left(splitPos);
+      paramCopy2 << lastPart.mid(splitPos);
+      putCmd(cmd, paramCopy1, prefix);
+      putCmd(cmd, paramCopy2, prefix);
+      return;
+    }
+  }
+     
   if(!prefix.isEmpty())
     msg += ":" + prefix + " ";
   msg += cmd.toUpper().toAscii();
 
   for(int i = 0; i < params.size() - 1; i++) {
-    msg += " " + params[i].toByteArray();
+    msg += " " + params[i];
   }
   if(!params.isEmpty())
-    msg += " :" + params.last().toByteArray();
+    msg += " :" + params.last();
 
   if(cmd == "PRIVMSG" && params.count() > 1) {
     QByteArray msghead = "PRIVMSG " + params[0].toByteArray() + " :";