ssu.h 7.73 KB
Newer Older
Aard's avatar
Aard committed
1 2 3 4 5 6 7 8 9 10
/**
 * @file ssu.h
 * @copyright 2012 Jolla Ltd.
 * @author Bernd Wachter <bernd.wachter@jollamobile.com>
 * @date 2012
 */

#ifndef _Ssu_H
#define _Ssu_H

11
#include <QDateTime>
Aard's avatar
Aard committed
12 13 14
#include <QObject>
#include <QDebug>

15 16
class QNetworkAccessManager;
class QNetworkReply;
17
class QDomDocument;
18

19 20
class Ssu: public QObject
{
Aard's avatar
Aard committed
21 22
    Q_OBJECT

23 24
    friend class UrlResolverTest;

25
public:
26 27 28 29
    /**
     * Filters to control the output of the repository lookup methods
     */
    enum RepoFilter {
30 31 32 33
        NoFilter,                 ///< All repositories (global + user)
        UserFilter,               ///< Only user configured repositories
        BoardFilter,              ///< Only global repositories, with user blacklist ignored
        BoardFilterUserBlacklist, ///< Only global repositories, with user blacklist applied
34 35 36 37 38 39 40 41
    };

    /**
     * List of possible device modes
     *
     * ReleaseMode is defined to make a switch to allowing RnD and Release
     * repositories on a device at the same time easy, if ever needed. Right
     * now any mode where RndMode is not set is treated as ReleaseMode.
42 43 44
     *
     * If both UpdateMode and AppInstallMode are specified the device behaves
     * like in AppInstallMode.
45 46
     */
    enum DeviceMode {
47 48 49 50 51 52
        DisableRepoManager = 0x1,   ///< Disable automagic repository management
        RndMode            = 0x2,   ///< Enable RnD mode for device
        ReleaseMode        = 0x4,   ///< Enable Release mode
        LenientMode        = 0x8,   ///< Disable strict mode (i.e., keep unmanaged repositories)
        UpdateMode         = 0x10,  ///< Do repo isolation and similar bits important for updating devices
        AppInstallMode     = 0x20   ///< Do repo isolation, but keep store repository enabled
53 54 55 56 57 58 59 60
    };

    Q_DECLARE_FLAGS(DeviceModeFlags, DeviceMode)

    /**
     * A list of types ssu provides shiny values suitable for displaying
     */
    enum DisplayType {
61 62 63
        DeviceManufacturer = 0,     ///< Manufacturer, like ACME Corp. Board mappings key "deviceManufacturer"
        DeviceModel,                ///< Marketed device name, like Pogoblaster 3000. Board mappings key "prettyModel"
        DeviceDesignation,          ///< Type designation, like NCC-1701. Beard mappings key "deviceDesignation"
64 65 66 67 68 69
    };

    /**
     * Edit modes for variables containing bitmasks
     */
    enum EditMode {
70 71 72
        Replace = 0x1, ///< Replace the old value with the new one
        Add     = 0x2, ///< Make sure the given value is set in the bitmask
        Remove  = 0x4, ///< Make sure the given value is not set in the bitmask
73 74 75 76 77 78
    };

    /**
     * Return codes to signal success or error conditions
     */
    enum ReturnValue {
79 80
        Success = 0,
        ErrUpdateMode = -10,
81 82
    };

83
    Ssu();
Aard's avatar
Aard committed
84 85 86 87 88 89 90 91 92 93 94 95 96 97
    /**
     * Find a username/password pair for the given scope
     * @return a QPair with username and password, or an empty QPair if scope is invalid
     */
    QPair<QString, QString> credentials(QString scope);
    /**
     * Get the scope for a repository, taking into account different scopes for
     * release and RnD repositories
     *
     * Please note that variable scope is not yet implemented -- one default scope is
     * read from the configuration file.
     *
     * @return a string containing the scope; it can be used to look up login credentials using  credentials()
     */
98
    QString credentialsScope(QString repoName, bool rndRepo = false);
99 100 101 102
    /**
     * Return the URL for which credentials scope is valid
     */
    QString credentialsUrl(QString scope);
Aard's avatar
Aard committed
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
    /**
     * Returns if the last operation was successful
     * @retval true last operation was successful
     * @retval false last operation failed, you should check lastError() for details
     */
    Q_INVOKABLE bool error();
    /**
     * Return an error message for the last error encountered. The message
     * will not be cleared, check error() to see if the last operation was
     * successful.
     */
    Q_INVOKABLE QString lastError();
    /**
     * Resolve a repository url
     * @return the repository URL on success, an empty string on error
     */
119 120 121
    QString repoUrl(QString repoName, bool rndRepo = false,
                    QHash<QString, QString> repoParameters = QHash<QString, QString>(),
                    QHash<QString, QString> parametersOverride = QHash<QString, QString>());
Aard's avatar
Aard committed
122 123
    /**
     * Unregister a device. This will clean all registration data from a device,
124
     * though will not touch the information on ssu server; the information there
Aard's avatar
Aard committed
125 126 127 128
     * has to be manually cleaned for a device we don't own anymore, but will be
     * overwritten next time the device gets registered
     */
    Q_INVOKABLE void unregister();
129 130 131 132 133 134 135 136

