FdoSecrets: Major Refactor and Code Consolidation (#5747)

* Fixes #3837

* Change objects to use DBusMgr rather than separate adaptors
  - Update all DBus invokable methods to new parameter order
  - Change all usage of DBusReturn to simpler DBusResult
  - Use DBusMgr to handle path and service registration
  - Remove adaptor/*
  - Set path in DBusObject
  - Unregister service when service is destroyed
  - Restore handling of invalid QVariant in prompt complete signal
  - Clean up meta type registration
  - Move dbus related file together
  - Convert to QSharedPointer as much as possible
  - Fix mapping of the Delete method
  - Handle dbus property get all

* Add per-client states
  - Move cipher negotiation to DBusClient
  - Show list of clients instead of sessions in the settings page
  - Add settings for confirmation of accessing items
  - Fix infinite recursion when client disconnected
  - Use optional explicit DBusClient parameter instead. This makes accessing 
    the client info in an async context explicit, and thus prevent accidental 
    assertions in prompts.

* Improve User Interface
  - Add per-item access confirmation (if enabled)
  - Remove the "disable for site" button for the access control dialog
  - Improve the text on the settings page to be more consistent
  - Fix disconnect buttons in settings page not working
  - Make the unlock prompt method nonblocking

* Fix and cleanup unit tests
  - Use QTRY_COMPARE when checking signal spies, as dbus signals are threaded
  - Fixes in meta type registration and type conversion
  - Remove QStringLiteral in COMPARE macros, making diff output readable
  - Add testing for remembering auth decision

src/fdosecrets/objects/Session.cpp

@@ -14,53 +14,36 @@
  *  You should have received a copy of the GNU General Public License
  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #include "Session.h"
 
 #include "fdosecrets/FdoSecretsPlugin.h"
+#include "fdosecrets/dbus/DBusMgr.h"
 #include "fdosecrets/objects/SessionCipher.h"
 
 #include "core/Tools.h"
 
 namespace FdoSecrets
 {
-
-    QHash<QString, QVariant> Session::negotiationState;
-
-    Session* Session::Create(std::unique_ptr<CipherPair>&& cipher, const QString& peer, Service* parent)
+    Session* Session::Create(QSharedPointer<CipherPair> cipher, const QString& peer, Service* parent)
     {
         QScopedPointer<Session> res{new Session(std::move(cipher), peer, parent)};
-
-        if (!res->registerSelf()) {
+        if (!res->dbus()->registerObject(res.data())) {
             return nullptr;
         }
 
         return res.take();
     }
 
-    Session::Session(std::unique_ptr<CipherPair>&& cipher, const QString& peer, Service* parent)
-        : DBusObjectHelper(parent)
+    Session::Session(QSharedPointer<CipherPair> cipher, const QString& peer, Service* parent)
+        : DBusObject(parent)
         , m_cipher(std::move(cipher))
         , m_peer(peer)
         , m_id(QUuid::createUuid())
     {
     }
 
-    bool Session::registerSelf()
-    {
-        auto path = QStringLiteral(DBUS_PATH_TEMPLATE_SESSION).arg(p()->objectPath().path(), id());
-        bool ok = registerWithPath(path);
-        if (!ok) {
-            service()->plugin()->emitError(tr("Failed to register session on DBus at path '%1'").arg(path));
-        }
-        return ok;
-    }
-
-    void Session::CleanupNegotiation(const QString& peer)
-    {
-        negotiationState.remove(peer);
-    }
-
-    DBusReturn<void> Session::close()
+    DBusResult Session::close()
     {
         emit aboutToClose();
         deleteLater();
@@ -83,48 +66,16 @@ namespace FdoSecrets
         return qobject_cast<Service*>(parent());
     }
 
-    std::unique_ptr<CipherPair> Session::CreateCiphers(const QString& peer,
-                                                       const QString& algorithm,
-                                                       const QVariant& input,
-                                                       QVariant& output,
-                                                       bool& incomplete)
-    {
-        Q_UNUSED(peer);
-        incomplete = false;
-
-        std::unique_ptr<CipherPair> cipher{};
-        if (algorithm == QLatin1String(PlainCipher::Algorithm)) {
-            cipher.reset(new PlainCipher);
-        } else if (algorithm == QLatin1String(DhIetf1024Sha256Aes128CbcPkcs7::Algorithm)) {
-            QByteArray clientPublicKey = input.toByteArray();
-            cipher.reset(new DhIetf1024Sha256Aes128CbcPkcs7(clientPublicKey));
-        } else {
-            // error notSupported
-        }
-
-        if (!cipher) {
-            return {};
-        }
-
-        if (!cipher->isValid()) {
-            qWarning() << "FdoSecrets: Error creating cipher";
-            return {};
-        }
-
-        output = cipher->negotiationOutput();
-        return cipher;
-    }
-
-    SecretStruct Session::encode(const SecretStruct& input) const
+    Secret Session::encode(const Secret& input) const
     {
         auto output = m_cipher->encrypt(input);
-        output.session = objectPath();
+        output.session = this;
         return output;
     }
 
-    SecretStruct Session::decode(const SecretStruct& input) const
+    Secret Session::decode(const Secret& input) const
     {
+        Q_ASSERT(input.session == this);
         return m_cipher->decrypt(input);
     }
-
 } // namespace FdoSecrets