X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fcommon%2Fnetwork.h;h=bbcd268c275d394367b61731aaf741f5b5abf36d;hb=0d418069762066b4640250efd5ba8d68bf0af178;hp=e425701eaa64d4cccfbc24e0f783a13c0dd558ac;hpb=4f70f02e2c9121a40e01ba9c05652d1e3bc9d5bf;p=quassel.git diff --git a/src/common/network.h b/src/common/network.h index e425701e..bbcd268c 100644 --- a/src/common/network.h +++ b/src/common/network.h @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-2015 by the Quassel Project * + * Copyright (C) 2005-2016 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -96,11 +96,20 @@ 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; QString password; bool useSsl; + bool sslVerify; /// If true, validate SSL certificates int sslVersion; bool useProxy; @@ -110,10 +119,17 @@ public : 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() : port(6667), useSsl(false), sslVerify(true), sslVersion(0), useProxy(false), + proxyType(QNetworkProxy::Socks5Proxy), proxyHost("localhost"), proxyPort(8080) {} + + Server(const QString &host, uint port, const QString &password, bool useSsl, + bool sslVerify) + : host(host), port(port), password(password), useSsl(useSsl), sslVerify(sslVerify), + sslVersion(0), useProxy(false), proxyType(QNetworkProxy::Socks5Proxy), + proxyHost("localhost"), proxyPort(8080) {} + bool operator==(const Server &other) const; bool operator!=(const Server &other) const; }; @@ -164,6 +180,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; } @@ -189,6 +217,26 @@ public : bool supports(const QString ¶m) const { return _supports.contains(param); } QString support(const QString ¶m) const; + /** + * 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 + IrcUser *newIrcUser(const QString &hostmask, const QVariantMap &initData = QVariantMap()); inline IrcUser *newIrcUser(const QByteArray &hostmask) { return newIrcUser(decodeServerString(hostmask)); } IrcUser *ircUser(QString nickname) const; @@ -256,19 +304,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 @@ -319,6 +438,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 +499,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;