src/common/quassel.h

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2018 by the Quassel Project                        *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  19  ***************************************************************************/
  20
  21 #pragma once
  22
  23 #include <functional>
  24 #include <vector>
  25
  26 #include <QCommandLineParser>
  27 #include <QCoreApplication>
  28 #include <QFile>
  29 #include <QLocale>
  30 #include <QObject>
  31 #include <QString>
  32 #include <QStringList>
  33
  34 #include "abstractsignalwatcher.h"
  35 #include "singleton.h"
  36
  37 class QFile;
  38
  39 class Logger;
  40
  41 class Quassel : public QObject, public Singleton<Quassel>
  42 {
  43     // TODO Qt5: Use Q_GADGET
  44     Q_OBJECT
  45
  46 public:
  47     enum RunMode {
  48         Monolithic,
  49         ClientOnly,
  50         CoreOnly
  51     };
  52
  53     struct BuildInfo {
  54         QString fancyVersionString; // clickable rev
  55         QString plainVersionString; // no <a> tag
  56
  57         QString baseVersion;
  58         QString generatedVersion;
  59         QString commitHash;
  60         QString commitDate;
  61
  62         uint protocolVersion; // deprecated
  63
  64         QString applicationName;
  65         QString coreApplicationName;
  66         QString clientApplicationName;
  67         QString organizationName;
  68         QString organizationDomain;
  69     };
  70
  71     /**
  72      * This enum defines the optional features supported by cores/clients prior to version 0.13.
  73      *
  74      * Since the number of features declared this way is limited to 16 (due to the enum not having a defined
  75      * width in cores/clients prior to 0.13), and for more robustness when negotiating features on connect,
  76      * the bitfield-based representation was replaced by a string-based representation in 0.13, support for
  77      * which is indicated by having the ExtendedFeatures flag set. Extended features are defined in the Feature
  78      * enum.
  79      *
  80      * @warning Do not alter this enum; new features must be added (only) to the @a Feature enum.
  81      *
  82      * @sa Feature
  83      */
  84     enum class LegacyFeature : quint32 {
  85         SynchronizedMarkerLine = 0x0001,
  86         SaslAuthentication     = 0x0002,
  87         SaslExternal           = 0x0004,
  88         HideInactiveNetworks   = 0x0008,
  89         PasswordChange         = 0x0010,
  90         CapNegotiation         = 0x0020,
  91         VerifyServerSSL        = 0x0040,
  92         CustomRateLimits       = 0x0080,
  93         // DccFileTransfer     = 0x0100,  // never in use
  94         AwayFormatTimestamp    = 0x0200,
  95         Authenticators         = 0x0400,
  96         BufferActivitySync     = 0x0800,
  97         CoreSideHighlights     = 0x1000,
  98         SenderPrefixes         = 0x2000,
  99         RemoteDisconnect       = 0x4000,
 100         ExtendedFeatures       = 0x8000,
 101     };
 102     Q_FLAGS(LegacyFeature)
 103     Q_DECLARE_FLAGS(LegacyFeatures, LegacyFeature)
 104
 105     /**
 106      * A list of features that are optional in core and/or client, but need runtime checking.
 107      *
 108      * Some features require an uptodate counterpart, but don't justify a protocol break.
 109      * This is what we use this enum for. Add such features to it and check at runtime on the other
 110      * side for their existence.
 111      *
 112      * For feature negotiation, these enum values are serialized as strings, so order does not matter. However,
 113      * do not rename existing enum values to avoid breaking compatibility.
 114      *
 115      * This list should be cleaned up after every protocol break, as we can assume them to be present then.
 116      */
 117     enum class Feature : uint32_t {
 118         SynchronizedMarkerLine,
 119         SaslAuthentication,
 120         SaslExternal,
 121         HideInactiveNetworks,
 122         PasswordChange,           ///< Remote password change
 123         CapNegotiation,           ///< IRCv3 capability negotiation, account tracking
 124         VerifyServerSSL,          ///< IRC server SSL validation
 125         CustomRateLimits,         ///< IRC server custom message rate limits
 126         AwayFormatTimestamp,      ///< Timestamp formatting in away (e.g. %%hh:mm%%)
 127         Authenticators,           ///< Whether or not the core supports auth backends
 128         BufferActivitySync,       ///< Sync buffer activity status
 129         CoreSideHighlights,       ///< Core-Side highlight configuration and matching
 130         SenderPrefixes,           ///< Show prefixes for senders in backlog
 131         RemoteDisconnect,         ///< Allow this peer to be remotely disconnected
 132         ExtendedFeatures,         ///< Extended features
 133         LongTime,                 ///< Serialize time as 64-bit values
 134         RichMessages,             ///< Real Name and Avatar URL in backlog
 135         BacklogFilterType,        ///< BacklogManager supports filtering backlog by MessageType
 136         EcdsaCertfpKeys,          ///< ECDSA keys for CertFP in identities
 137         LongMessageId,            ///< 64-bit IDs for messages
 138         SyncedCoreInfo,           ///< CoreInfo dynamically updated using signals
 139     };
 140     Q_ENUMS(Feature)
 141
 142     class Features;
 143
 144     Quassel();
 145
 146     void init(RunMode runMode);
 147
 148     /**
 149      * Provides access to the Logger instance.
 150      *
 151      * @returns The Logger instance
 152      */
 153     Logger *logger() const;
 154
 155     static void setupBuildInfo();
 156     static const BuildInfo &buildInfo();
 157     static RunMode runMode();
 158
 159     static QString configDirPath();
 160
 161     //! Returns a list of data directory paths
 162     /** There are several locations for applications to install their data files in. On Unix,
 163     *  a common location is /usr/share; others include $PREFIX/share and additional directories
 164     *  specified in the env variable XDG_DATA_DIRS.
 165     *  \return A list of directory paths to look for data files in
 166     */
 167     static QStringList dataDirPaths();
 168
 169     //! Searches for a data file in the possible data directories
 170     /** Data files can reside in $DATA_DIR/apps/quassel, where $DATA_DIR is one of the directories
 171     *  returned by \sa dataDirPaths().
 172     *  \Note With KDE integration enabled, files are searched (only) in KDE's appdata dirs.
 173     *  \return The full path to the data file if found; a null QString else
 174     */
 175     static QString findDataFilePath(const QString &filename);
 176
 177     static QString translationDirPath();
 178
 179     //! Returns a list of directories we look for scripts in
 180     /** We look for a subdirectory named "scripts" in the configdir and in all datadir paths.
 181     *   \return A list of directory paths containing executable scripts for /exec
 182     */
 183     static QStringList scriptDirPaths();
 184
 185     static void loadTranslation(const QLocale &locale);
 186
 187     static QString optionValue(const QString &option);
 188     static bool isOptionSet(const QString &option);
 189
 190     using ReloadHandler = std::function<bool()>;
 191
 192     static void registerReloadHandler(ReloadHandler handler);
 193
 194     using QuitHandler = std::function<void()>;
 195
 196     /**
 197      * Registers a handler that is called when the application is supposed to quit.
 198      *
 199      * @note If multiple handlers are registered, they are processed in order of registration.
 200      * @note If any handler is registered, quit() will not call QCoreApplication::quit(). It relies
 201      *       on one of the handlers doing so, instead.
 202      * @param quitHandler Handler to register
 203      */
 204     static void registerQuitHandler(QuitHandler quitHandler);
 205
 206     const QString &coreDumpFileName();
 207
 208 public slots:
 209     /**
 210      * Requests to quit the application.
 211      *
 212      * Calls any registered quit handlers. If no handlers are registered, calls QCoreApplication::quit().
 213      */
 214     void quit();
 215
 216 signals:
 217     void messageLogged(const QDateTime &timeStamp, const QString &msg);
 218
 219 private:
 220     void registerMetaTypes();
 221     void setupSignalHandling();
 222     void setupEnvironment();
 223     void setupCliParser();
 224
 225     /**
 226      * Requests a reload of relevant runtime configuration.
 227      *
 228      * Calls any registered reload handlers, and returns the cumulative result. If no handlers are registered,
 229      * does nothing and returns true.
 230      *
 231      * @returns True if configuration reload successful, otherwise false
 232      */
 233     bool reloadConfig();
 234
 235     void logBacktrace(const QString &filename);
 236
 237 private slots:
 238     void handleSignal(AbstractSignalWatcher::Action action);
 239
 240 private:
 241     BuildInfo _buildInfo;
 242     RunMode _runMode;
 243     bool _quitting{false};
 244
 245     QString _coreDumpFileName;
 246     QString _configDirPath;
 247     QStringList _dataDirPaths;
 248     QString _translationDirPath;
 249
 250     QCommandLineParser _cliParser;
 251
 252     Logger *_logger;
 253     AbstractSignalWatcher *_signalWatcher{nullptr};
 254
 255     std::vector<ReloadHandler> _reloadHandlers;
 256     std::vector<QuitHandler> _quitHandlers;
 257 };
 258
 259 // --------------------------------------------------------------------------------------------------------------------
 260
 261 /**
 262  * Class representing a set of supported core/client features.
 263  *
 264  * @sa Quassel::Feature
 265  */
 266 class Quassel::Features
 267 {
 268 public:
 269     /**
 270      * Default constructor.
 271      *
 272      * Creates a Feature instance with all known features (i.e., all values declared in the Quassel::Feature enum) set.
 273      * This is useful for easily creating a Feature instance that represent the current version's capabilities.
 274      */
 275     Features();
 276
 277     /**
 278      * Constructs a Feature instance holding the given list of features.
 279      *
 280      * Both the @a features and the @a legacyFeatures arguments are considered (additively).
 281      * This is useful when receiving a list of features from another peer.
 282      *
 283      * @param features       A list of strings matching values in the Quassel::Feature enum. Strings that don't match are
 284      *                       can be accessed after construction via unknownFeatures(), but are otherwise ignored.
 285      * @param legacyFeatures Holds a bit-wise combination of LegacyFeature flag values, which are each added to the list of
 286      *                       features represented by this Features instance.
 287      */
 288     Features(const QStringList &features, LegacyFeatures legacyFeatures);
 289
 290     /**
 291      * Check if a given feature is marked as enabled in this Features instance.
 292      *
 293      * @param feature The feature to be queried
 294      * @returns Whether the given feature is marked as enabled
 295      */
 296     bool isEnabled(Feature feature) const;
 297
 298     /**
 299      * Provides a list of all features marked as either enabled or disabled (as indicated by the @a enabled argument) as strings.
 300      *
 301      * @param enabled Whether to return the enabled or the disabled features
 302      * @return A string list containing all enabled or disabled features
 303      */
 304     QStringList toStringList(bool enabled = true) const;
 305
 306     /**
 307      * Provides a list of all enabled legacy features (i.e. features defined prior to v0.13) as bit-wise combination in a
 308      * LegacyFeatures type.
 309      *
 310      * @note Extended features cannot be represented this way, and are thus ignored even if set.
 311      * @return A LegacyFeatures type holding the bit-wise combination of all legacy features enabled in this Features instance
 312      */
 313     LegacyFeatures toLegacyFeatures() const;
 314
 315     /**
 316      * Provides the list of strings that could not be mapped to Quassel::Feature enum values on construction.
 317      *
 318      * Useful for debugging/logging purposes.
 319      *
 320      * @returns A list of strings that could not be mapped to the Feature enum on construction of this Features instance, if any
 321      */
 322     QStringList unknownFeatures() const;
 323
 324 private:
 325     std::vector<bool> _features;
 326     QStringList _unknownFeatures;
 327 };