[SCM] kdeconnect packaging branch, master, updated. debian/0.9g-1-1183-g9d69498

Maximiliano Curia maxy at moszumanska.debian.org
Fri Oct 14 14:28:45 UTC 2016


Gitweb-URL: http://git.debian.org/?p=pkg-kde/kde-extras/kdeconnect.git;a=commitdiff;h=7c777e6

The following commit has been merged in the master branch:
commit 7c777e62790985e1f810c813204809072c9d9f1f
Author: Vineet Garg <grg.vineet at gmail.com>
Date:   Fri Jul 10 03:21:08 2015 +0530

    Implemented pairing handler interface
---
 core/backends/lan/lanlinkprovider.cpp   | 22 ++++++++++++--
 core/backends/lan/lanpairinghandler.cpp | 45 ++++++++++++++++++++++------
 core/backends/lan/lanpairinghandler.h   | 13 ++++----
 core/backends/linkprovider.h            |  6 ++++
 core/backends/pairinghandler.h          |  9 +++---
 core/daemon.cpp                         | 11 +++++++
 core/daemon.h                           |  4 +++
 core/device.cpp                         | 53 +++++++++++++++++++--------------
 core/device.h                           |  7 ++++-
 core/networkpackage.cpp                 |  8 +++++
 core/networkpackage.h                   |  1 +
 plugins/sftp/kdeconnect_sftp.json       |  2 +-
 12 files changed, 136 insertions(+), 45 deletions(-)

diff --git a/core/backends/lan/lanlinkprovider.cpp b/core/backends/lan/lanlinkprovider.cpp
index 3ccf680..0314ebf 100644
--- a/core/backends/lan/lanlinkprovider.cpp
+++ b/core/backends/lan/lanlinkprovider.cpp
@@ -33,9 +33,11 @@
 #include <QNetworkSession>
 #include <QNetworkConfigurationManager>
 
+#include "../../daemon.h"
 #include "landevicelink.h"
+#include "lanpairinghandler.h"
 #include <kdeconnectconfig.h>
-#include <QtNetwork/qsslkey.h>
+#include <QDBusPendingReply>
 #include <QtNetwork/qsslcipher.h>
 #include <QtNetwork/qsslconfiguration.h>
 
@@ -49,6 +51,8 @@ LanLinkProvider::LanLinkProvider()
     mServer = new Server(this);
     connect(mServer,SIGNAL(newConnection(QSslSocket*)),this, SLOT(newConnection(QSslSocket*)));
 
+    pairingHandler = new LanPairingHandler();
+
     //Detect when a network interface changes status, so we announce ourelves in the new network
     QNetworkConfigurationManager* networkManager;
     networkManager = new QNetworkConfigurationManager(this);
@@ -273,7 +277,21 @@ void LanLinkProvider::sslErrors(QList<QSslError> errors)
 
     foreach(QSslError error, errors) {
         qCDebug(KDECONNECT_CORE) << "SSL Error :" << error.errorString();
-        //TODO: Check for varius error here
+        switch (error.error()) {
+            case QSslError::CertificateSignatureFailed:
+            case QSslError::CertificateNotYetValid:
+            case QSslError::CertificateExpired:
+            case QSslError::CertificateUntrusted:
+            case QSslError::SelfSignedCertificate:
+                qCDebug(KDECONNECT_CORE) << "Unpairing device due to " << error.errorString();
+                // Not able to find an alternative now
+                Daemon::instance()->getDevice(socket->peerVerifyName())->unpair();
+                break;
+            default:
+                continue;
+                // Lots of warnings without this
+
+        }
     }
 
     delete receivedIdentityPackages[socket].np;
diff --git a/core/backends/lan/lanpairinghandler.cpp b/core/backends/lan/lanpairinghandler.cpp
index 7db6145..38a6c32 100644
--- a/core/backends/lan/lanpairinghandler.cpp
+++ b/core/backends/lan/lanpairinghandler.cpp
@@ -18,33 +18,60 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <kdeconnectconfig.h>
 #include "lanpairinghandler.h"
+#include "networkpackagetypes.h"
 
 LanPairingHandler::LanPairingHandler() {
 
 }
 
