VPN connection routine fixed

client/core/ipcclient.cpp

@@ -63,7 +63,7 @@ bool IpcClient::init(IpcClient *instance)
     return Instance()->m_ipcClient->isReplicaValid();
 }
 
-QSharedPointer<IpcProcessInterfaceReplica> IpcClient::CreatePrivilegedProcess()
+QSharedPointer<PrivilegedProcess> IpcClient::CreatePrivilegedProcess()
 {
 #ifndef Q_OS_IOS
     if (! Instance()->m_ipcClient || ! Instance()->m_ipcClient->isReplicaValid()) {
@@ -84,17 +84,19 @@ QSharedPointer<IpcProcessInterfaceReplica> IpcClient::CreatePrivilegedProcess()
     connect(pd->localSocket.data(), &QLocalSocket::connected, pd->replicaNode.data(), [pd]() {
         pd->replicaNode->addClientSideConnection(pd->localSocket.data());
 
-        pd->ipcProcess.reset(pd->replicaNode->acquire<IpcProcessInterfaceReplica>());
+        IpcProcessInterfaceReplica *repl = pd->replicaNode->acquire<IpcProcessInterfaceReplica>();
+        PrivilegedProcess *priv = static_cast<PrivilegedProcess *>(repl);
+        pd->ipcProcess.reset(priv);
         if (!pd->ipcProcess) {
-            qWarning() << "Acquire IpcProcessInterfaceReplica failed";
+            qWarning() << "Acquire PrivilegedProcess failed";
         }
         else {
             pd->ipcProcess->waitForSource(1000);
             if (!pd->ipcProcess->isReplicaValid()) {
-                qWarning() << "IpcProcessInterfaceReplica replica is not connected!";
+                qWarning() << "PrivilegedProcess replica is not connected!";
             }
 
-            QObject::connect(pd->ipcProcess.data(), &IpcProcessInterfaceReplica::destroyed, pd->ipcProcess.data(), [pd](){
+            QObject::connect(pd->ipcProcess.data(), &PrivilegedProcess::destroyed, pd->ipcProcess.data(), [pd](){
                 pd->replicaNode->deleteLater();
             });
         }
@@ -103,10 +105,10 @@ QSharedPointer<IpcProcessInterfaceReplica> IpcClient::CreatePrivilegedProcess()
     pd->localSocket->connectToServer(amnezia::getIpcProcessUrl(pid));
     pd->localSocket->waitForConnected();
 
-    auto proccessReplica = QSharedPointer<IpcProcessInterfaceReplica>(pd->ipcProcess);
+    auto proccessReplica = QSharedPointer<PrivilegedProcess>(pd->ipcProcess);
     return proccessReplica;
 #else
-    return QSharedPointer<IpcProcessInterfaceReplica>();
+    return QSharedPointer<PrivilegedProcess>();
 #endif
 }
 

client/core/ipcclient.h

@@ -7,13 +7,7 @@
 #include "ipc.h"
 #include "rep_ipc_interface_replica.h"
 
-#ifndef Q_OS_IOS
-#include "rep_ipc_process_interface_replica.h"
-#else
-class IpcProcessInterfaceReplica {
-
-};
-#endif
+#include "privileged_process.h"
 
 class IpcClient : public QObject
 {
@@ -24,7 +18,7 @@ public:
    static IpcClient *Instance();
    static bool init(IpcClient *instance);
    static QSharedPointer<IpcInterfaceReplica> Interface();
-   static QSharedPointer<IpcProcessInterfaceReplica> CreatePrivilegedProcess();
+   static QSharedPointer<PrivilegedProcess> CreatePrivilegedProcess();
 
    bool isSocketConnected() const;
 
@@ -40,10 +34,10 @@ private:
     struct ProcessDescriptor {
         ProcessDescriptor () {
             replicaNode = QSharedPointer<QRemoteObjectNode>(new QRemoteObjectNode());
-            ipcProcess = QSharedPointer<IpcProcessInterfaceReplica>();
+            ipcProcess = QSharedPointer<PrivilegedProcess>();
             localSocket = QSharedPointer<QLocalSocket>();
         }
-        QSharedPointer<IpcProcessInterfaceReplica> ipcProcess;
+        QSharedPointer<PrivilegedProcess> ipcProcess;
         QSharedPointer<QRemoteObjectNode> replicaNode;
         QSharedPointer<QLocalSocket> localSocket;
     };

client/core/privileged_process.cpp

@@ -0,0 +1,27 @@
+#include "privileged_process.h"
+
+PrivilegedProcess::PrivilegedProcess() :
+    IpcProcessInterfaceReplica()
+{
+}
+
+PrivilegedProcess::~PrivilegedProcess()
+{
+    qDebug() << "PrivilegedProcess::~PrivilegedProcess()";
+}
+
+void PrivilegedProcess::waitForFinished(int msecs)
+{
+    QSharedPointer<QEventLoop> loop(new QEventLoop);
+    connect(this, &PrivilegedProcess::finished, this, [this, loop](int exitCode, QProcess::ExitStatus exitStatus) mutable{
+        loop->quit();
+        loop.clear();
+    });
+
+    QTimer::singleShot(msecs, this, [this, loop]() mutable {
+        loop->quit();
+        loop.clear();
+    });
+
+    loop->exec();
+}

client/core/privileged_process.h

@@ -0,0 +1,30 @@
+#ifndef PRIVILEGED_PROCESS_H
+#define PRIVILEGED_PROCESS_H
+
+#include <QObject>
+
+#ifndef Q_OS_IOS
+#include "rep_ipc_process_interface_replica.h"
+// This class is dangerous - instance of this class casted from base class,
+// so it support only functions
+// Do not add any members into it
+//
+class PrivilegedProcess : public IpcProcessInterfaceReplica
+{
+    Q_OBJECT
+public:
+    PrivilegedProcess();
+    ~PrivilegedProcess() override;
+
+    void waitForFinished(int msecs);
+
+};
+
+#endif // PRIVILEGED_PROCESS_H
+
+#else // defined Q_OS_IOS
+class IpcProcessInterfaceReplica {};
+class PrivilegedProcess {};
+#endif
+
+