Semi-yearly copyright bump

[quassel.git] / src / core / corenetwork.h

diff --git a/src/core/corenetwork.h b/src/core/corenetwork.h
index 906f60a..b67e2c3 100644 (file)
--- a/src/core/corenetwork.h
+++ b/src/core/corenetwork.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2016 by the Quassel Project                        *
+ *   Copyright (C) 2005-2018 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -101,6 +101,15 @@ public:
     inline quint16 localPort() const { return socket.localPort(); }
     inline quint16 peerPort() const { return socket.peerPort(); }
 
+    /**
+     * Gets whether or not a disconnect was expected.
+     *
+     * Distinguishes desired quits from unexpected disconnections such as socket errors or timeouts.
+     *
+     * @return True if disconnect was requested, otherwise false.
+     */
+    inline bool disconnectExpected() const { return _disconnectExpected; }
+
     QList<QList<QByteArray>> splitMessage(const QString &cmd, const QString &message, std::function<QList<QByteArray>(QString &)> cmdGenerator);
 
     // IRCv3 capability negotiation
@@ -268,6 +277,40 @@ public slots:
     bool cipherUsesCBC(const QString &target);
 #endif
 
+    // Custom rate limiting (can be connected to signals)
+
+    /**
+     * Update rate limiting according to Network configuration
+     *
+     * Updates the token bucket and message queue timer according to the network configuration, such
+     * as on first load, or after changing settings.
+     *
+     * Calling this will reset any ongoing queue delays.  If messages exist in the queue when rate
+     * limiting is disabled, messages will be quickly sent (100 ms) with new messages queued to send
+     * until the queue is cleared.
+     *
+     * @see Network::useCustomMessageRate()
+     * @see Network::messageRateBurstSize()
+     * @see Network::messageRateDelay()
+     * @see Network::unlimitedMessageRate()
+     *
+     * @param[in] forceUnlimited
+     * @parmblock
+     * If true, override user settings to disable message rate limiting, otherwise apply rate limits
+     * set by the user.  Use with caution and remember to re-enable configured limits when done.
+     * @endparmblock
+     */
+    void updateRateLimiting(const bool forceUnlimited = false);
+
+    /**
+     * Resets the token bucket up to the maximum
+     *
+     * Call this if the connection's been reset after calling updateRateLimiting() if needed.
+     *
+     * @see CoreNetwork::updateRateLimiting()
+     */
+    void resetTokenBucket();
+
     // IRCv3 capability negotiation (can be connected to signals)
 
     /**
@@ -381,6 +424,23 @@ private slots:
     void sslErrors(const QList<QSslError> &errors);
 #endif
 
+    /**
+     * Check the message token bucket
+     *
+     * If rate limiting is disabled and the message queue is empty, this disables the token bucket
+     * timer.  Otherwise, a queued message will be sent.
+     *
+     * @see CoreNetwork::fillBucketAndProcessQueue()
+     */
+    void checkTokenBucket();
+
+    /**
+     * Top up token bucket and send as many queued messages as possible
+     *
+     * If there's any room for more tokens, add to the token bucket.  Separately, if there's any
+     * messages to send, send until there's no more tokens or the queue is empty, whichever comes
+     * first.
+     */
     void fillBucketAndProcessQueue();
 
     void writeToSocket(const QByteArray &data);
@@ -463,10 +523,12 @@ private:
     const int maxCapRequestLength = 100;
 
     QTimer _tokenBucketTimer;
-    int _messageDelay;      // token refill speed in ms
-    int _burstSize;         // size of the token bucket
-    int _tokenBucket;       // the virtual bucket that holds the tokens
-    QList<QByteArray> _msgQueue;
+    // No need for int type as one cannot travel into the past (at least not yet, Doc)
+    quint32 _messageDelay;       /// Token refill speed in ms
+    quint32 _burstSize;          /// Size of the token bucket
+    quint32 _tokenBucket;        /// The virtual bucket that holds the tokens
+    QList<QByteArray> _msgQueue; /// Queue of messages waiting to be sent
+    bool _skipMessageRates;      /// If true, skip all message rate limits
 
     QString _requestedUserModes; // 2 strings separated by a '-' character. first part are requested modes to add, the second to remove