-NetworkPackage* LanPairingHandler::createPairPackage(Device *device) {
-    NetworkPackage* np = new NetworkPackage("");
+NetworkPackage LanPairingHandler::createPairPackage() {
+    NetworkPackage np(PACKAGE_TYPE_PAIR);
+    np.set("pair", true);
+    np.set("publicKey", KdeConnectConfig::instance()->publicKey().toPEM());
     return np;
 }
 
-void LanPairingHandler::packageReceived(Device *device) {
-
+bool LanPairingHandler::packageReceived(Device *device, NetworkPackage np) {
+    //Retrieve their public key
+    const QString& keyString = np.get<QString>("publicKey");
+    device->setPublicKey(QCA::RSAPublicKey::fromPEM(keyString));
+    if (device->publicKey().isNull()) {
+        return false;
+    }
+    return true;
 }
 
-void LanPairingHandler::requestPairing(Device *device) {
-
+bool LanPairingHandler::requestPairing(Device *device) {
+    NetworkPackage np = createPairPackage();
+    bool success = device->sendPackage(np);
+    return success;
 }
 
-void LanPairingHandler::acceptPairing(Device *device) {
-
+bool LanPairingHandler::acceptPairing(Device *device) {
+    NetworkPackage np = createPairPackage();
+    bool success = device->sendPackage(np);
+    return success;
 }
 
 void LanPairingHandler::rejectPairing(Device *device) {
-
+    // TODO : check status of reject pairing
+    NetworkPackage np(PACKAGE_TYPE_PAIR);
+    np.set("pair", false);
+    device->sendPackage(np);
 }
 
 void LanPairingHandler::pairingDone(Device *device) {
+    // TODO : Save certificate and public key here
+
+    // No need to worry, if either of certificate or public key is null an empty qstring will be returned
+    KdeConnectConfig::instance()->setDeviceProperty(device->id(), "key", device->publicKey().toPEM());
+    KdeConnectConfig::instance()->setDeviceProperty(device->id(), "certificate", QString(device->certificate().toPem()));
+}
 
+void LanPairingHandler::unpair(Device *device) {
+    NetworkPackage np(PACKAGE_TYPE_PAIR);
+    np.set("pair", false);
+    bool success = device->sendPackage(np);
 }
diff --git a/core/backends/lan/lanpairinghandler.h b/core/backends/lan/lanpairinghandler.h
index 089b945..2fb7052 100644
--- a/core/backends/lan/lanpairinghandler.h
+++ b/core/backends/lan/lanpairinghandler.h
@@ -30,12 +30,13 @@ public:
     LanPairingHandler();
     virtual ~LanPairingHandler() { }
 
-    virtual NetworkPackage* createPairPackage(Device *device);
-    virtual void packageReceived(Device *device);
-    virtual void requestPairing(Device *device);
-    virtual void acceptPairing(Device *device);
-    virtual void rejectPairing(Device *device);
-    virtual void pairingDone(Device *device);
+    virtual NetworkPackage createPairPackage() Q_DECL_OVERRIDE;
+    virtual bool packageReceived(Device *device, NetworkPackage np) Q_DECL_OVERRIDE;
+    virtual bool requestPairing(Device *device) Q_DECL_OVERRIDE;
+    virtual bool acceptPairing(Device *device) Q_DECL_OVERRIDE;
+    virtual void rejectPairing(Device *device) Q_DECL_OVERRIDE;
+    virtual void pairingDone(Device *device) Q_DECL_OVERRIDE;
+    virtual void unpair(Device* device) Q_DECL_OVERRIDE;
 
 
 };
diff --git a/core/backends/linkprovider.h b/core/backends/linkprovider.h
index f4fc309..7d5ca0f 100644
--- a/core/backends/linkprovider.h
+++ b/core/backends/linkprovider.h
@@ -26,6 +26,7 @@
 #include <QNetworkSession>
 
 #include "core/networkpackage.h"
+#include "pairinghandler.h"
 
 class DeviceLink;
 
@@ -34,6 +35,9 @@ class LinkProvider
 {
     Q_OBJECT
 
+protected:
+    PairingHandler* pairingHandler;
+
 public:
 
     const static int PRIORITY_LOW = 0;      //eg: 3g internet
@@ -45,6 +49,8 @@ public:
 
     virtual QString name() = 0;
     virtual int priority() = 0;
+    PairingHandler* getPairingHandler() { return pairingHandler;}
+
 
 public Q_SLOTS:
     virtual void onStart() = 0;
diff --git a/core/backends/pairinghandler.h b/core/backends/pairinghandler.h
index 88025ac..5b91b0e 100644
--- a/core/backends/pairinghandler.h
+++ b/core/backends/pairinghandler.h
@@ -31,12 +31,13 @@ public:
     PairingHandler();
     virtual ~PairingHandler() { }
 
-    virtual NetworkPackage* createPairPackage(Device *device) = 0;
-    virtual void packageReceived(Device *device) = 0;
-    virtual void requestPairing(Device *device) = 0;
-    virtual void acceptPairing(Device *device) = 0;
+    virtual NetworkPackage createPairPackage() = 0;
+    virtual bool packageReceived(Device *device, NetworkPackage np) = 0;
+    virtual bool requestPairing(Device *device) = 0;
+    virtual bool acceptPairing(Device *device) = 0;
     virtual void rejectPairing(Device *device) = 0;
     virtual void pairingDone(Device *device) = 0;
+    virtual void unpair(Device *device) = 0;
 
 };
 
diff --git a/core/daemon.cpp b/core/daemon.cpp
index ce16a55..13a650d 100644
--- a/core/daemon.cpp
+++ b/core/daemon.cpp
@@ -107,6 +107,17 @@ void Daemon::forceOnNetworkChange()
     }
 }
 
+// I hate this, but not able to find an alternative now
+Device *Daemon::getDevice(QString deviceId) {
+
+    Q_FOREACH(Device* device, d->mDevices) {
+        if (device->id() == deviceId) {
+            return device;
+        }
+    }
+    return Q_NULLPTR;
+}
+
 QStringList Daemon::devices(bool onlyReachable, bool onlyVisible) const
 {
     QStringList ret;
diff --git a/core/daemon.h b/core/daemon.h
index 674ca01..db65b49 100644
--- a/core/daemon.h
+++ b/core/daemon.h
@@ -26,6 +26,7 @@
 #include <QMap>
 
 #include "kdeconnectcore_export.h"
+#include "device.h"
 
 class NetworkPackage;
 class DeviceLink;
@@ -76,6 +77,9 @@ private Q_SLOTS:
 
 private:
     QScopedPointer<struct DaemonPrivate> d;
+
+public:
+    Device* getDevice(QString deviceId);
 };
 
 #endif
diff --git a/core/device.cpp b/core/device.cpp
index a7fb75a..20a2ebe 100644
--- a/core/device.cpp
+++ b/core/device.cpp
@@ -209,12 +209,14 @@ void Device::requestPair()
     m_pairStatus = Device::Requested;
 
     //Send our own public key
-    bool success = sendOwnPublicKey();
+    Q_FOREACH(DeviceLink* dl, m_deviceLinks) {
+        bool success = dl->provider()->getPairingHandler()->requestPairing(this);
 
-    if (!success) {
-        m_pairStatus = Device::NotPaired;
-        Q_EMIT pairingFailed(i18n("Error contacting device"));
-        return;
+        if (!success) {
+            m_pairStatus = Device::NotPaired;
+            Q_EMIT pairingFailed(i18n("Error contacting device"));
+            return;
+        }
     }
 
     if (m_pairStatus == Device::Paired) {
@@ -227,9 +229,9 @@ void Device::requestPair()
 void Device::unpair()
 {
 
-    NetworkPackage np(PACKAGE_TYPE_PAIR);
-    np.set("pair", false);
-    sendPackage(np);
+    Q_FOREACH(DeviceLink* dl, m_deviceLinks) {
+        dl->provider()->getPairingHandler()->unpair(this);
+    }
 
     unpairInternal();
 }
@@ -351,23 +353,27 @@ void Device::privateReceivedPackage(const NetworkPackage& np)
                 m_pairStatus = Device::NotPaired;
                 m_pairingTimeout.stop();
                 Q_EMIT pairingFailed(i18n("Canceled by other peer"));
+            } else if (m_pairStatus == Device::Paired) {
+                // If other request's pairing, and we have pair status Paired, send accept pairing
+                Q_FOREACH(DeviceLink* dl, m_deviceLinks) {
+                       dl->provider()->getPairingHandler()->acceptPairing(this);
+                }
             }
             return;
         }
 
         if (wantsPair) {
 
-            //Retrieve their public key
-            const QString& key = np.get<QString>("publicKey");
-            m_publicKey = QCA::RSAPublicKey::fromPEM(key);
-            if (m_publicKey.isNull()) {
-                qCDebug(KDECONNECT_CORE) << "ERROR decoding key";
-                if (m_pairStatus == Device::Requested) {
-                    m_pairStatus = Device::NotPaired;
-                    m_pairingTimeout.stop();
+            Q_FOREACH(DeviceLink* dl, m_deviceLinks) {
+                bool success = dl->provider()->getPairingHandler()->packageReceived(this, np);
+                if (!success) {
+                    if (m_pairStatus == Device::Requested) {
+                        m_pairStatus = Device::NotPaired;
+                        m_pairingTimeout.stop();
+                    }
+                    Q_EMIT pairingFailed(i18n("Received incorrect key"));
+                    return;
                 }
-                Q_EMIT pairingFailed(i18n("Received incorrect key"));
-                return;
             }
 
             if (m_pairStatus == Device::Requested)  { //We started pairing
@@ -427,9 +433,9 @@ void Device::rejectPairing()
 
     m_pairStatus = Device::NotPaired;
 
-    NetworkPackage np(PACKAGE_TYPE_PAIR);
-    np.set("pair", false);
-    sendPackage(np);
+    Q_FOREACH(DeviceLink* link, m_deviceLinks) {
+        link->provider()->getPairingHandler()->rejectPairing(this);
+    }
 
     Q_EMIT pairingFailed(i18n("Canceled by the user"));
 
@@ -441,7 +447,10 @@ void Device::acceptPairing()
 
     qCDebug(KDECONNECT_CORE) << "Accepted pairing";
 
-    bool success = sendOwnPublicKey();
+    bool success;
+    Q_FOREACH(DeviceLink* link, m_deviceLinks) {
+        success = link->provider()->getPairingHandler()->acceptPairing(this);
+    }
 
     if (!success) {
         m_pairStatus = Device::NotPaired;
diff --git a/core/device.h b/core/device.h
index 6e5c180..09ccfce 100644
--- a/core/device.h
+++ b/core/device.h
@@ -84,7 +84,9 @@ public:
     QString id() const { return m_deviceId; }
     QString name() const { return m_deviceName; }
     QString dbusPath() const { return "/modules/kdeconnect/devices/"+id(); }
-    QString type() const { return type2str(m_deviceType); };
+    QString type() const { return type2str(m_deviceType); }
+    QCA::PublicKey publicKey() const { return m_publicKey; }
+    QSslCertificate certificate() const { return m_certificate; }
     QString iconName() const;
     QString statusIconName() const;
 
@@ -92,6 +94,9 @@ public:
     void addLink(const NetworkPackage& identityPackage, DeviceLink*);
     void removeLink(DeviceLink*);
 
+    // Setter for public key after pairing, since it is handled by pairinghandler now
+    void setPublicKey(QCA::PublicKey publicKey) { m_publicKey = publicKey; }
+
     Q_SCRIPTABLE bool isPaired() const { return m_pairStatus==Device::Paired; }
     Q_SCRIPTABLE bool pairRequested() const { return m_pairStatus==Device::Requested; }
 
diff --git a/core/networkpackage.cpp b/core/networkpackage.cpp
index 53b6355..6238122 100644
--- a/core/networkpackage.cpp
+++ b/core/networkpackage.cpp
@@ -47,6 +47,14 @@ NetworkPackage::NetworkPackage(const QString& type)
     mPayloadSize = 0;
 }
 
+NetworkPackage::NetworkPackage(const NetworkPackage &np) {
+    mId = np.id();
+    mType = np.type();
+    mBody = np.body();
+    mPayload = np.payload();
+    mPayloadSize = np.payloadSize();
+}
+
 void NetworkPackage::createIdentityPackage(NetworkPackage* np)
 {
     KdeConnectConfig* config = KdeConnectConfig::instance();
diff --git a/core/networkpackage.h b/core/networkpackage.h
index 6a0bf9c..84e1d85 100644
--- a/core/networkpackage.h
+++ b/core/networkpackage.h
@@ -53,6 +53,7 @@ public:
     const static int ProtocolVersion;
 
     NetworkPackage(const QString& type);
+    NetworkPackage(const NetworkPackage& np);
 
     static void createIdentityPackage(NetworkPackage*);
 
diff --git a/plugins/sftp/kdeconnect_sftp.json b/plugins/sftp/kdeconnect_sftp.json
index 08a89fb..7ac24ff 100644
--- a/plugins/sftp/kdeconnect_sftp.json
+++ b/plugins/sftp/kdeconnect_sftp.json
@@ -59,7 +59,7 @@
     }, 
     "X-KdeConnect-OutgoingPackageType": [
         "kdeconnect.sftp"
-    ], 
+    ],
     "X-KdeConnect-SupportedPackageType": [
         "kdeconnect.sftp"
     ]

-- 
kdeconnect packaging



More information about the pkg-kde-commits mailing list