/
ssu.h
221 lines (201 loc) · 8.03 KB
/
ssu.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
/**
* @file ssu.h
* @copyright 2012 Jolla Ltd.
* @author Bernd Wachter <bernd.wachter@jollamobile.com>
* @date 2012
*/
#ifndef _Ssu_H
#define _Ssu_H
#include <QDateTime>
#include <QObject>
#include <QDebug>
class QNetworkAccessManager;
class QNetworkReply;
class QDomDocument;
class Ssu: public QObject
{
Q_OBJECT
friend class UrlResolverTest;
Q_PROPERTY(bool registered READ isRegistered NOTIFY registrationStatusChanged)
Q_PROPERTY(DeviceModeFlags deviceMode READ deviceMode CONSTANT)
Q_PROPERTY(QString domain READ domain CONSTANT)
public:
/**
* Filters to control the output of the repository lookup methods
*/
enum RepoFilter {
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
};
/**
* 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.
*
* If both UpdateMode and AppInstallMode are specified the device behaves
* like in AppInstallMode.
*/
enum DeviceMode {
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
};
Q_DECLARE_FLAGS(DeviceModeFlags, DeviceMode)
Q_FLAGS(DeviceModeFlags)
/**
* A list of types ssu provides shiny values suitable for displaying
*/
enum DisplayType {
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"
};
/**
* Edit modes for variables containing bitmasks
*/
enum EditMode {
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
};
/**
* Return codes to signal success or error conditions
*/
enum ReturnValue {
Success = 0,
ErrUpdateMode = -10,
};
Ssu();
/**
* 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(const 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()
*/
QString credentialsScope(const QString &repoName, bool rndRepo = false);
/**
* Return the URL for which credentials scope is valid
*/
QString credentialsUrl(const QString &scope);
/**
* 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
*/
QString repoUrl(const QString &repoName, bool rndRepo = false,
QHash<QString, QString> repoParameters = QHash<QString, QString>(),
QHash<QString, QString> parametersOverride = QHash<QString, QString>());
/**
* Unregister a device. This will clean all registration data from a device,
* though will not touch the information on ssu server; the information there
* 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();
// 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
Q_INVOKABLE DeviceModeFlags deviceMode();
/// See SsuCoreConfig::domain; returns printable version
Q_INVOKABLE QString domain();
/// See SsuCoreConfig::isRegistered
Q_INVOKABLE bool isRegistered();
/// See SsuCoreConfig::lastCredentialsUpdate
Q_INVOKABLE QDateTime lastCredentialsUpdate();
/// See SsuCoreConfig::release
Q_INVOKABLE QString release(bool rnd = false);
/// See SsuCoreConfig::setDeviceMode
Q_INVOKABLE void setDeviceMode(DeviceModeFlags mode, enum EditMode editMode = Replace);
/// See SsuCoreConfig::setFlavour
Q_INVOKABLE void setFlavour(const QString &flavour);
/// See SsuCoreConfig::setRelease
Q_INVOKABLE void setRelease(const QString &release, bool rnd = false);
/// See SsuCoreConfig::setDomain
Q_INVOKABLE void setDomain(const QString &domain);
/// See SsuCoreConfig::useSslVerify
Q_INVOKABLE bool useSslVerify();
private:
QString errorString;
bool errorFlag;
QNetworkAccessManager *manager;
int pendingRequests;
bool registerDevice(QDomDocument *response);
bool setCredentials(QDomDocument *response);
bool verifyResponse(QDomDocument *response);
void storeAuthorizedKeys(const QByteArray &data);
private slots:
void requestFinished(QNetworkReply *reply);
/**
* Set errorString returned by lastError to errorMessage, set
* errorFlag returned by error() to true, and emit done()
*/
void setError(const QString &errorMessage);
public slots:
/**
* 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(const QString &username, const 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.
*/
void updateCredentials(bool force = false);
/**
* Try to update credentials for (Jolla) store
*/
void updateStoreCredentials();
signals:
/**
* Emitted after an asynchronous operation finished
*/
void done();
/**
* Emitted after the devices registration status has changed
*/
void registrationStatusChanged();
void credentialsChanged();
};
Q_DECLARE_OPERATORS_FOR_FLAGS(Ssu::DeviceModeFlags)
#endif