SingeApplication lib

main.cpp

@@ -8,8 +8,11 @@
 #include <QtWidgets>
 #include <QQuickWindow>
 #include <QQuickStyle>
+#include <singleapplication.h>
+
 #include "screenshot.h"
 
+
 void handleExitSignal(int sig) {
   printf("Exiting due to signal %d\n", sig);
   QCoreApplication::quit();
@@ -41,7 +44,7 @@ int main(int argc, char *argv[])
 
     QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
 
-    QApplication application(argc, argv);
+    SingleApplication application(argc, argv);
     application.setApplicationName("Yubico Authenticator");
     application.setApplicationVersion(APP_VERSION);
     application.setOrganizationName("Yubico");
@@ -136,6 +139,12 @@ int main(int argc, char *argv[])
     // Set icon in the window, doesn't effect desktop icons.
     qmlWindow->setIcon(QIcon(path_prefix + "/images/windowicon.png"));
 
+    // Starting a second instance application should raise the qmlWindow. Replicated steps as above
+    root->connect(&application, &SingleApplication::instanceStarted, qmlWindow, &QQuickWindow::hide);
+    root->connect(&application, &SingleApplication::instanceStarted, qmlWindow, &QQuickWindow::show);
+    root->connect(&application, &SingleApplication::instanceStarted, qmlWindow, &QQuickWindow::raise);
+    root->connect(&application, &SingleApplication::instanceStarted, qmlWindow, &QQuickWindow::requestActivate);
+
     const int status = application.exec();
     return status;
 }

singleapplication/CHANGELOG.md

