+
+void CoreNetwork::setUseAutoReconnect(bool use)
+{
+ Network::setUseAutoReconnect(use);
+ if (!use)
+ _autoReconnectTimer.stop();
+}
+
+
+void CoreNetwork::setAutoReconnectInterval(quint32 interval)
+{
+ Network::setAutoReconnectInterval(interval);
+ _autoReconnectTimer.setInterval(interval * 1000);
+}
+
+
+void CoreNetwork::setAutoReconnectRetries(quint16 retries)
+{
+ Network::setAutoReconnectRetries(retries);
+ if (_autoReconnectCount != 0) {
+ if (unlimitedReconnectRetries())
+ _autoReconnectCount = -1;
+ else
+ _autoReconnectCount = autoReconnectRetries();
+ }
+}
+
+
+void CoreNetwork::doAutoReconnect()
+{
+ if (connectionState() != Network::Disconnected && connectionState() != Network::Reconnecting) {
+ qWarning() << "CoreNetwork::doAutoReconnect(): Cannot reconnect while not being disconnected!";
+ return;
+ }
+ if (_autoReconnectCount > 0 || _autoReconnectCount == -1)
+ _autoReconnectCount--; // -2 means we delay the next reconnect
+ connectToIrc(true);
+}
+
+
+void CoreNetwork::sendPing()
+{
+ qint64 now = QDateTime::currentDateTime().toMSecsSinceEpoch();
+ if (_pingCount != 0) {
+ qDebug() << "UserId:" << userId() << "Network:" << networkName() << "missed" << _pingCount << "pings."
+ << "BA:" << socket.bytesAvailable() << "BTW:" << socket.bytesToWrite();
+ }
+ if ((int)_pingCount >= networkConfig()->maxPingCount()
+ && (now - _lastPingTime) <= (_pingTimer.interval() + (1 * 1000))) {
+ // In transitioning to 64-bit time, the interval no longer needs converted down to seconds.
+ // However, to reduce the risk of breaking things by changing past behavior, we still allow
+ // up to 1 second missed instead of enforcing a stricter 1 millisecond allowance.
+ //
+ // 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 {
+ _lastPingTime = now;
+ _pingCount++;
+ // Don't send pings until the network is initialized
+ if(_sendPings) {
+ // Mark as waiting for a reply
+ _pongReplyPending = true;
+ // Send default timestamp ping
+ userInputHandler()->handlePing(BufferInfo(), QString());
+ }
+ }
+}
+
+
+void CoreNetwork::enablePingTimeout(bool enable)
+{
+ if (!enable)
+ disablePingTimeout();
+ else {
+ resetPingTimeout();
+ resetPongReplyPending();
+ if (networkConfig()->pingTimeoutEnabled())
+ _pingTimer.start();
+ }
+}
+
+
+void CoreNetwork::disablePingTimeout()
+{
+ _pingTimer.stop();
+ _sendPings = false;
+ resetPingTimeout();
+ resetPongReplyPending();
+}
+
+
+void CoreNetwork::setPingInterval(int interval)
+{
+ _pingTimer.setInterval(interval * 1000);
+}
+
+
+void CoreNetwork::setPongTimestampValid(bool validTimestamp)
+{
+ _pongTimestampValid = validTimestamp;
+}
+
+
+/******** Custom Rate Limiting ********/
+
+void CoreNetwork::updateRateLimiting(const bool forceUnlimited)
+{
+ // Verify and apply custom rate limiting options, always resetting the delay and burst size
+ // (safe-guarding against accidentally starting the timer), but don't reset the token bucket as
+ // this may be called while connected to a server.
+
+ if (useCustomMessageRate() || forceUnlimited) {
+ // Custom message rates enabled, or chosen by means of forcing unlimited. Let's go for it!
+
+ _messageDelay = messageRateDelay();
+
+ _burstSize = messageRateBurstSize();
+ if (_burstSize < 1) {
+ qWarning() << "Invalid messageRateBurstSize data, cannot have zero message burst size!"
+ << _burstSize;
+ // Can't go slower than one message at a time
+ _burstSize = 1;
+ }
+
+ if (_tokenBucket > _burstSize) {
+ // Don't let the token bucket exceed the maximum
+ _tokenBucket = _burstSize;
+ // To fill up the token bucket, use resetRateLimiting(). Don't do that here, otherwise
+ // changing the rate-limit settings while connected to a server will incorrectly reset
+ // the token bucket.
+ }
+
+ // Toggle the timer according to whether or not rate limiting is enabled
+ // If we're here, either useCustomMessageRate or forceUnlimited is true. Thus, the logic is
+ // _skipMessageRates = ((useCustomMessageRate && unlimitedMessageRate) || forceUnlimited)
+ // Override user preferences if called with force unlimited, only used during connect.
+ _skipMessageRates = (unlimitedMessageRate() || forceUnlimited);
+ if (_skipMessageRates) {
+ // If the message queue already contains messages, they need sent before disabling the
+ // timer. Set the timer to a rapid pace and let it disable itself.
+ if (_msgQueue.size() > 0) {
+ qDebug() << "Outgoing message queue contains messages while disabling rate "
+ "limiting. Sending remaining queued messages...";
+ // Promptly run the timer again to clear the messages. Rate limiting is disabled,
+ // so nothing should cause this to block.. in theory. However, don't directly call
+ // fillBucketAndProcessQueue() in order to keep it on a separate thread.
+ //
+ // TODO If testing shows this isn't needed, it can be simplified to a direct call.
+ // Hesitant to change it without a wide variety of situations to verify behavior.
+ _tokenBucketTimer.start(100);
+ } else {
+ // No rate limiting, disable the timer
+ _tokenBucketTimer.stop();
+ }
+ } else {
+ // Rate limiting enabled, enable the timer
+ _tokenBucketTimer.start(_messageDelay);
+ }