fixing backup path
[accounts-sso:vitalyrepins-signon.git] / src / signond / credentialsaccessmanager.h
1 /* -*- Mode: C++; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3  * This file is part of signon
4  *
5  * Copyright (C) 2009-2010 Nokia Corporation.
6  *
7  * Contact: Aurel Popirtac <mailto:ext-Aurel.Popirtac@nokia.com>
8  * Contact: Alberto Mardegan <alberto.mardegan@nokia.com>
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public License
12  * version 2.1 as published by the Free Software Foundation.
13  *
14  * This library is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22  * 02110-1301 USA
23  */
24
25 /*!
26   @file credentialsaccessmanager.h
27   Definition of the CredentialsAccessManager object.
28   @ingroup Accounts_and_SSO_Framework
29  */
30
31 #ifndef CREDENTIALS_ACCESS_MANAGER_H
32 #define CREDENTIALS_ACCESS_MANAGER_H
33
34 #include "credentialsdb.h"
35 #include "signonui_interface.h"
36
37 #include <QObject>
38 #include <QPointer>
39 #include <QFlags>
40
41 #include "SignOn/AbstractKeyAuthorizer"
42 #include "SignOn/AbstractKeyManager"
43 #include "SignOn/KeyHandler"
44 #include "SignOn/crypto-manager.h"
45
46 /*! @def SIGNON_SECURE_STORAGE_NOT_AVAILABLE
47     Use this event type to signal the CAM when the secure storage is
48     not available. CAM can also reply with a event of this type
49     if it doesn't manage to resolve the secure storage access.
50     @sa SecureStorageEvent
51 */
52 #define SIGNON_SECURE_STORAGE_NOT_AVAILABLE (QEvent::User + 1001)
53
54 /*! @def SIGNON_SECURE_STORAGE_AVAILABLE
55     The CAM will reply with an event of this type when
56     the secure storage access will be successfully resolved.
57     @sa SecureStorageEvent
58 */
59 #define SIGNON_SECURE_STORAGE_AVAILABLE (QEvent::User + 1002)
60
61 /**
62  * Manager access to the Credentials DB - synchronized singleton available everywhere in
63  * the Authentication Core module.
64  */
65 namespace SignonDaemonNS {
66
67 /*!
68     @typedef EventSender Guarded pointer for event sending objects.
69  */
70 typedef QPointer<QObject> EventSender;
71
72 /*!
73     @class SecureStorageEvent
74     Any object in the signon framework that needs the
75     CredentialsAccessManager - CAM -  secure storage in order
76     to function properly can signal this event to the CAM.
77     The object posting this event should reimplement the
78     QObject::customEvent(QEvent *event) method and handle response
79     events of the same type coming from the CAM upon success/failure
80     in resolving access to the secure storage.
81     @sa SIGNON_SECURE_STORAGE_NOT_AVAILABLE
82     @sa SIGNON_SECURE_STORAGE_AVAILABLE
83  */
84 class SecureStorageEvent : public QEvent
85 {
86 public:
87
88     SecureStorageEvent(QEvent::Type type)
89         : QEvent(type),
90           m_sender(0)
91     {}
92
93     EventSender m_sender;    /*! << The sender object of the event. */
94 };
95
96 /*!
97     @class CAMConfiguration
98     Configuration object for the CredentialsAccessManager - CAM.
99     @ingroup Accounts_and_SSO_Framework
100  */
101 struct CAMConfiguration
102 {
103     /*!
104       Constructs a CAMConfiguration object with the default configuration - encryption in use.
105     */
106     CAMConfiguration();
107
108     /*!
109       Serializes the CAMConfiguration object as string to a specific IODevice.
110       @param device, must not be null.
111     */
112     void serialize(QIODevice *device);
113
114     /*!
115      * Returns the path to the metadata DB.
116      */
117     QString metadataDBPath() const;
118
119     /*!
120      * Returns the path of the encrypted FS.
121      */
122     QString encryptedFSPath() const;
123
124     QString m_storagePath;      /*!< The base directory for storage. */
125     QString m_dbName;           /*!< The database file name. */
126     bool m_useEncryption;       /*!< Flag for encryption use, enables/disables all of the bellow. */
127     QString m_fileSystemType;   /*!< The encrypted file system type (ext2, ext3, ext4). */
128     quint32 m_fileSystemSize;   /*!< The encrypted file system size. */
129     QByteArray m_encryptionPassphrase; /*!< Passphrase used for opening encrypted FS. */
130     QString m_encryptedStoragePath; /*!< The directory for encrypted storage. */
131     QString m_aegisPath;        /*!< The base directory for aegisfs. */
132 };
133
134 /*!
135   @enum, error reported by the CAM via the lastError() method.
136 */
137 enum CredentialsAccessError {
138     NoError = 0,
139     NotInitialized,
140     AlreadyInitialized,
141     AccessCodeHandlerInitFailed,
142     AccessCodeNotReady,
143     FailedToFetchAccessCode,
144     AccessCodeInvalid,
145     EncryptionInUse,
146     CredentialsDbSetupFailed,
147     CredentialsDbMountFailed,
148     CredentialsDbUnmountFailed,
149     CredentialsDbDeletionFailed,
150     CredentialsDbAlreadyDeployed,
151     CredentialsDbAlreadyMounted,
152     CredentialsDbNotMounted,
153     CredentialsDbConnectionError,
154     CredentialsDbSqlError,
155     UnknownError
156 };
157
158 /*!
159     @class CredentialsAccessManager
160     Main singleton and manager object of the credentials database system.
161     Offers access to the CredentialsDB and AccessControl objects, using a specific configuration
162     (e.g. Access to a SQL database created on an encrypted file system which is mounted by this system).
163     Most calls of this object's methods return false or NULL in case of
164     failure; the specific error code can be retrieved by calling the
165     lastError() method.
166     @ingroup Accounts_and_SSO_Framework
167     @sa CredentialsDB
168     @sa AccessControl
169     @sa AccessCodeHandler
170     @sa CryptoManager
171  */
172 class CredentialsAccessManager : public QObject
173 {
174     Q_OBJECT
175
176     /*!
177         Constructs a CredentialsAccessManager object with the given parent.
178         @param parent
179     */
180     CredentialsAccessManager(QObject *parent = 0);
181
182     /*!
183        @enum KeySwapAuthorizingMech
184        Core key authorization is performed through key swapping mechanisms.
185        This feature becomes available when the number of inserted authorized keys
186        reaches `0`.
187        - If the mechanism is `Disabled`, signon core will attemp authorizing keys
188        only through available AbstractKeyManager implementations that support
189        key authorization.
190        - If the mechanism is `AuthorizedKeyRemovedFirst`, signon core will attempt
191        authorization of a newly inserted key using its internal already authorized
192        keys collection.
193        - If the mechanism is `UnauthorizedKeyRemovedFirst`, signon core will attempt
194        authorization of a previously disabled unauthorized key, if the last physically
195        inserted key is already authorized. In this case the disabled unauthorized
196        key was cached when disabled, prior to its authorization.
197      */
198     enum KeySwapAuthorizingMech {
199         Disabled = 0,               /**< Signon core does not authorize keys. */
200         AuthorizedKeyRemovedFirst,  /**< The key swap order is as suggested. */
201         UnauthorizedKeyRemovedFirst /**< The key swap order is as suggested. */
202     };
203
204     /*!
205       @enum StorageUiCleanupFlag
206       Specific options for cleaning up resources upon secure storage UI closure.
207       @sa KeySwapAuthorizingMech
208      */
209     enum StorageUiCleanupFlag {
210         NoFlags = 0,                 /**< No flags. */
211         DisableCoreKeyAuthorization  /**< Disable any core key authorization mechanism
212                                           and clears any unauthorized cached key that is
213                                           not physically inserted into the device. */
214     };
215     Q_DECLARE_FLAGS(StorageUiCleanupFlags, StorageUiCleanupFlag)
216
217 public:
218
219     /*!
220         Destroys a CredentialsAccessManager.
221         Closes the credentials access system
222          - closes the database connection
223          - unmounts the dedicated encrypted filesystem, if in use.
224     */
225     ~CredentialsAccessManager();
226
227     /*!
228         Creates the CAM instance with the given parent.
229         @param parent
230     */
231     static CredentialsAccessManager *instance(QObject *parent = 0);
232
233     /*!
234         Initializes the CAM instance with the given configuration.
235         If encryption is in use, this will start the key managers and
236         create the CryptoManager object, preparing everything for the
237         mounting of the encrypted file system.
238         @param configuration
239     */
240     bool init(const CAMConfiguration &configuration = CAMConfiguration());
241
242     /*!
243         Finalizes the CAM instance, this could include, closing the credentials system
244         and resetting the configuration. After this call the CAM needs to be reinitialized.
245     */
246     void finalize();
247
248     /*!
249      * Adds a key manager. This method must be called before init().
250      * @param keyManager The key manager to add.
251      */
252     void addKeyManager(SignOn::AbstractKeyManager *keyManager);
253
254     /*!
255      * Initializes know objects from an extension plugin.
256      * @param extension A signon extension plugin.
257      *
258      * @returns True if the extension provides objects that the CAM is using.
259      */
260     bool initExtension(QObject *object);
261
262     /*!
263         Opens the credentials system, creates the CreadentialsDB object;
264         if encryption is configured this will also mount the encrypted file system, based on
265         the AccessControlHandler obtained keys.
266         First call of this method on a specific platform also does the
267         formatting prior to the effective opening.
268
269         @returns true on success, false otherwise. Call lastError() to get
270         the error code.
271     */
272     bool openCredentialsSystem();
273
274     /*!
275         Closes the credentials system
276             - closes the database connection
277             - if encryption is in use, unmounts the encrypted file system
278         This is also called by the destructor.
279
280         @returns true on success, false otherwise. Call lastError() to get
281         the error code.
282     */
283     bool closeCredentialsSystem();
284
285     /*!
286         Deletes the credentials system.
287             - deletes the credentials database
288             - if encryption is in use the encrypted file system will be deleted
289         @warning use this carefully. Upon successful completion this call deletes all the stored credentials.
290
291         @returns true on success, false otherwise. Call lastError() to get
292         the error code.
293     */
294     bool deleteCredentialsSystem();
295
296     /*!
297       For convenience method.
298       @returns true if the credentials system is opened, false otherwise.
299     */
300     bool credentialsSystemOpened() const { return m_systemOpened; }
301
302     /*!
303       The creadentials system is ready when all of the subscribed key managers
304       have successfully reported all of the inserted keys. The credentials
305       system can be ready while at the same time the secure storage is not opened.
306       @returns true if the credentials system is ready, false otherwise.
307     */
308     bool isCredentialsSystemReady() const;
309
310     /*!
311       @returns the credentials database object.
312     */
313     CredentialsDB *credentialsDB() const;
314
315     /*!
316       @returns the CAM in use configuration.
317     */
318     const CAMConfiguration &configuration() const { return m_CAMConfiguration; }
319
320     /*!
321       @sa CredentialsAccessError
322       @returns the last CAM's internally reported error.
323     */
324     CredentialsAccessError lastError() const { return m_error; }
325
326     /*!
327       The CAM manages the encryption keys collection.
328       For convenience method.
329       @returns whether the CAM detected any encryption keys or not.
330     */
331     bool keysAvailable() const;
332
333 Q_SIGNALS:
334     /*!
335       Is emitted when the credentials system becomes ready.
336     */
337     void credentialsSystemReady();
338
339 private Q_SLOTS:
340     void onKeyInserted(const SignOn::Key key);
341     void onLastAuthorizedKeyRemoved(const SignOn::Key key);
342     void onKeyRemoved(const SignOn::Key key);
343     void onKeyAuthorizationQueried(const SignOn::Key, int);
344     void onEncryptedFSMounted();
345     void onEncryptedFSUnmounting();
346
347 protected:
348     void customEvent(QEvent *event);
349
350 private:
351     bool createStorageDir();
352     bool openSecretsDB();
353     bool isSecretsDBOpen();
354     bool closeSecretsDB();
355     bool openMetaDataDB();
356     void closeMetaDataDB();
357     void replyToSecureStorageEventNotifiers();
358
359 private:
360     static CredentialsAccessManager *m_pInstance;
361
362     bool m_isInitialized;
363     bool m_systemOpened;
364     /* Flag indicating whether the system is ready or not.
365      * Currently the system is ready when all of the key managers have
366      * successfully reported all of the inserted keys. */
367     mutable CredentialsAccessError m_error;
368     QList<SignOn::AbstractKeyManager *> keyManagers;
369
370     CredentialsDB *m_pCredentialsDB;
371     SignOn::CryptoManager *m_pCryptoFileSystemManager;
372     SignOn::KeyHandler *m_keyHandler;
373     SignOn::AbstractKeyAuthorizer *m_keyAuthorizer;
374     CAMConfiguration m_CAMConfiguration;
375
376     /* List of all the senders of a SecureStorageEvent. */
377     QList<EventSender> m_secureStorageEventNotifiers;
378 };
379
380 } //namespace SignonDaemonNS
381
382 #endif // CREDENTIALS_ACCESS_MANAGER_H