@@ -0,0 +1,162 @@
+Changelog
+=========
+
+__3.0.10__
+----------
+
+* Removed C style casts and eliminated all clang warnings. Fixed `instanceId`
+  reading from only one byte in the message deserialization. Cleaned up
+  serialization code using `QDataStream`. Changed connection type to use
+  `quint8 enum` rather than `char`.
+* Renamed `SingleAppConnectionType` to `ConnectionType`. Added initialization
+  values to all `ConnectionType` enum cases.
+
+    _Jedidiah Buck McCready_
+
+__3.0.9__
+---------
+
+*   Added SingleApplicationPrivate::primaryPid() as a solution to allow
+    bringing the primary window of an application to the foreground on
+    Windows.
+
+    _Eelco van Dam from Peacs BV_
+
+__3.0.8__
+---------
+
+*   Bug fix - changed QApplication::instance() to QCoreApplication::instance()
+
+    _Evgeniy Bazhenov_
+
+__3.0.7a__
+----------
+
+*   Fixed compilation error with Mingw32 in MXE thanks to Vitaly Tonkacheyev.
+*   Removed QMutex used for thread safe behaviour. The implementation now uses
+    QCoreApplication::instance() to get an instance to SingleApplication for
+    memory deallocation.
+
+__3.0.6a__
+----------
+
+*   Reverted GetUserName API usage on Windows. Fixed bug with missing library.
+*   Fixed bug in the Calculator example, preventing it's window to be raised
+    on Windows.
+
+    Special thanks to Charles Gunawan.
+
+__3.0.5a__
+----------
+
+*   Fixed a memory leak in the SingleApplicationPrivate destructor.
+
+    _Sergei Moiseev_
+
+__3.0.4a__
+----------
+
+*   Fixed shadow and uninitialised variable warnings.
+
+    _Paul Walmsley_
+
+__3.0.3a__
+----------
+
+*   Removed Microsoft Windows specific code for getting username due to
+    multiple problems and compiler differences on Windows platforms. On
+    Windows the shared memory block in User mode now includes the user's
+    home path (which contains the user's username).
+
+*   Explicitly getting absolute path of the user's home directory as on Unix
+    a relative path (`~`) may be returned.
+
+__3.0.2a__
+----------
+
+*   Fixed bug on Windows when username containing wide characters causes the
+    library to crash.
+
+    _Le Liu_
+
+__3.0.1a__
+----------
+
+*   Allows the application path and version to be excluded from the server name
+    hash. The following flags were added for this purpose:
+      * `SingleApplication::Mode::ExcludeAppVersion`
+      * `SingleApplication::Mode::ExcludeAppPath`
+*   Allow a non elevated process to connect to a local server created by an
+    elevated process run by the same user on Windows
+*   Fixes a problem with upper case letters in paths on Windows
+
+    _Le Liu_
+
+__v3.0a__
+---------
+
+*   Depricated secondary instances count.
+*   Added a sendMessage() method to send a message to the primary instance.
+*   Added a receivedMessage() signal, emitted when a message is received from a
+    secondary instance.
+*   The SingleApplication constructor's third parameter is now a bool
+    specifying if the current instance should be allowed to run as a secondary
+    instance if there is already a primary instance.
+*   The SingleApplication constructor accept a fourth parameter specifying if
+    the SingleApplication block should be User-wide or System-wide.
+*   SingleApplication no longer relies on `applicationName` and
+    `organizationName` to be set. It instead concatenates all of the following
+    data and computes a `SHA256` hash which is used as the key of the
+    `QSharedMemory` block and the `QLocalServer`. Since at least
+    `applicationFilePath` is always present there is no need to explicitly set
+    any of the following prior to initialising `SingleApplication`.
+      * `QCoreApplication::applicationName`
+      * `QCoreApplication::applicationVersion`
+      * `QCoreApplication::applicationFilePath`
+      * `QCoreApplication::organizationName`
+      * `QCoreApplication::organizationDomain`
+      * User name or home directory path if in User mode
+*   The primary instance is no longer notified when a secondary instance had
+    been started by default. A `Mode` flag for this feature exists.
+*   Added `instanceNumber()` which represents a unique identifier for each
+    secondary instance started. When called from the primary instance will
+    return `0`.
+
+__v2.4__
+--------
+
+*   Stability improvements
+*   Support for secondary instances.
+*   The library now recovers safely after the primary process has crashed
+and the shared memory had not been deleted.
+
+__v2.3__
+--------
+
+*   Improved pimpl design and inheritance safety.
+
+    _Vladislav Pyatnichenko_
+
+__v2.2__
+--------
+
+*   The `QAPPLICATION_CLASS` macro can now be defined in the file including the
+Single Application header or with a `DEFINES+=` statement in the project file.
+
+__v2.1__
+--------
+
+*   A race condition can no longer occur when starting two processes nearly
+    simultaneously.
+
+    Fix issue [#3](https://github.com/itay-grudev/SingleApplication/issues/3)
+
+__v2.0__
+--------
+
+*   SingleApplication is now being passed a reference to `argc` instead of a
+    copy.
+
+    Fix issue [#1](https://github.com/itay-grudev/SingleApplication/issues/1)
+
+*   Improved documentation.

singleapplication/LICENSE

@@ -0,0 +1,24 @@
+The MIT License (MIT)
+
+Copyright (c) Itay Grudev 2015 - 2016
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Note: Some of the examples include code not distributed under the terms of the
+MIT License.

singleapplication/singleapplication.cpp

@@ -0,0 +1,468 @@
+// The MIT License (MIT)
+//
+// Copyright (c) Itay Grudev 2015 - 2016
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#include <cstdlib>
+
+#include <QtCore/QDir>
+#include <QtCore/QProcess>
+#include <QtCore/QByteArray>
+#include <QtCore/QSemaphore>
+#include <QtCore/QSharedMemory>
+#include <QtCore/QStandardPaths>
+#include <QtCore/QCryptographicHash>
+#include <QtCore/QDataStream>
+#include <QtNetwork/QLocalServer>
+#include <QtNetwork/QLocalSocket>
+
+#ifdef Q_OS_UNIX
+    #include <signal.h>
+    #include <unistd.h>
+#endif
+
+#ifdef Q_OS_WIN
+    #include <windows.h>
+    #include <lmcons.h>
+#endif
+
+#include "singleapplication.h"
+#include "singleapplication_p.h"
+
+
+SingleApplicationPrivate::SingleApplicationPrivate( SingleApplication *q_ptr ) : q_ptr( q_ptr ) {
+    server = nullptr;
+    socket = nullptr;
+}
+
+SingleApplicationPrivate::~SingleApplicationPrivate()
+{
+    if( socket != nullptr ) {
+        socket->close();
+        delete socket;
+    }
+
+    memory->lock();
+    InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
+    if( server != nullptr ) {
+        server->close();
+        delete server;
+        inst->primary = false;
+        inst->primaryPid = -1;
+    }
+    memory->unlock();
+
+    delete memory;
+}
+
+void SingleApplicationPrivate::genBlockServerName( int timeout )
+{
+    QCryptographicHash appData( QCryptographicHash::Sha256 );
+    appData.addData( "SingleApplication", 17 );
+    appData.addData( SingleApplication::app_t::applicationName().toUtf8() );
+    appData.addData( SingleApplication::app_t::organizationName().toUtf8() );
+    appData.addData( SingleApplication::app_t::organizationDomain().toUtf8() );
+
+    if( ! (options & SingleApplication::Mode::ExcludeAppVersion) ) {
+        appData.addData( SingleApplication::app_t::applicationVersion().toUtf8() );
+    }
+
+    if( ! (options & SingleApplication::Mode::ExcludeAppPath) ) {
+#ifdef Q_OS_WIN
+        appData.addData( SingleApplication::app_t::applicationFilePath().toLower().toUtf8() );
+#else
+        appData.addData( SingleApplication::app_t::applicationFilePath().toUtf8() );
+#endif
+    }
+
+    // User level block requires a user specific data in the hash
+    if( options & SingleApplication::Mode::User ) {
+#ifdef Q_OS_WIN
+        Q_UNUSED(timeout);
+        wchar_t username [ UNLEN + 1 ];
+        // Specifies size of the buffer on input
+        DWORD usernameLength = UNLEN + 1;
+        if( GetUserNameW( username, &usernameLength ) ) {
+            appData.addData( QString::fromWCharArray(username).toUtf8() );
+        } else {
+            appData.addData( QStandardPaths::standardLocations( QStandardPaths::HomeLocation ).join("").toUtf8() );
+        }
+#endif
+#ifdef Q_OS_UNIX
+        QProcess process;
+        process.start( "whoami" );
+        if( process.waitForFinished( timeout ) &&
+            process.exitCode() == QProcess::NormalExit) {
+            appData.addData( process.readLine() );
+        } else {
+            appData.addData(
+                QDir(
+                    QStandardPaths::standardLocations( QStandardPaths::HomeLocation ).first()
+                ).absolutePath().toUtf8()
+            );
+        }
+#endif
+    }
+
+    // Replace the backslash in RFC 2045 Base64 [a-zA-Z0-9+/=] to comply with
+    // server naming requirements.
+    blockServerName = appData.result().toBase64().replace("/", "_");
+}
+
+void SingleApplicationPrivate::startPrimary( bool resetMemory )
+{
+    Q_Q(SingleApplication);
+
+#ifdef Q_OS_UNIX
+    // Handle any further termination signals to ensure the
+    // QSharedMemory block is deleted even if the process crashes
+    crashHandler();
+#endif
+    // Successful creation means that no main process exists
+    // So we start a QLocalServer to listen for connections
+    QLocalServer::removeServer( blockServerName );
+    server = new QLocalServer();
+
+    // Restrict access to the socket according to the
+    // SingleApplication::Mode::User flag on User level or no restrictions
+    if( options & SingleApplication::Mode::User ) {
+      server->setSocketOptions( QLocalServer::UserAccessOption );
+    } else {
+      server->setSocketOptions( QLocalServer::WorldAccessOption );
+    }
+
+    server->listen( blockServerName );
+    QObject::connect(
+        server,
+        &QLocalServer::newConnection,
+        this,
+        &SingleApplicationPrivate::slotConnectionEstablished
+    );
+
+    // Reset the number of connections
+    memory->lock();
+    InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
+
+    if( resetMemory ) {
+        inst->secondary = 0;
+    }
+
+    inst->primary = true;
+    inst->primaryPid = q->applicationPid();
+
+    memory->unlock();
+
+    instanceNumber = 0;
+}
+
+void SingleApplicationPrivate::startSecondary()
+{
+#ifdef Q_OS_UNIX
+    // Handle any further termination signals to ensure the
+    // QSharedMemory block is deleted even if the process crashes
+    crashHandler();
+#endif
+}
+
+void SingleApplicationPrivate::connectToPrimary( int msecs, ConnectionType connectionType )
+{
+    // Connect to the Local Server of the Primary Instance if not already
+    // connected.
+    if( socket == nullptr ) {
+        socket = new QLocalSocket();
+    }
+
+    // If already connected - we are done;
+    if( socket->state() == QLocalSocket::ConnectedState )
+        return;
+
+    // If not connect
+    if( socket->state() == QLocalSocket::UnconnectedState ||
+        socket->state() == QLocalSocket::ClosingState ) {
+        socket->connectToServer( blockServerName );
+    }
+
+    // Wait for being connected
+    if( socket->state() == QLocalSocket::ConnectingState ) {
+        socket->waitForConnected( msecs );
+    }
+
+    // Initialisation message according to the SingleApplication protocol
+    if( socket->state() == QLocalSocket::ConnectedState ) {
+        // Notify the parent that a new instance had been started;
+        QByteArray initMsg;
+        QDataStream writeStream(&initMsg, QIODevice::WriteOnly);
+        writeStream.setVersion(QDataStream::Qt_5_5);
+        writeStream << blockServerName.toLatin1();
+        writeStream << static_cast<quint8>(connectionType);
+        writeStream << instanceNumber;
+        quint16 checksum = qChecksum(initMsg.constData(), static_cast<quint32>(initMsg.length()));
+        writeStream << checksum;
+
+        socket->write( initMsg );
+        socket->flush();
+        socket->waitForBytesWritten( msecs );
+    }
+}
+
+qint64 SingleApplicationPrivate::primaryPid()
+{
+    qint64 pid;
+
+    memory->lock();
+    InstancesInfo* inst = static_cast<InstancesInfo*>(memory->data());
+    pid = inst->primaryPid;
+    memory->unlock();
+
+    return pid;
+}
+
+#ifdef Q_OS_UNIX
+    void SingleApplicationPrivate::crashHandler()
+    {
+        // Handle any further termination signals to ensure the
+        // QSharedMemory block is deleted even if the process crashes
+        signal( SIGHUP,  SingleApplicationPrivate::terminate ); // 1
+        signal( SIGINT,  SingleApplicationPrivate::terminate ); // 2
+        signal( SIGQUIT, SingleApplicationPrivate::terminate ); // 3
+        signal( SIGILL,  SingleApplicationPrivate::terminate ); // 4
+        signal( SIGABRT, SingleApplicationPrivate::terminate ); // 6
+        signal( SIGFPE,  SingleApplicationPrivate::terminate ); // 8
+        signal( SIGBUS,  SingleApplicationPrivate::terminate ); // 10
+        signal( SIGSEGV, SingleApplicationPrivate::terminate ); // 11
+        signal( SIGSYS,  SingleApplicationPrivate::terminate ); // 12
+        signal( SIGPIPE, SingleApplicationPrivate::terminate ); // 13
+        signal( SIGALRM, SingleApplicationPrivate::terminate ); // 14
+        signal( SIGTERM, SingleApplicationPrivate::terminate ); // 15
+        signal( SIGXCPU, SingleApplicationPrivate::terminate ); // 24
+        signal( SIGXFSZ, SingleApplicationPrivate::terminate ); // 25
+    }
+
+    void SingleApplicationPrivate::terminate( int signum )
+    {
+        delete ((SingleApplication*)QCoreApplication::instance())->d_ptr;
+        ::exit( 128 + signum );
+    }
+#endif
+
+/**
+ * @brief Executed when a connection has been made to the LocalServer
+ */
+void SingleApplicationPrivate::slotConnectionEstablished()
+{
+    Q_Q(SingleApplication);
+
+    QLocalSocket *nextConnSocket = server->nextPendingConnection();
+
+    quint32 instanceId = 0;
+    ConnectionType connectionType = InvalidConnection;
+    if( nextConnSocket->waitForReadyRead( 100 ) ) {
+        // read all data from message in same order/format as written
+        QByteArray msgBytes = nextConnSocket->read(nextConnSocket->bytesAvailable() - static_cast<qint64>(sizeof(quint16)));
+        QByteArray checksumBytes = nextConnSocket->read(sizeof(quint16));
+        QDataStream readStream(msgBytes);
+        readStream.setVersion(QDataStream::Qt_5_5);
+
+        // server name
+        QByteArray latin1Name;
+        readStream >> latin1Name;
+        // connectioon type
+        quint8 connType = InvalidConnection;
+        readStream >> connType;
+        connectionType = static_cast<ConnectionType>(connType);
+        // instance id
+        readStream >> instanceId;
+        // checksum
+        quint16 msgChecksum = 0;
+        QDataStream checksumStream(checksumBytes);
+        checksumStream.setVersion(QDataStream::Qt_5_5);
+        checksumStream >> msgChecksum;
+
+        const quint16 actualChecksum = qChecksum(msgBytes.constData(), static_cast<quint32>(msgBytes.length()));
+
+        if (readStream.status() != QDataStream::Ok || QLatin1String(latin1Name) != blockServerName || msgChecksum != actualChecksum) {
+          connectionType = InvalidConnection;
+        }
+    }
+
+    if( connectionType == InvalidConnection ) {
+        nextConnSocket->close();
+        delete nextConnSocket;
+        return;
+    }
+
+    QObject::connect(
+        nextConnSocket,
+        &QLocalSocket::aboutToClose,
+        this,
+        [nextConnSocket, instanceId, this]() {
+            Q_EMIT this->slotClientConnectionClosed( nextConnSocket, instanceId );
+        }
+    );
+
+    QObject::connect(
+        nextConnSocket,
+        &QLocalSocket::readyRead,
+        this,
+        [nextConnSocket, instanceId, this]() {
+            Q_EMIT this->slotDataAvailable( nextConnSocket, instanceId );
+        }
+    );
+
+    if( connectionType == NewInstance || (
+            connectionType == SecondaryInstance &&
+            options & SingleApplication::Mode::SecondaryNotification
+        )
+    ) {
+        Q_EMIT q->instanceStarted();
+    }
+
+    if( nextConnSocket->bytesAvailable() > 0 ) {
+        Q_EMIT this->slotDataAvailable( nextConnSocket, instanceId );
+    }
+}
+
+void SingleApplicationPrivate::slotDataAvailable( QLocalSocket *dataSocket, quint32 instanceId )
+{
+    Q_Q(SingleApplication);
+    Q_EMIT q->receivedMessage( instanceId, dataSocket->readAll() );
+}
+
+void SingleApplicationPrivate::slotClientConnectionClosed( QLocalSocket *closedSocket, quint32 instanceId )
+{
+    if( closedSocket->bytesAvailable() > 0 )
+        Q_EMIT slotDataAvailable( closedSocket, instanceId  );
+    closedSocket->deleteLater();
+}
+
+/**
+ * @brief Constructor. Checks and fires up LocalServer or closes the program
+ * if another instance already exists
+ * @param argc
+ * @param argv
+ * @param {bool} allowSecondaryInstances
+ */
+SingleApplication::SingleApplication( int &argc, char *argv[], bool allowSecondary, Options options, int timeout )
+    : app_t( argc, argv ), d_ptr( new SingleApplicationPrivate( this ) )
+{
+    Q_D(SingleApplication);
+
+    // Store the current mode of the program
+    d->options = options;
+
+    // Generating an application ID used for identifying the shared memory
+    // block and QLocalServer
+    d->genBlockServerName( timeout );
+
+    // Guarantee thread safe behaviour with a shared memory block. Also by
+    // explicitly attaching it and then deleting it we make sure that the
+    // memory is deleted even if the process had crashed on Unix.
+#ifdef Q_OS_UNIX
+    d->memory = new QSharedMemory( d->blockServerName );
+    d->memory->attach();
+    delete d->memory;
+#endif
+    d->memory = new QSharedMemory( d->blockServerName );
+
+    // Create a shared memory block
+    if( d->memory->create( sizeof( InstancesInfo ) ) ) {
+        d->startPrimary( true );
+        return;
+    } else {
+        // Attempt to attach to the memory segment
+        if( d->memory->attach() ) {
+            d->memory->lock();
+            InstancesInfo* inst = static_cast<InstancesInfo*>(d->memory->data());
+
+            if( ! inst->primary ) {
+                d->startPrimary( false );
+                d->memory->unlock();
+                return;
+            }
+
+            // Check if another instance can be started
+            if( allowSecondary ) {
+                inst->secondary += 1;
+                d->instanceNumber = inst->secondary;
+                d->startSecondary();
+                if( d->options & Mode::SecondaryNotification ) {
+                    d->connectToPrimary( timeout, SingleApplicationPrivate::SecondaryInstance );
+                }
+                d->memory->unlock();
+                return;
+            }
+
+            d->memory->unlock();
+        }
+    }
+
+    d->connectToPrimary( timeout, SingleApplicationPrivate::NewInstance );
+    delete d;
+    ::exit( EXIT_SUCCESS );
+}
+
+/**
+ * @brief Destructor
+ */
+SingleApplication::~SingleApplication()
+{
+    Q_D(SingleApplication);
+    delete d;
+}
+
+bool SingleApplication::isPrimary()
+{
+    Q_D(SingleApplication);
+    return d->server != nullptr;
+}
+
+bool SingleApplication::isSecondary()
+{
+    Q_D(SingleApplication);
+    return d->server == nullptr;
+}
+
+quint32 SingleApplication::instanceId()
+{
+    Q_D(SingleApplication);
+    return d->instanceNumber;
+}
+
+qint64 SingleApplication::primaryPid()
+{
+    Q_D(SingleApplication);
+    return d->primaryPid();
+}
+
+bool SingleApplication::sendMessage( QByteArray message, int timeout )
+{
+    Q_D(SingleApplication);
+
+    // Nobody to connect to
+    if( isPrimary() ) return false;
+
+    // Make sure the socket is connected
+    d->connectToPrimary( timeout,  SingleApplicationPrivate::Reconnect );
+
+    d->socket->write( message );
+    bool dataWritten = d->socket->flush();
+    d->socket->waitForBytesWritten( timeout );
+    return dataWritten;
+}

singleapplication/singleapplication.h

@@ -0,0 +1,135 @@
+// The MIT License (MIT)
+//
+// Copyright (c) Itay Grudev 2015 - 2016
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+#ifndef SINGLE_APPLICATION_H
+#define SINGLE_APPLICATION_H
+
+#include <QtCore/QtGlobal>
+#include <QtNetwork/QLocalSocket>
+
+#ifndef QAPPLICATION_CLASS
+  #define QAPPLICATION_CLASS QCoreApplication
+#endif
+
+#include QT_STRINGIFY(QAPPLICATION_CLASS)
+
+class SingleApplicationPrivate;
+
+/**
+ * @brief The SingleApplication class handles multipe instances of the same
+ * Application
+ * @see QCoreApplication
+ */
+class SingleApplication : public QAPPLICATION_CLASS
+{
+    Q_OBJECT
+
+    typedef QAPPLICATION_CLASS app_t;
+
+public:
+    /**
+     * @brief Mode of operation of SingleApplication.
+     * Whether the block should be user-wide or system-wide and whether the
+     * primary instance should be notified when a secondary instance had been
+     * started.
+     * @note Operating system can restrict the shared memory blocks to the same
+     * user, in which case the User/System modes will have no effect and the
+     * block will be user wide.
+     * @enum
+     */
+    enum Mode {
+        User                    = 1 << 0,
+        System                  = 1 << 1,
+        SecondaryNotification   = 1 << 2,
+        ExcludeAppVersion       = 1 << 3,
+        ExcludeAppPath          = 1 << 4
+    };
+    Q_DECLARE_FLAGS(Options, Mode)
+
+    /**
+     * @brief Intitializes a SingleApplication instance with argc command line
+     * arguments in argv
+     * @arg {int &} argc - Number of arguments in argv
+     * @arg {const char *[]} argv - Supplied command line arguments
+     * @arg {bool} allowSecondary - Whether to start the instance as secondary
+     * if there is already a primary instance.
+     * @arg {Mode} mode - Whether for the SingleApplication block to be applied
+     * User wide or System wide.
+     * @arg {int} timeout - Timeout to wait in miliseconds.
+     * @note argc and argv may be changed as Qt removes arguments that it
+     * recognizes
+     * @note Mode::SecondaryNotification only works if set on both the primary
+     * instance and the secondary instance.
+     * @note The timeout is just a hint for the maximum time of blocking
+     * operations. It does not guarantee that the SingleApplication
+     * initialisation will be completed in given time, though is a good hint.
+     * Usually 4*timeout would be the worst case (fail) scenario.
+     * @see See the corresponding QAPPLICATION_CLASS constructor for reference
+     */
+    explicit SingleApplication( int &argc, char *argv[], bool allowSecondary = false, Options options = Mode::User, int timeout = 100 );
+    ~SingleApplication();
+
+    /**
+     * @brief Returns if the instance is the primary instance
+     * @returns {bool}
+     */
+    bool isPrimary();
+
+    /**
+     * @brief Returns if the instance is a secondary instance
+     * @returns {bool}
+     */
+    bool isSecondary();
+
+    /**
+     * @brief Returns a unique identifier for the current instance
+     * @returns {qint32}
+     */
+    quint32 instanceId();
+
+    /**
+     * @brief Returns the process ID (PID) of the primary instance
+     * @returns {qint64}
+     */
+    qint64 primaryPid();
+
+    /**
+     * @brief Sends a message to the primary instance. Returns true on success.
+     * @param {int} timeout - Timeout for connecting
+     * @returns {bool}
+     * @note sendMessage() will return false if invoked from the primary
+     * instance.
+     */
+    bool sendMessage( QByteArray message, int timeout = 100 );
+
+Q_SIGNALS:
+    void instanceStarted();
+    void receivedMessage( quint32 instanceId, QByteArray message );
+
+private:
+    SingleApplicationPrivate *d_ptr;
+    Q_DECLARE_PRIVATE(SingleApplication)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(SingleApplication::Options)
+
+#endif // SINGLE_APPLICATION_H

singleapplication/singleapplication.pri

@@ -0,0 +1,18 @@
+QT += core network
+CONFIG += c++11
+
+HEADERS += $$PWD/singleapplication.h \
+    $$PWD/singleapplication_p.h
+SOURCES += $$PWD/singleapplication.cpp
+
+INCLUDEPATH += $$PWD
+
+win32 {
+    msvc:LIBS += Advapi32.lib
+    gcc:LIBS += -lAdvapi32
+}
+
+DISTFILES += \
+    $$PWD/README.md \
+    $$PWD/CHANGELOG.md \
+    $$PWD/Windows.md

singleapplication/singleapplication_p.h

@@ -0,0 +1,85 @@
+// The MIT License (MIT)
+//
+// Copyright (c) Itay Grudev 2015 - 2016
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+//
+//  W A R N I N G !!!
+//  -----------------
+//
+// This file is not part of the SingleApplication API. It is used purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or may even be removed.
+//
+
+#ifndef SINGLEAPPLICATION_P_H
+#define SINGLEAPPLICATION_P_H
+
+#include <QtCore/QSharedMemory>
+#include <QtNetwork/QLocalServer>
+#include <QtNetwork/QLocalSocket>
+#include "singleapplication.h"
+
+struct InstancesInfo {
+    bool primary;
+    quint32 secondary;
+    qint64 primaryPid;
+};
+
+class SingleApplicationPrivate : public QObject {
+Q_OBJECT
+public:
+    enum ConnectionType : quint8 {
+        InvalidConnection = 0,
+        NewInstance = 1,
+        SecondaryInstance = 2,
+        Reconnect = 3
+    };
+    Q_DECLARE_PUBLIC(SingleApplication)
+
+    SingleApplicationPrivate( SingleApplication *q_ptr );
+     ~SingleApplicationPrivate();
+
+    void genBlockServerName( int msecs );
+    void startPrimary( bool resetMemory );
+    void startSecondary();
+    void connectToPrimary(int msecs, ConnectionType connectionType );
+    qint64 primaryPid();
+
+#ifdef Q_OS_UNIX
+    void crashHandler();
+    static void terminate( int signum );
+#endif
+
+    QSharedMemory *memory;
+    SingleApplication *q_ptr;
+    QLocalSocket *socket;
+    QLocalServer *server;
+    quint32 instanceNumber;
+    QString blockServerName;
+    SingleApplication::Options options;
+
+public Q_SLOTS:
+    void slotConnectionEstablished();
+    void slotDataAvailable( QLocalSocket*, quint32 );
+    void slotClientConnectionClosed( QLocalSocket*, quint32 );
+};
+
+#endif // SINGLEAPPLICATION_P_H

yubioath-desktop.pro

@@ -1,6 +1,10 @@
 TEMPLATE = app
 QT += qml quick widgets quickcontrols2
 CONFIG += c++11
+
+include(singleapplication/singleapplication.pri)
+DEFINES += QAPPLICATION_CLASS=QApplication
+
 SOURCES += main.cpp
 HEADERS += screenshot.h