X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.h;h=1275436379e5a2dc7994f7010ee2eb092763cdaa;hp=3e58fdaccbef1a383359b1a41003c6690c897ba0;hb=158443f71d48215eea8b47b836b61afd77654b78;hpb=0a43227b8cd44625f4881cc1545d42c8c8a4876c diff --git a/src/common/network.h b/src/common/network.h index 3e58fdac..12754363 100644 --- a/src/common/network.h +++ b/src/common/network.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 * @@ -18,8 +18,9 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ -#ifndef NETWORK_H -#define NETWORK_H +#pragma once + +#include "common-export.h" #include #include @@ -30,6 +31,7 @@ #include #include #include +#include #include "types.h" #include "util.h" @@ -39,15 +41,19 @@ #include "ircuser.h" #include "ircchannel.h" +// IRCv3 capabilities +#include "irccap.h" + // defined below! struct NetworkInfo; // TODO: ConnectionInfo to propagate and sync the current state of NetworkConnection, encodings etcpp -class Network : public SyncableObject +class COMMON_EXPORT Network : public SyncableObject { - SYNCABLE_OBJECT Q_OBJECT + SYNCABLE_OBJECT + Q_ENUMS(ConnectionState) Q_PROPERTY(QString networkName READ networkName WRITE setNetworkName) @@ -74,6 +80,11 @@ class Network : public SyncableObject Q_PROPERTY(quint16 autoReconnectRetries READ autoReconnectRetries WRITE setAutoReconnectRetries) Q_PROPERTY(bool unlimitedReconnectRetries READ unlimitedReconnectRetries WRITE setUnlimitedReconnectRetries) Q_PROPERTY(bool rejoinChannels READ rejoinChannels WRITE setRejoinChannels) + // Custom rate limiting + Q_PROPERTY(bool useCustomMessageRate READ useCustomMessageRate WRITE setUseCustomMessageRate) + Q_PROPERTY(quint32 msgRateBurstSize READ messageRateBurstSize WRITE setMessageRateBurstSize) + Q_PROPERTY(quint32 msgRateMessageDelay READ messageRateDelay WRITE setMessageRateDelay) + Q_PROPERTY(bool unlimitedMessageRate READ unlimitedMessageRate WRITE setUnlimitedMessageRate) public : enum ConnectionState { @@ -96,31 +107,46 @@ public : D_CHANMODE = 0x08 }; + // Default port assignments according to what many IRC networks have settled on. + // Technically not a standard, but it's fairly widespread. + // See https://freenode.net/news/port-6697-irc-via-tlsssl + enum PortDefaults { + PORT_PLAINTEXT = 6667, /// Default port for unencrypted connections + PORT_SSL = 6697 /// Default port for encrypted connections + }; + struct Server { QString host; - uint port; + uint port{6667}; QString password; - bool useSsl; - int sslVersion; + bool useSsl{false}; + bool sslVerify{true}; /// If true, validate SSL certificates + int sslVersion{0}; - bool useProxy; - int proxyType; + bool useProxy{false}; + int proxyType{QNetworkProxy::Socks5Proxy}; QString proxyHost; - uint proxyPort; + uint proxyPort{8080}; QString proxyUser; QString proxyPass; - Server() : port(6667), useSsl(false), sslVersion(0), useProxy(false), proxyType(QNetworkProxy::Socks5Proxy), proxyHost("localhost"), proxyPort(8080) {} - Server(const QString &host, uint port, const QString &password, bool useSsl) - : host(host), port(port), password(password), useSsl(useSsl), sslVersion(0), - useProxy(false), proxyType(QNetworkProxy::Socks5Proxy), proxyHost("localhost"), proxyPort(8080) {} + // sslVerify only applies when useSsl is true. sslVerify should be enabled by default, + // so enabling useSsl offers a more secure default. + Server() : proxyHost("localhost") {} + + Server(QString host, uint port, QString password, bool useSsl, + bool sslVerify) + : host(std::move(host)), port(port), password(std::move(password)), useSsl(useSsl), sslVerify(sslVerify), + proxyType(QNetworkProxy::Socks5Proxy), + proxyHost("localhost"), proxyPort(8080) {} + bool operator==(const Server &other) const; bool operator!=(const Server &other) const; }; - typedef QList ServerList; + using ServerList = QList; - Network(const NetworkId &networkid, QObject *parent = 0); - ~Network(); + Network(const NetworkId &networkid, QObject *parent = nullptr); + ~Network() override; inline NetworkId networkId() const { return _networkId; } @@ -148,10 +174,72 @@ public : //Network::ConnectionState connectionState() const; inline int connectionState() const { return _connectionState; } + /**@{*/ + /** + * Translates a user’s prefix to the channelmode associated with it. + * @param prefix Prefix to be translated. + */ QString prefixToMode(const QString &prefix) const; inline QString prefixToMode(const QCharRef &prefix) const { return prefixToMode(QString(prefix)); } + inline QString prefixesToModes(const QString &prefix) const { + QString modes; + for (QChar c : prefix) { + modes += prefixToMode(c); + } + return modes; + } + /**@}*/ + + /**@{*/ + /** + * Translates a user’s prefix to the channelmode associated with it. + * @param prefix Prefix to be translated. + */ QString modeToPrefix(const QString &mode) const; inline QString modeToPrefix(const QCharRef &mode) const { return modeToPrefix(QString(mode)); } + inline QString modesToPrefixes(const QString &mode) const { + QString prefixes; + for (QChar c : mode) { + prefixes += modeToPrefix(c); + } + return prefixes; + } + /**@}*/ + + /** + * Sorts the user channelmodes according to priority set by PREFIX + * + * Given a list of channel modes, sorts according to the order of PREFIX, putting the highest + * modes first. Any unknown modes are moved to the end in no given order. + * + * If prefix modes cannot be determined from the network, no changes will be made. + * + * @param modes User channelmodes + * @return Priority-sorted user channelmodes + */ + QString sortPrefixModes(const QString &modes) const; + + /**@{*/ + /** + * Sorts the list of users' channelmodes according to priority set by PREFIX + * + * Maintains order of the modes list. + * + * @seealso Network::sortPrefixModes() + * + * @param modesList List of users' channel modes + * @return Priority-sorted list of users' channel modes + */ + inline QStringList sortPrefixModes(const QStringList &modesList) const { + QStringList sortedModesList; + // Sort each individual mode string, appending back + // Must maintain the order received! + for (QString modes : modesList) { + sortedModesList << sortPrefixModes(modes); + } + return sortedModesList; + } + /**@}*/ ChannelModeType channelModeType(const QString &mode); inline ChannelModeType channelModeType(const QCharRef &mode) { return channelModeType(QString(mode)); } @@ -164,6 +252,18 @@ public : inline IdentityId identity() const { return _identity; } QStringList nicks() const; inline QStringList channels() const { return _ircChannels.keys(); } + /** + * Gets the list of available capabilities. + * + * @returns QStringList of available capabilities + */ + inline const QStringList caps() const { return QStringList(_caps.keys()); } + /** + * Gets the list of enabled (acknowledged) capabilities. + * + * @returns QStringList of enabled (acknowledged) capabilities + */ + inline const QStringList capsEnabled() const { return _capsEnabled; } inline const ServerList &serverList() const { return _serverList; } inline bool useRandomServer() const { return _useRandomServer; } inline const QStringList &perform() const { return _perform; } @@ -179,6 +279,44 @@ public : inline bool unlimitedReconnectRetries() const { return _unlimitedReconnectRetries; } inline bool rejoinChannels() const { return _rejoinChannels; } + // Custom rate limiting + + /** + * Gets whether or not custom rate limiting is used + * + * @return True if custom rate limiting is enabled, otherwise false. + */ + inline bool useCustomMessageRate() const { return _useCustomMessageRate; } + + /** + * Gets maximum number of messages to send without any delays + * + * @return + * @parblock + * Maximum number of messages to send without any delays. A value of 1 disables message + * bursting. + * @endparblock + */ + inline quint32 messageRateBurstSize() const { return _messageRateBurstSize; } + + /** + * Gets the delay between messages after the maximum number of undelayed messages have been sent + * + * @return + * @parblock + * Delay in milliseconds between messages after the maximum number of undelayed messages have + * been sent. + * @endparblock + */ + inline quint32 messageRateDelay() const { return _messageRateDelay; } + + /** + * Gets whether or not all rate limiting is disabled, e.g. for IRC bridges + * + * @return If true, disable rate limiting, otherwise apply configured limits. + */ + inline bool unlimitedMessageRate() const { return _unlimitedMessageRate; } + NetworkInfo networkInfo() const; void setNetworkInfo(const NetworkInfo &); @@ -189,6 +327,50 @@ public : bool supports(const QString ¶m) const { return _supports.contains(param); } QString support(const QString ¶m) const; + /** + * Checks if a given capability is advertised by the server. + * + * These results aren't valid if the network is disconnected or capability negotiation hasn't + * happened, and some servers might not correctly advertise capabilities. Don't treat this as + * a guarantee. + * + * @param[in] capability Name of capability + * @returns True if connected and advertised by the server, otherwise false + */ + inline bool capAvailable(const QString &capability) const { return _caps.contains(capability.toLower()); } + // IRCv3 specs all use lowercase capability names + + /** + * Checks if a given capability is acknowledged and active. + * + * @param[in] capability Name of capability + * @returns True if acknowledged (active), otherwise false + */ + inline bool capEnabled(const QString &capability) const { return _capsEnabled.contains(capability.toLower()); } + // IRCv3 specs all use lowercase capability names + + /** + * Gets the value of an available capability, e.g. for SASL, "EXTERNAL,PLAIN". + * + * @param[in] capability Name of capability + * @returns Value of capability if one was specified, otherwise empty string + */ + QString capValue(const QString &capability) const { return _caps.value(capability.toLower()); } + // IRCv3 specs all use lowercase capability names + // QHash returns the default constructed value if not found, in this case, empty string + // See: https://doc.qt.io/qt-4.8/qhash.html#value + + /** + * Check if the given authentication mechanism is likely to be supported. + * + * This depends on the server advertising SASL support and either declaring available mechanisms + * (SASL 3.2), or just indicating something is supported (SASL 3.1). + * + * @param[in] saslMechanism Desired SASL mechanism + * @return True if mechanism supported or unknown, otherwise false + */ + bool saslMaybeSupports(const QString &saslMechanism) const; + IrcUser *newIrcUser(const QString &hostmask, const QVariantMap &initData = QVariantMap()); inline IrcUser *newIrcUser(const QByteArray &hostmask) { return newIrcUser(decodeServerString(hostmask)); } IrcUser *ircUser(QString nickname) const; @@ -249,6 +431,48 @@ public slots: void setUnlimitedReconnectRetries(bool); void setRejoinChannels(bool); + // Custom rate limiting + + /** + * Sets whether or not custom rate limiting is used. + * + * Setting limits too low may get you disconnected from the server! + * + * @param[in] useCustomRate If true, use custom rate limits, otherwise use Quassel defaults. + */ + void setUseCustomMessageRate(bool useCustomRate); + + /** + * Sets maximum number of messages to send without any delays + * + * @param[in] burstSize + * @parblock + * Maximum number of messages to send without any delays. A value of 1 disables message + * bursting. Cannot be less than 1 as sending 0 messages at a time accomplishes nothing. + * @endparblock + */ + void setMessageRateBurstSize(quint32 burstSize); + + /** + * Sets the delay between messages after the maximum number of undelayed messages have been sent + * + * @param[in] messageDelay + * @parblock + * Delay in milliseconds between messages after the maximum number of undelayed messages have + * been sent. + * @endparblock + */ + void setMessageRateDelay(quint32 messageDelay); + + /** + * Sets whether or not all rate limiting is disabled, e.g. for IRC bridges + * + * Don't use with most normal networks. + * + * @param[in] unlimitedRate If true, disable rate limiting, otherwise apply configured limits. + */ + void setUnlimitedMessageRate(bool unlimitedRate); + void setCodecForServer(const QByteArray &codecName); void setCodecForEncoding(const QByteArray &codecName); void setCodecForDecoding(const QByteArray &codecName); @@ -256,19 +480,90 @@ public slots: void addSupport(const QString ¶m, const QString &value = QString()); void removeSupport(const QString ¶m); + // IRCv3 capability negotiation (can be connected to signals) + + /** + * Add an available capability, optionally providing a value. + * + * This may happen during first connect, or at any time later if a new capability becomes + * available (e.g. SASL service starting). + * + * @param[in] capability Name of the capability + * @param[in] value + * @parblock + * Optional value of the capability, e.g. sasl=plain. + * @endparblock + */ + void addCap(const QString &capability, const QString &value = QString()); + + /** + * Marks a capability as acknowledged (enabled by the IRC server). + * + * @param[in] capability Name of the capability + */ + void acknowledgeCap(const QString &capability); + + /** + * Removes a capability from the list of available capabilities. + * + * This may happen during first connect, or at any time later if an existing capability becomes + * unavailable (e.g. SASL service stopping). This also removes the capability from the list + * of acknowledged capabilities. + * + * @param[in] capability Name of the capability + */ + void removeCap(const QString &capability); + + /** + * Clears all capabilities from the list of available capabilities. + * + * This also removes the capability from the list of acknowledged capabilities. + */ + void clearCaps(); + inline void addIrcUser(const QString &hostmask) { newIrcUser(hostmask); } inline void addIrcChannel(const QString &channel) { newIrcChannel(channel); } //init geters QVariantMap initSupports() const; + /** + * Get the initial list of available capabilities. + * + * @return QVariantMap of indicating available capabilities and values + */ + QVariantMap initCaps() const; + /** + * Get the initial list of enabled (acknowledged) capabilities. + * + * @return QVariantList of QString indicating enabled (acknowledged) capabilities and values + */ + QVariantList initCapsEnabled() const { return toVariantList(capsEnabled()); } inline QVariantList initServerList() const { return toVariantList(serverList()); } virtual QVariantMap initIrcUsersAndChannels() const; //init seters void initSetSupports(const QVariantMap &supports); + /** + * Initialize the list of available capabilities. + * + * @param[in] caps QVariantMap of indicating available capabilities and values + */ + void initSetCaps(const QVariantMap &caps); + /** + * Initialize the list of enabled (acknowledged) capabilities. + * + * @param[in] caps QVariantList of QString indicating enabled (acknowledged) capabilities and values + */ + inline void initSetCapsEnabled(const QVariantList &capsEnabled) { _capsEnabled = fromVariantList(capsEnabled); } inline void initSetServerList(const QVariantList &serverList) { _serverList = fromVariantList(serverList); } virtual void initSetIrcUsersAndChannels(const QVariantMap &usersAndChannels); + /** + * Update IrcUser hostmask and username from mask, creating an IrcUser if one does not exist. + * + * @param[in] mask Full nick!user@hostmask string + * @return IrcUser of the matching nick if exists, otherwise a new IrcUser + */ IrcUser *updateNickFromMask(const QString &mask); // these slots are to keep the hashlists of all users and the @@ -312,6 +607,44 @@ signals: // void unlimitedReconnectRetriesSet(bool); // void rejoinChannelsSet(bool); + // Custom rate limiting (can drive other slots) + + /** + * Signals enabling or disabling custom rate limiting + * + * @see Network::useCustomMessageRate() + * + * @param[out] useCustomRate + */ + void useCustomMessageRateSet(const bool useCustomRate); + + /** + * Signals a change in maximum number of messages to send without any delays + * + * @see Network::messageRateBurstSize() + * + * @param[out] burstSize + */ + void messageRateBurstSizeSet(const quint32 burstSize); + + /** + * Signals a change in delay between messages after the max. undelayed messages have been sent + * + * @see Network::messageRateDelay() + * + * @param[out] messageDelay + */ + void messageRateDelaySet(const quint32 messageDelay); + + /** + * Signals enabling or disabling all rate limiting + * + * @see Network::unlimitedMessageRate() + * + * @param[out] unlimitedRate + */ + void unlimitedMessageRateSet(const bool unlimitedRate); + // void codecForServerSet(const QByteArray &codecName); // void codecForEncodingSet(const QByteArray &codecName); // void codecForDecodingSet(const QByteArray &codecName); @@ -319,6 +652,34 @@ signals: // void supportAdded(const QString ¶m, const QString &value); // void supportRemoved(const QString ¶m); + // IRCv3 capability negotiation (can drive other slots) + /** + * Indicates a capability is now available, with optional value in Network::capValue(). + * + * @see Network::addCap() + * + * @param[in] capability Name of the capability + */ + void capAdded (const QString &capability); + + /** + * Indicates a capability was acknowledged (enabled by the IRC server). + * + * @see Network::acknowledgeCap() + * + * @param[in] capability Name of the capability + */ + void capAcknowledged(const QString &capability); + + /** + * Indicates a capability was removed from the list of available capabilities. + * + * @see Network::removeCap() + * + * @param[in] capability Name of the capability + */ + void capRemoved(const QString &capability); + // void ircUserAdded(const QString &hostmask); void ircUserAdded(IrcUser *); // void ircChannelAdded(const QString &channelname); @@ -352,6 +713,13 @@ private: QHash _ircChannels; // stores all known channels QHash _supports; // stores results from RPL_ISUPPORT + QHash _caps; /// Capabilities supported by the IRC server + // By synchronizing the supported capabilities, the client could suggest certain behaviors, e.g. + // in the Network settings dialog, recommending SASL instead of using NickServ, or warning if + // SASL EXTERNAL isn't available. + QStringList _capsEnabled; /// Enabled capabilities that received 'CAP ACK' + // _capsEnabled uses the same values from the = pairs stored in _caps + ServerList _serverList; bool _useRandomServer; QStringList _perform; @@ -370,6 +738,12 @@ private: bool _unlimitedReconnectRetries; bool _rejoinChannels; + // Custom rate limiting + bool _useCustomMessageRate; /// If true, use custom rate limits, otherwise use defaults + quint32 _messageRateBurstSize; /// Maximum number of messages to send without any delays + quint32 _messageRateDelay; /// Delay in ms. for messages when max. burst messages sent + bool _unlimitedMessageRate; /// If true, disable rate limiting, otherwise apply limits + QTextCodec *_codecForServer; QTextCodec *_codecForEncoding; QTextCodec *_codecForDecoding; @@ -386,50 +760,52 @@ private: //! Stores all editable information about a network (as opposed to runtime state). -struct NetworkInfo { - // set some default values, note that this does not initialize e.g. name and id - NetworkInfo(); - - NetworkId networkId; +struct COMMON_EXPORT NetworkInfo +{ QString networkName; - IdentityId identity; - - bool useCustomEncodings; // not used! - QByteArray codecForServer; - QByteArray codecForEncoding; - QByteArray codecForDecoding; Network::ServerList serverList; - bool useRandomServer; - QStringList perform; - bool useAutoIdentify; - QString autoIdentifyService; + QString autoIdentifyService{"NickServ"}; QString autoIdentifyPassword; - bool useSasl; QString saslAccount; QString saslPassword; - bool useAutoReconnect; - quint32 autoReconnectInterval; - quint16 autoReconnectRetries; - bool unlimitedReconnectRetries; - bool rejoinChannels; + QByteArray codecForServer; + QByteArray codecForEncoding; + QByteArray codecForDecoding; + + NetworkId networkId {0}; + IdentityId identity {1}; + + quint32 messageRateBurstSize {5}; ///< Maximum number of messages to send without any delays + quint32 messageRateDelay {2200}; ///< Delay in ms. for messages when max. burst messages sent + + quint32 autoReconnectInterval {60}; + quint16 autoReconnectRetries {20}; + bool rejoinChannels {true}; + bool useRandomServer {false}; + bool useAutoIdentify {false}; + bool useSasl {false}; + bool useAutoReconnect {true}; + bool unlimitedReconnectRetries {false}; + bool useCustomMessageRate {false}; ///< If true, use custom rate limits, otherwise use defaults + bool unlimitedMessageRate {false}; ///< If true, disable rate limiting, otherwise apply limits + +public: bool operator==(const NetworkInfo &other) const; bool operator!=(const NetworkInfo &other) const; }; -QDataStream &operator<<(QDataStream &out, const NetworkInfo &info); -QDataStream &operator>>(QDataStream &in, NetworkInfo &info); -QDebug operator<<(QDebug dbg, const NetworkInfo &i); +COMMON_EXPORT QDataStream &operator<<(QDataStream &out, const NetworkInfo &info); +COMMON_EXPORT QDataStream &operator>>(QDataStream &in, NetworkInfo &info); +COMMON_EXPORT QDebug operator<<(QDebug dbg, const NetworkInfo &i); Q_DECLARE_METATYPE(NetworkInfo) -QDataStream &operator<<(QDataStream &out, const Network::Server &server); -QDataStream &operator>>(QDataStream &in, Network::Server &server); -QDebug operator<<(QDebug dbg, const Network::Server &server); +COMMON_EXPORT QDataStream &operator<<(QDataStream &out, const Network::Server &server); +COMMON_EXPORT QDataStream &operator>>(QDataStream &in, Network::Server &server); +COMMON_EXPORT QDebug operator<<(QDebug dbg, const Network::Server &server); Q_DECLARE_METATYPE(Network::Server) - -#endif