X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fcorenetwork.cpp;h=21415aed8ec94b82d485478e4986e9b9027b11e9;hp=3dc0cc2720a76b9c65433989880ce8ca80f60f92;hb=1489728cd358f6bf7151bcdd87b9ea2cbdff7bec;hpb=32c550d8f25392616de13fe761285ac13cf5e0d9 diff --git a/src/core/corenetwork.cpp b/src/core/corenetwork.cpp index 3dc0cc27..21415aed 100644 --- a/src/core/corenetwork.cpp +++ b/src/core/corenetwork.cpp @@ -23,6 +23,7 @@ #include "core.h" #include "coresession.h" #include "coreidentity.h" +#include "corenetworkconfig.h" #include "ircserverhandler.h" #include "userinputhandler.h" @@ -40,36 +41,37 @@ CoreNetwork::CoreNetwork(const NetworkId &networkid, CoreSession *session) _previousConnectionAttemptFailed(false), _lastUsedServerIndex(0), - _gotPong(true), + _lastPingTime(0), + _pingCount(0) - // TODO make autowho configurable (possibly per-network) - _autoWhoEnabled(true), - _autoWhoInterval(90), - _autoWhoNickLimit(0), // unlimited - _autoWhoDelay(3) { _autoReconnectTimer.setSingleShot(true); _socketCloseTimer.setSingleShot(true); connect(&_socketCloseTimer, SIGNAL(timeout()), this, SLOT(socketCloseTimeout())); - _pingTimer.setInterval(30000); + setPingInterval(networkConfig()->pingInterval()); connect(&_pingTimer, SIGNAL(timeout()), this, SLOT(sendPing())); - _autoWhoTimer.setInterval(_autoWhoDelay * 1000); - _autoWhoCycleTimer.setInterval(_autoWhoInterval * 1000); + setAutoWhoDelay(networkConfig()->autoWhoDelay()); + setAutoWhoInterval(networkConfig()->autoWhoInterval()); QHash channels = coreSession()->persistentChannels(networkId()); foreach(QString chan, channels.keys()) { _channelKeys[chan.toLower()] = channels[chan]; } + connect(networkConfig(), SIGNAL(pingTimeoutEnabledSet(bool)), SLOT(enablePingTimeout(bool))); + connect(networkConfig(), SIGNAL(pingIntervalSet(int)), SLOT(setPingInterval(int))); + connect(networkConfig(), SIGNAL(autoWhoEnabledSet(bool)), SLOT(setAutoWhoEnabled(bool))); + connect(networkConfig(), SIGNAL(autoWhoIntervalSet(int)), SLOT(setAutoWhoInterval(int))); + connect(networkConfig(), SIGNAL(autoWhoDelaySet(int)), SLOT(setAutoWhoDelay(int))); + connect(&_autoReconnectTimer, SIGNAL(timeout()), this, SLOT(doAutoReconnect())); connect(&_autoWhoTimer, SIGNAL(timeout()), this, SLOT(sendAutoWho())); connect(&_autoWhoCycleTimer, SIGNAL(timeout()), this, SLOT(startAutoWhoCycle())); connect(&_tokenBucketTimer, SIGNAL(timeout()), this, SLOT(fillBucketAndProcessQueue())); connect(this, SIGNAL(connectRequested()), this, SLOT(connectToIrc())); - connect(&socket, SIGNAL(connected()), this, SLOT(socketInitialized())); connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); @@ -189,6 +191,8 @@ void CoreNetwork::disconnectFromIrc(bool requested, const QString &reason, bool _autoReconnectTimer.stop(); _autoReconnectCount = 0; // prohibiting auto reconnect } + disablePingTimeout(); + _msgQueue.clear(); IrcUser *me_ = me(); if(me_) { @@ -204,21 +208,18 @@ void CoreNetwork::disconnectFromIrc(bool requested, const QString &reason, bool else _quitReason = reason; - displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Disconnecting.")); + displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Disconnecting. (%1)").arg((!requested && !withReconnect) ? tr("Core Shutdown") : _quitReason)); switch(socket.state()) { - case QAbstractSocket::UnconnectedState: - socketDisconnected(); - break; case QAbstractSocket::ConnectedState: userInputHandler()->issueQuit(_quitReason); - default: - if(!requested) { - socket.close(); - socketDisconnected(); - } else { + if(requested || withReconnect) { // the irc server has 10 seconds to close the socket _socketCloseTimer.start(10000); + break; } + default: + socket.close(); + socketDisconnected(); } } @@ -259,7 +260,7 @@ void CoreNetwork::setChannelJoined(const QString &channel) { void CoreNetwork::setChannelParted(const QString &channel) { removeChannelKey(channel); _autoWhoQueue.removeAll(channel.toLower()); - _autoWhoInProgress.remove(channel.toLower()); + _autoWhoPending.remove(channel.toLower()); Core::setChannelPersistent(userId(), networkId(), channel, false); } @@ -277,9 +278,11 @@ void CoreNetwork::removeChannelKey(const QString &channel) { } bool CoreNetwork::setAutoWhoDone(const QString &channel) { - if(_autoWhoInProgress.value(channel.toLower(), 0) <= 0) + QString chan = channel.toLower(); + if(_autoWhoPending.value(chan, 0) <= 0) return false; - _autoWhoInProgress[channel.toLower()]--; + if(--_autoWhoPending[chan] <= 0) + _autoWhoPending.remove(chan); return true; } @@ -303,7 +306,7 @@ void CoreNetwork::socketError(QAbstractSocket::SocketError error) { _previousConnectionAttemptFailed = true; qWarning() << qPrintable(tr("Could not connect to %1 (%2)").arg(networkName(), socket.errorString())); emit connectionError(socket.errorString()); - emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Connection failure: %1").arg(socket.errorString())); + displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Connection failure: %1").arg(socket.errorString())); emitConnectionError(socket.errorString()); if(socket.state() < QAbstractSocket::ConnectedState) { socketDisconnected(); @@ -325,26 +328,33 @@ void CoreNetwork::socketInitialized() { } // TokenBucket to avoid sending too much at once - _messagesPerSecond = 1; + _messageDelay = 2200; // this seems to be a safe value (2.2 seconds delay) _burstSize = 5; - _tokenBucket = 5; // init with a full bucket - _tokenBucketTimer.start(_messagesPerSecond * 1000); + _tokenBucket = _burstSize; // init with a full bucket + _tokenBucketTimer.start(_messageDelay); if(!server.password.isEmpty()) { putRawLine(serverEncode(QString("PASS %1").arg(server.password))); } - putRawLine(serverEncode(QString("NICK :%1").arg(identity->nicks()[0]))); + QString nick; + if(identity->nicks().isEmpty()) { + nick = "quassel"; + qWarning() << "CoreNetwork::socketInitialized(): no nicks supplied for identity Id" << identity->id(); + } else { + nick = identity->nicks()[0]; + } + putRawLine(serverEncode(QString("NICK :%1").arg(nick))); putRawLine(serverEncode(QString("USER %1 8 * :%2").arg(identity->ident(), identity->realName()))); } void CoreNetwork::socketDisconnected() { - _pingTimer.stop(); - resetPong(); + disablePingTimeout(); + _msgQueue.clear(); _autoWhoCycleTimer.stop(); _autoWhoTimer.stop(); _autoWhoQueue.clear(); - _autoWhoInProgress.clear(); + _autoWhoPending.clear(); _socketCloseTimer.stop(); @@ -353,7 +363,7 @@ void CoreNetwork::socketDisconnected() { IrcUser *me_ = me(); if(me_) { foreach(QString channel, me_->channels()) - emit displayMsg(Message::Quit, BufferInfo::ChannelBuffer, channel, _quitReason, me_->hostmask()); + displayMsg(Message::Quit, BufferInfo::ChannelBuffer, channel, _quitReason, me_->hostmask()); } setConnected(false); @@ -363,7 +373,7 @@ void CoreNetwork::socketDisconnected() { Core::setNetworkConnected(userId(), networkId(), false); } else if(_autoReconnectCount != 0) { setConnectionState(Network::Reconnecting); - if(_autoReconnectCount == autoReconnectRetries()) + if(_autoReconnectCount == -1 || _autoReconnectCount == autoReconnectRetries()) doAutoReconnect(); // first try is immediate else _autoReconnectTimer.start(); @@ -399,11 +409,13 @@ void CoreNetwork::networkInitialized() { if(useAutoReconnect()) { // reset counter - _autoReconnectCount = autoReconnectRetries(); + _autoReconnectCount = unlimitedReconnectRetries() ? -1 : autoReconnectRetries(); } // restore away state - userInputHandler()->handleAway(BufferInfo(), Core::awayMessage(userId(), networkId())); + QString awayMsg = Core::awayMessage(userId(), networkId()); + if(!awayMsg.isEmpty()) + userInputHandler()->handleAway(BufferInfo(), Core::awayMessage(userId(), networkId())); // restore old user modes if server default mode is set. IrcUser *me_ = me(); @@ -418,10 +430,9 @@ void CoreNetwork::networkInitialized() { sendPerform(); - resetPong(); - _pingTimer.start(); + enablePingTimeout(); - if(_autoWhoEnabled) { + if(networkConfig()->autoWhoEnabled()) { _autoWhoCycleTimer.start(); _autoWhoTimer.start(); startAutoWhoCycle(); // FIXME wait for autojoin to be completed @@ -509,37 +520,50 @@ void CoreNetwork::doAutoReconnect() { qWarning() << "CoreNetwork::doAutoReconnect(): Cannot reconnect while not being disconnected!"; return; } - if(_autoReconnectCount > 0) - _autoReconnectCount--; + if(_autoReconnectCount > 0 || _autoReconnectCount == -1) + _autoReconnectCount--; // -2 means we delay the next reconnect connectToIrc(true); } void CoreNetwork::sendPing() { - if(!gotPong()) { - disconnectFromIrc(false, QString("No Ping reply in %1 seconds.").arg(_pingTimer.interval() / 1000), true /* withReconnect */); + uint now = QDateTime::currentDateTime().toTime_t(); + if(_pingCount != 0) { + qDebug() << "UserId:" << userId() << "Network:" << networkName() << "missed" << _pingCount << "pings." + << "BA:" << socket.bytesAvailable() << "BTW:" << socket.bytesToWrite(); + } + if((int)_pingCount >= networkConfig()->maxPingCount() && now - _lastPingTime <= (uint)(_pingTimer.interval() / 1000) + 1) { + // the second check compares the actual elapsed time since the last ping and the pingTimer interval + // if the interval is shorter then the actual elapsed time it means that this thread was somehow blocked + // and unable to even handle a ping answer. So we ignore those misses. + disconnectFromIrc(false, QString("No Ping reply in %1 seconds.").arg(_pingCount * _pingTimer.interval() / 1000), true /* withReconnect */); } else { - _gotPong = false; + _lastPingTime = now; + _pingCount++; userInputHandler()->handlePing(BufferInfo(), QString()); } } -void CoreNetwork::sendAutoWho() { - while(!_autoWhoQueue.isEmpty()) { - QString chan = _autoWhoQueue.takeFirst(); - IrcChannel *ircchan = ircChannel(chan); - if(!ircchan) continue; - if(_autoWhoNickLimit > 0 && ircchan->ircUsers().count() > _autoWhoNickLimit) continue; - _autoWhoInProgress[chan]++; - putRawLine("WHO " + serverEncode(chan)); - if(_autoWhoQueue.isEmpty() && _autoWhoEnabled && !_autoWhoCycleTimer.isActive()) { - // Timer was stopped, means a new cycle is due immediately - _autoWhoCycleTimer.start(); - startAutoWhoCycle(); - } - break; +void CoreNetwork::enablePingTimeout(bool enable) { + if(!enable) + disablePingTimeout(); + else { + resetPingTimeout(); + if(networkConfig()->pingTimeoutEnabled()) + _pingTimer.start(); } } +void CoreNetwork::disablePingTimeout() { + _pingTimer.stop(); + resetPingTimeout(); +} + +void CoreNetwork::setPingInterval(int interval) { + _pingTimer.setInterval(interval * 1000); +} + +/******** AutoWHO ********/ + void CoreNetwork::startAutoWhoCycle() { if(!_autoWhoQueue.isEmpty()) { _autoWhoCycleTimer.stop(); @@ -548,6 +572,45 @@ void CoreNetwork::startAutoWhoCycle() { _autoWhoQueue = channels(); } +void CoreNetwork::setAutoWhoDelay(int delay) { + _autoWhoTimer.setInterval(delay * 1000); +} + +void CoreNetwork::setAutoWhoInterval(int interval) { + _autoWhoCycleTimer.setInterval(interval * 1000); +} + +void CoreNetwork::setAutoWhoEnabled(bool enabled) { + if(enabled && isConnected() && !_autoWhoTimer.isActive()) + _autoWhoTimer.start(); + else if(!enabled) { + _autoWhoTimer.stop(); + _autoWhoCycleTimer.stop(); + } +} + +void CoreNetwork::sendAutoWho() { + // Don't send autowho if there are still some pending + if(_autoWhoPending.count()) + return; + + while(!_autoWhoQueue.isEmpty()) { + QString chan = _autoWhoQueue.takeFirst(); + IrcChannel *ircchan = ircChannel(chan); + if(!ircchan) continue; + if(networkConfig()->autoWhoNickLimit() > 0 && ircchan->ircUsers().count() >= networkConfig()->autoWhoNickLimit()) + continue; + _autoWhoPending[chan]++; + putRawLine("WHO " + serverEncode(chan)); + break; + } + if(_autoWhoQueue.isEmpty() && networkConfig()->autoWhoEnabled() && !_autoWhoCycleTimer.isActive()) { + // Timer was stopped, means a new cycle is due immediately + _autoWhoCycleTimer.start(); + startAutoWhoCycle(); + } +} + #ifdef HAVE_SSL void CoreNetwork::sslErrors(const QList &sslErrors) { Q_UNUSED(sslErrors)