    // wrappers around SsuCoreConfig
    // not all of those belong into SsuCoreConfig, but will go there
    // in the first phase of refactoring

    /// See SsuCoreConfig::flavour
    Q_INVOKABLE QString flavour();
    /// See SsuCoreConfig::deviceMode
137
    Q_INVOKABLE DeviceModeFlags deviceMode();
138
    /// See SsuCoreConfig::domain; returns printable version
139 140 141 142 143 144
    Q_INVOKABLE QString domain();
    /// See SsuCoreConfig::isRegistered
    Q_INVOKABLE bool isRegistered();
    /// See SsuCoreConfig::lastCredentialsUpdate
    Q_INVOKABLE QDateTime lastCredentialsUpdate();
    /// See SsuCoreConfig::release
145
    Q_INVOKABLE QString release(bool rnd = false);
146
    /// See SsuCoreConfig::setDeviceMode
147
    Q_INVOKABLE void setDeviceMode(DeviceModeFlags mode, enum EditMode editMode = Replace);
148 149 150
    /// See SsuCoreConfig::setFlavour
    Q_INVOKABLE void setFlavour(QString flavour);
    /// See SsuCoreConfig::setRelease
151
    Q_INVOKABLE void setRelease(QString release, bool rnd = false);
152 153 154
    /// See SsuCoreConfig::setDomain
    Q_INVOKABLE void setDomain(QString domain);
    /// See SsuCoreConfig::useSslVerify
Aard's avatar
Aard committed
155 156
    Q_INVOKABLE bool useSslVerify();

157
private:
158
    QString errorString;
Aard's avatar
Aard committed
159 160
    bool errorFlag;
    QNetworkAccessManager *manager;
161
    int pendingRequests;
Aard's avatar
Aard committed
162 163 164
    bool registerDevice(QDomDocument *response);
    bool setCredentials(QDomDocument *response);
    bool verifyResponse(QDomDocument *response);
165
    void storeAuthorizedKeys(QByteArray data);
Aard's avatar
Aard committed
166

167
private slots:
Aard's avatar
Aard committed
168 169 170 171 172 173 174
    void requestFinished(QNetworkReply *reply);
    /**
     * Set errorString returned by lastError to errorMessage, set
     * errorFlag returned by error() to true, and emit done()
     */
    void setError(QString errorMessage);

175
public slots:
Aard's avatar
Aard committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196
    /**
     * Attempt RND device registration, using @a username and @a password supplied
     * @param username Jolla username
     * @param password Jolla password
     *
     * When the operation has finished the done() signal will be sent. You can call
     * error() to check if an error occured, and use lastError() to retrieve the last
     * error message.
     */
    void sendRegistration(QString username, QString password);
    /**
     * Try to update the RND repository credentials. The device needs to be registered
     * for this to work. updateCredentials remembers the time of the last credentials
     * update, and skips updating if only little time has elapsed since the last update.
     * An update may be forced by setting @a force to true
     * @param force force credentials updating
     *
     * When the operation has finished the done() signal will be sent. You can call
     * error() to check if an error occured, and use lastError() to retrieve the last
     * error message.
     */
197
    void updateCredentials(bool force = false);
198 199 200
    /**
     * Try to update credentials for (Jolla) store
     */
201
    void updateStoreCredentials();
Aard's avatar
Aard committed
202

203
signals:
Aard's avatar
Aard committed
204 205 206 207
    /**
     * Emitted after an asynchronous operation finished
     */
    void done();
208 209 210
    /**
     * Emitted after the devices registration status has changed
     */
Aard's avatar
Aard committed
211 212 213 214
    void registrationStatusChanged();
    void credentialsChanged();
};

215 216
Q_DECLARE_OPERATORS_FOR_FLAGS(Ssu::DeviceModeFlags)

Aard's avatar
Aard committed
217
#endif