Aditya Kulkarni
5 years ago
13 changed files with 1343 additions and 16 deletions
@ -1,3 +0,0 @@ |
|||
[submodule "singleapplication"] |
|||
path = singleapplication |
|||
url = git@github.com:itay-grudev/SingleApplication.git |
|||
@ -0,0 +1,193 @@ |
|||
Changelog |
|||
========= |
|||
|
|||
__3.0.14__ |
|||
---------- |
|||
|
|||
* Fixed uninitialised variables in the `SingleApplicationPrivate` constructor. |
|||
|
|||
__3.0.13a__ |
|||
---------- |
|||
|
|||
* Process socket events asynchronously |
|||
* Fix undefined variable error on Windows |
|||
|
|||
_Francis Giraldeau_ |
|||
|
|||
__3.0.12a__ |
|||
---------- |
|||
|
|||
* Removed signal handling. |
|||
|
|||
__3.0.11a__ |
|||
---------- |
|||
|
|||
* Fixed bug where the message sent by the second process was not received |
|||
correctly when the message is sent immediately following a connection. |
|||
|
|||
_Francis Giraldeau_ |
|||
|
|||
* Refactored code and implemented shared memory block consistency checks |
|||
via `qChecksum()` (CRC-16). |
|||
* Explicit `qWarning` and `qCritical` when the library is unable to initialise |
|||
correctly. |
|||
|
|||
__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. |
|||
@ -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. |
|||
@ -0,0 +1,265 @@ |
|||
SingleApplication |
|||
================= |
|||
|
|||
This is a replacement of the QtSingleApplication for `Qt5`. |
|||
|
|||
Keeps the Primary Instance of your Application and kills each subsequent |
|||
instances. It can (if enabled) spawn secondary (non-related to the primary) |
|||
instances and can send data to the primary instance from secondary instances. |
|||
|
|||
Usage |
|||
----- |
|||
|
|||
The `SingleApplication` class inherits from whatever `Q[Core|Gui]Application` |
|||
class you specify via the `QAPPLICATION_CLASS` macro (`QCoreApplication` is the |
|||
default). Further usage is similar to the use of the `Q[Core|Gui]Application` |
|||
classes. |
|||
|
|||
The library sets up a `QLocalServer` and a `QSharedMemory` block. The first |
|||
instance of your Application is your Primary Instance. It would check if the |
|||
shared memory block exists and if not it will start a `QLocalServer` and listen |
|||
for connections. Each subsequent instance of your application would check if the |
|||
shared memory block exists and if it does, it will connect to the QLocalServer |
|||
to notify the primary instance that a new instance had been started, after which |
|||
it would terminate with status code `0`. In the Primary Instance |
|||
`SingleApplication` would emit the `instanceStarted()` signal upon detecting |
|||
that a new instance had been started. |
|||
|
|||
The library uses `stdlib` to terminate the program with the `exit()` function. |
|||
|
|||
You can use the library as if you use any other `QCoreApplication` derived |
|||
class: |
|||
|
|||
```cpp |
|||
#include <QApplication> |
|||
#include <SingleApplication.h> |
|||
|
|||
int main( int argc, char* argv[] ) |
|||
{ |
|||
SingleApplication app( argc, argv ); |
|||
|
|||
return app.exec(); |
|||
} |
|||
``` |
|||
|
|||
To include the library files I would recommend that you add it as a git |
|||
submodule to your project and include it's contents with a `.pri` file. Here is |
|||
how: |
|||
|
|||
```bash |
|||
git submodule add git@github.com:itay-grudev/SingleApplication.git singleapplication |
|||
``` |
|||
|
|||
Then include the `singleapplication.pri` file in your `.pro` project file. Also |
|||
don't forget to specify which `QCoreApplication` class your app is using if it |
|||
is not `QCoreApplication`. |
|||
|
|||
```qmake |
|||
include(singleapplication/singleapplication.pri) |
|||
DEFINES += QAPPLICATION_CLASS=QApplication |
|||
``` |
|||
|
|||
The `Instance Started` signal |
|||
------------------------ |
|||
|
|||
The SingleApplication class implements a `instanceStarted()` signal. You can |
|||
bind to that signal to raise your application's window when a new instance had |
|||
been started, for example. |
|||
|
|||
```cpp |
|||
// window is a QWindow instance |
|||
QObject::connect( |
|||
&app, |
|||
&SingleApplication::instanceStarted, |
|||
&window, |
|||
&QWindow::raise |
|||
); |
|||
``` |
|||
|
|||
Using `SingleApplication::instance()` is a neat way to get the |
|||
`SingleApplication` instance for binding to it's signals anywhere in your |
|||
program. |
|||
|
|||
__Note:__ On Windows the ability to bring the application windows to the |
|||
foreground is restricted. See [Windows specific implementations](Windows.md) |
|||
for a workaround and an example implementation. |
|||
|
|||
|
|||
Secondary Instances |
|||
------------------- |
|||
|
|||
If you want to be able to launch additional Secondary Instances (not related to |
|||
your Primary Instance) you have to enable that with the third parameter of the |
|||
`SingleApplication` constructor. The default is `false` meaning no Secondary |
|||
Instances. Here is an example of how you would start a Secondary Instance send |
|||
a message with the command line arguments to the primary instance and then shut |
|||
down. |
|||
|
|||
```cpp |
|||
int main(int argc, char *argv[]) |
|||
{ |
|||
SingleApplication app( argc, argv, true ); |
|||
|
|||
if( app.isSecondary() ) { |
|||
app.sendMessage( app.arguments().join(' ')).toUtf8() ); |
|||
app.exit( 0 ); |
|||
} |
|||
|
|||
return app.exec(); |
|||
} |
|||
``` |
|||
|
|||
*__Note:__ A secondary instance won't cause the emission of the |
|||
`instanceStarted()` signal by default. See `SingleApplication::Mode` for more |
|||
details.* |
|||
|
|||
You can check whether your instance is a primary or secondary with the following |
|||
methods: |
|||
|
|||
```cpp |
|||
app.isPrimary(); |
|||
// or |
|||
app.isSecondary(); |
|||
``` |
|||
|
|||
*__Note:__ If your Primary Instance is terminated a newly launched instance |
|||
will replace the Primary one even if the Secondary flag has been set.* |
|||
|
|||
API |
|||
--- |
|||
|
|||
### Members |
|||
|
|||
```cpp |
|||
SingleApplication::SingleApplication( int &argc, char *argv[], bool allowSecondary = false, Options options = Mode::User, int timeout = 100 ) |
|||
``` |
|||
|
|||
Depending on whether `allowSecondary` is set, this constructor may terminate |
|||
your app if there is already a primary instance running. Additional `Options` |
|||
can be specified to set whether the SingleApplication block should work |
|||
user-wide or system-wide. Additionally the `Mode::SecondaryNotification` may be |
|||
used to notify the primary instance whenever a secondary instance had been |
|||
started (disabled by default). `timeout` specifies the maximum time in |
|||
milliseconds to wait for blocking operations. |
|||
|
|||
*__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 |
|||
and the secondary instance.* |
|||
|
|||
*__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.* |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
bool SingleApplication::sendMessage( QByteArray message, int timeout = 100 ) |
|||
``` |
|||
|
|||
Sends `message` to the Primary Instance. Uses `timeout` as a the maximum timeout |
|||
in milliseconds for blocking functions |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
bool SingleApplication::isPrimary() |
|||
``` |
|||
|
|||
Returns if the instance is the primary instance. |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
bool SingleApplication::isSecondary() |
|||
``` |
|||
Returns if the instance is a secondary instance. |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
quint32 SingleApplication::instanceId() |
|||
``` |
|||
|
|||
Returns a unique identifier for the current instance. |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
qint64 SingleApplication::primaryPid() |
|||
``` |
|||
|
|||
Returns the process ID (PID) of the primary instance. |
|||
|
|||
### Signals |
|||
|
|||
```cpp |
|||
void SingleApplication::instanceStarted() |
|||
``` |
|||
|
|||
Triggered whenever a new instance had been started, except for secondary |
|||
instances if the `Mode::SecondaryNotification` flag is not specified. |
|||
|
|||
--- |
|||
|
|||
```cpp |
|||
void SingleApplication::receivedMessage( quint32 instanceId, QByteArray message ) |
|||
``` |
|||
|
|||
Triggered whenever there is a message received from a secondary instance. |
|||
|
|||
--- |
|||
|
|||
### Flags |
|||
|
|||
```cpp |
|||
enum SingleApplication::Mode |
|||
``` |
|||
|
|||
* `Mode::User` - The SingleApplication block should apply user wide. This adds |
|||
user specific data to the key used for the shared memory and server name. |
|||
This is the default functionality. |
|||
* `Mode::System` – The SingleApplication block applies system-wide. |
|||
* `Mode::SecondaryNotification` – Whether to trigger `instanceStarted()` even |
|||
whenever secondary instances are started. |
|||
* `Mode::ExcludeAppPath` – Excludes the application path from the server name |
|||
(and memory block) hash. |
|||
* `Mode::ExcludeAppVersion` – Excludes the application version from the server |
|||
name (and memory block) hash. |
|||
|
|||
*__Note:__ `Mode::SecondaryNotification` only works if set on both the primary |
|||
and the secondary instance.* |
|||
|
|||
*__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.* |
|||
|
|||
--- |
|||
|
|||
Versioning |
|||
---------- |
|||
|
|||
Each major version introduces either very significant changes or is not |
|||
backwards compatible with the previous version. Minor versions only add |
|||
additional features, bug fixes or performance improvements and are backwards |
|||
compatible with the previous release. See [`CHANGELOG.md`](CHANGELOG.md) for |
|||
more details. |
|||
|
|||
Implementation |
|||
-------------- |
|||
|
|||
The library is implemented with a QSharedMemory block which is thread safe and |
|||
guarantees a race condition will not occur. It also uses a QLocalSocket to |
|||
notify the main process that a new instance had been spawned and thus invoke the |
|||
`instanceStarted()` signal and for messaging the primary instance. |
|||
|
|||
Additionally the library can recover from being forcefully killed on *nix |
|||
systems and will reset the memory block given that there are no other |
|||
instances running. |
|||
|
|||
License |
|||
------- |
|||
This library and it's supporting documentation are released under |
|||
`The MIT License (MIT)` with the exception of the Qt calculator examples which |
|||
is distributed under the BSD license. |
|||
@ -0,0 +1,46 @@ |
|||
Windows Specific Implementations |
|||
================================ |
|||
|
|||
Setting the foreground window |
|||
----------------------------- |
|||
|
|||
In the `instanceStarted()` example in the `README` we demonstrated how an |
|||
application can bring it's primary instance window whenever a second copy |
|||
of the application is started. |
|||
|
|||
On Windows the ability to bring the application windows to the foreground is |
|||
restricted, see [`AllowSetForegroundWindow()`][AllowSetForegroundWindow] for more |
|||
details. |
|||
|
|||
The background process (the primary instance) can bring its windows to the |
|||
foreground if it is allowed by the current foreground process (the secondary |
|||
instance). To bypass this `SingleApplication` must be initialized with the |
|||
`allowSecondary` parameter set to `true` and the `options` parameter must |
|||
include `Mode::SecondaryNotification`, See `SingleApplication::Mode` for more |
|||
details. |
|||
|
|||
Here is an example: |
|||
|
|||
```cpp |
|||
if( app.isSecondary() ) { |
|||
// This API requires LIBS += User32.lib to be added to the project |
|||
AllowSetForegroundWindow( DWORD( app.primaryPid() ) ); |
|||
} |
|||
|
|||
if( app.isPrimary() ) { |
|||
QObject::connect( |
|||
&app, |
|||
&SingleApplication::instanceStarted, |
|||
this, |
|||
&App::instanceStarted |
|||
); |
|||
} |
|||
``` |
|||
|
|||
```cpp |
|||
void App::instanceStarted() { |
|||
QApplication::setActiveWindow( [window/widget to set to the foreground] ); |
|||
} |
|||
``` |
|||
|
|||
[AllowSetForegroundWindow]: https://msdn.microsoft.com/en-us/library/windows/desktop/ms632668.aspx |
|||
@ -0,0 +1,174 @@ |
|||
// The MIT License (MIT)
|
|||
//
|
|||
// Copyright (c) Itay Grudev 2015 - 2018
|
|||
//
|
|||
// 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 <QtCore/QTime> |
|||
#include <QtCore/QThread> |
|||
#include <QtCore/QDateTime> |
|||
#include <QtCore/QByteArray> |
|||
#include <QtCore/QSharedMemory> |
|||
|
|||
#include "singleapplication.h" |
|||
#include "singleapplication_p.h" |
|||
|
|||
/**
|
|||
* @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(); |
|||
|
|||
#ifdef Q_OS_UNIX |
|||
// By explicitly attaching it and then deleting it we make sure that the
|
|||
// memory is deleted even after the process has crashed on Unix.
|
|||
d->memory = new QSharedMemory( d->blockServerName ); |
|||
d->memory->attach(); |
|||
delete d->memory; |
|||
#endif |
|||
// Guarantee thread safe behaviour with a shared memory block.
|
|||
d->memory = new QSharedMemory( d->blockServerName ); |
|||
|
|||
// Create a shared memory block
|
|||
if( d->memory->create( sizeof( InstancesInfo ) ) ) { |
|||
// Initialize the shared memory block
|
|||
d->memory->lock(); |
|||
d->initializeMemoryBlock(); |
|||
d->memory->unlock(); |
|||
} else { |
|||
// Attempt to attach to the memory segment
|
|||
if( ! d->memory->attach() ) { |
|||
qCritical() << "SingleApplication: Unable to attach to shared memory block."; |
|||
qCritical() << d->memory->errorString(); |
|||
delete d; |
|||
::exit( EXIT_FAILURE ); |
|||
} |
|||
} |
|||
|
|||
InstancesInfo* inst = static_cast<InstancesInfo*>( d->memory->data() ); |
|||
QTime time; |
|||
time.start(); |
|||
|
|||
// Make sure the shared memory block is initialised and in consistent state
|
|||
while( true ) { |
|||
d->memory->lock(); |
|||
|
|||
if( d->blockChecksum() == inst->checksum ) break; |
|||
|
|||
if( time.elapsed() > 5000 ) { |
|||
qWarning() << "SingleApplication: Shared memory block has been in an inconsistent state from more than 5s. Assuming primary instance failure."; |
|||
d->initializeMemoryBlock(); |
|||
} |
|||
|
|||
d->memory->unlock(); |
|||
|
|||
// Random sleep here limits the probability of a collision between two racing apps
|
|||
qsrand( QDateTime::currentMSecsSinceEpoch() % std::numeric_limits<uint>::max() ); |
|||
QThread::sleep( 8 + static_cast <unsigned long>( static_cast <float>( qrand() ) / RAND_MAX * 10 ) ); |
|||
} |
|||
|
|||
if( inst->primary == false) { |
|||
d->startPrimary(); |
|||
d->memory->unlock(); |
|||
return; |
|||
} |
|||
|
|||
// Check if another instance can be started
|
|||
if( allowSecondary ) { |
|||
inst->secondary += 1; |
|||
inst->checksum = d->blockChecksum(); |
|||
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; |
|||
} |
|||
@ -0,0 +1,135 @@ |
|||
// The MIT License (MIT)
|
|||
//
|
|||
// Copyright (c) Itay Grudev 2015 - 2018
|
|||
//
|
|||
// 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 = 1000 ); |
|||
~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
|
|||
@ -0,0 +1,19 @@ |
|||
QT += core network |
|||
CONFIG += c++11 |
|||
|
|||
HEADERS += $$PWD/singleapplication.h \ |
|||
$$PWD/singleapplication_p.h |
|||
SOURCES += $$PWD/singleapplication.cpp \ |
|||
$$PWD/singleapplication_p.cpp |
|||
|
|||
INCLUDEPATH += $$PWD |
|||
|
|||
win32 { |
|||
msvc:LIBS += Advapi32.lib |
|||
gcc:LIBS += -ladvapi32 |
|||
} |
|||
|
|||
DISTFILES += \ |
|||
$$PWD/README.md \ |
|||
$$PWD/CHANGELOG.md \ |
|||
$$PWD/Windows.md |
|||
@ -0,0 +1,386 @@ |
|||
// The MIT License (MIT)
|
|||
//
|
|||
// Copyright (c) Itay Grudev 2015 - 2018
|
|||
//
|
|||
// 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.
|
|||
//
|
|||
|
|||
#include <cstdlib> |
|||
#include <cstddef> |
|||
|
|||
#include <QtCore/QDir> |
|||
#include <QtCore/QProcess> |
|||
#include <QtCore/QByteArray> |
|||
#include <QtCore/QSemaphore> |
|||
#include <QtCore/QDataStream> |
|||
#include <QtCore/QStandardPaths> |
|||
#include <QtCore/QCryptographicHash> |
|||
#include <QtNetwork/QLocalServer> |
|||
#include <QtNetwork/QLocalSocket> |
|||
|
|||
#include "singleapplication.h" |
|||
#include "singleapplication_p.h" |
|||
|
|||
|
|||
SingleApplicationPrivate::SingleApplicationPrivate( SingleApplication *q_ptr ) |
|||
: q_ptr( q_ptr ) |
|||
{ |
|||
server = nullptr; |
|||
socket = nullptr; |
|||
memory = nullptr; |
|||
instanceNumber = -1; |
|||
} |
|||
|
|||
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; |
|||
inst->checksum = blockChecksum(); |
|||
} |
|||
memory->unlock(); |
|||
|
|||
delete memory; |
|||
} |
|||
|
|||
void SingleApplicationPrivate::genBlockServerName() |
|||
{ |
|||
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 |
|||
appData.addData( QStandardPaths::standardLocations( QStandardPaths::HomeLocation ).join("").toUtf8() ); |
|||
#endif |
|||
#ifdef Q_OS_UNIX |
|||
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::initializeMemoryBlock() |
|||
{ |
|||
InstancesInfo* inst = static_cast<InstancesInfo*>( memory->data() ); |
|||
inst->primary = false; |
|||
inst->secondary = 0; |
|||
inst->primaryPid = -1; |
|||
inst->checksum = blockChecksum(); |
|||
} |
|||
|
|||
void SingleApplicationPrivate::startPrimary() |
|||
{ |
|||
Q_Q(SingleApplication); |
|||
|
|||
// 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
|
|||
InstancesInfo* inst = static_cast <InstancesInfo*>( memory->data() ); |
|||
|
|||
inst->primary = true; |
|||
inst->primaryPid = q->applicationPid(); |
|||
inst->checksum = blockChecksum(); |
|||
|
|||
instanceNumber = 0; |
|||
} |
|||
|
|||
void SingleApplicationPrivate::startSecondary() |
|||
{ |
|||
} |
|||
|
|||
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); |
|||
|
|||
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) |
|||
writeStream.setVersion(QDataStream::Qt_5_6); |
|||
#endif |
|||
|
|||
writeStream << blockServerName.toLatin1(); |
|||
writeStream << static_cast<quint8>(connectionType); |
|||
writeStream << instanceNumber; |
|||
quint16 checksum = qChecksum(initMsg.constData(), static_cast<quint32>(initMsg.length())); |
|||
writeStream << checksum; |
|||
|
|||
// The header indicates the message length that follows
|
|||
QByteArray header; |
|||
QDataStream headerStream(&header, QIODevice::WriteOnly); |
|||
|
|||
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) |
|||
headerStream.setVersion(QDataStream::Qt_5_6); |
|||
#endif |
|||
headerStream << static_cast <quint64>( initMsg.length() ); |
|||
|
|||
socket->write( header ); |
|||
socket->write( initMsg ); |
|||
socket->flush(); |
|||
socket->waitForBytesWritten( msecs ); |
|||
} |
|||
} |
|||
|
|||
quint16 SingleApplicationPrivate::blockChecksum() |
|||
{ |
|||
return qChecksum( |
|||
static_cast <const char *>( memory->data() ), |
|||
offsetof( InstancesInfo, checksum ) |
|||
); |
|||
} |
|||
|
|||
qint64 SingleApplicationPrivate::primaryPid() |
|||
{ |
|||
qint64 pid; |
|||
|
|||
memory->lock(); |
|||
InstancesInfo* inst = static_cast<InstancesInfo*>( memory->data() ); |
|||
pid = inst->primaryPid; |
|||
memory->unlock(); |
|||
|
|||
return pid; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Executed when a connection has been made to the LocalServer |
|||
*/ |
|||
void SingleApplicationPrivate::slotConnectionEstablished() |
|||
{ |
|||
QLocalSocket *nextConnSocket = server->nextPendingConnection(); |
|||
connectionMap.insert(nextConnSocket, ConnectionInfo()); |
|||
|
|||
QObject::connect(nextConnSocket, &QLocalSocket::aboutToClose, |
|||
[nextConnSocket, this]() { |
|||
auto &info = connectionMap[nextConnSocket]; |
|||
Q_EMIT this->slotClientConnectionClosed( nextConnSocket, info.instanceId ); |
|||
} |
|||
); |
|||
|
|||
QObject::connect(nextConnSocket, &QLocalSocket::disconnected, |
|||
[nextConnSocket, this](){ |
|||
connectionMap.remove(nextConnSocket); |
|||
nextConnSocket->deleteLater(); |
|||
} |
|||
); |
|||
|
|||
QObject::connect(nextConnSocket, &QLocalSocket::readyRead, |
|||
[nextConnSocket, this]() { |
|||
auto &info = connectionMap[nextConnSocket]; |
|||
switch(info.stage) { |
|||
case StageHeader: |
|||
readInitMessageHeader(nextConnSocket); |
|||
break; |
|||
case StageBody: |
|||
readInitMessageBody(nextConnSocket); |
|||
break; |
|||
case StageConnected: |
|||
Q_EMIT this->slotDataAvailable( nextConnSocket, info.instanceId ); |
|||
break; |
|||
default: |
|||
break; |
|||
}; |
|||
} |
|||
); |
|||
} |
|||
|
|||
void SingleApplicationPrivate::readInitMessageHeader( QLocalSocket *sock ) |
|||
{ |
|||
if (!connectionMap.contains( sock )) { |
|||
return; |
|||
} |
|||
|
|||
if( sock->bytesAvailable() < ( qint64 )sizeof( quint64 ) ) { |
|||
return; |
|||
} |
|||
|
|||
QDataStream headerStream( sock ); |
|||
|
|||
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) |
|||
headerStream.setVersion( QDataStream::Qt_5_6 ); |
|||
#endif |
|||
|
|||
// Read the header to know the message length
|
|||
quint64 msgLen = 0; |
|||
headerStream >> msgLen; |
|||
ConnectionInfo &info = connectionMap[sock]; |
|||
info.stage = StageBody; |
|||
info.msgLen = msgLen; |
|||
|
|||
if ( sock->bytesAvailable() >= (qint64) msgLen ) { |
|||
readInitMessageBody( sock ); |
|||
} |
|||
} |
|||
|
|||
void SingleApplicationPrivate::readInitMessageBody( QLocalSocket *sock ) |
|||
{ |
|||
Q_Q(SingleApplication); |
|||
|
|||
if (!connectionMap.contains( sock )) { |
|||
return; |
|||
} |
|||
|
|||
ConnectionInfo &info = connectionMap[sock]; |
|||
if( sock->bytesAvailable() < ( qint64 )info.msgLen ) { |
|||
return; |
|||
} |
|||
|
|||
// Read the message body
|
|||
QByteArray msgBytes = sock->read(info.msgLen); |
|||
QDataStream readStream(msgBytes); |
|||
|
|||
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)) |
|||
readStream.setVersion( QDataStream::Qt_5_6 ); |
|||
#endif |
|||
|
|||
// server name
|
|||
QByteArray latin1Name; |
|||
readStream >> latin1Name; |
|||
|
|||
// connection type
|
|||
ConnectionType connectionType = InvalidConnection; |
|||
quint8 connTypeVal = InvalidConnection; |
|||
readStream >> connTypeVal; |
|||
connectionType = static_cast <ConnectionType>( connTypeVal ); |
|||
|
|||
// instance id
|
|||
quint32 instanceId = 0; |
|||
readStream >> instanceId; |
|||
|
|||
// checksum
|
|||
quint16 msgChecksum = 0; |
|||
readStream >> msgChecksum; |
|||
|
|||
const quint16 actualChecksum = qChecksum( msgBytes.constData(), static_cast<quint32>( msgBytes.length() - sizeof( quint16 ) ) ); |
|||
|
|||
bool isValid = readStream.status() == QDataStream::Ok && |
|||
QLatin1String(latin1Name) == blockServerName && |
|||
msgChecksum == actualChecksum; |
|||
|
|||
if( !isValid ) { |
|||
sock->close(); |
|||
return; |
|||
} |
|||
|
|||
info.instanceId = instanceId; |
|||
info.stage = StageConnected; |
|||
|
|||
if( connectionType == NewInstance || |
|||
( connectionType == SecondaryInstance && |
|||
options & SingleApplication::Mode::SecondaryNotification ) ) |
|||
{ |
|||
Q_EMIT q->instanceStarted(); |
|||
} |
|||
|
|||
if (sock->bytesAvailable() > 0) { |
|||
Q_EMIT this->slotDataAvailable( sock, 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 ); |
|||
} |
|||
@ -0,0 +1,99 @@ |
|||
// 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; |
|||
quint16 checksum; |
|||
}; |
|||
|
|||
struct ConnectionInfo { |
|||
explicit ConnectionInfo() : |
|||
msgLen(0), instanceId(0), stage(0) {} |
|||
qint64 msgLen; |
|||
quint32 instanceId; |
|||
quint8 stage; |
|||
}; |
|||
|
|||
class SingleApplicationPrivate : public QObject { |
|||
Q_OBJECT |
|||
public: |
|||
enum ConnectionType : quint8 { |
|||
InvalidConnection = 0, |
|||
NewInstance = 1, |
|||
SecondaryInstance = 2, |
|||
Reconnect = 3 |
|||
}; |
|||
enum ConnectionStage : quint8 { |
|||
StageHeader = 0, |
|||
StageBody = 1, |
|||
StageConnected = 2, |
|||
}; |
|||
Q_DECLARE_PUBLIC(SingleApplication) |
|||
|
|||
SingleApplicationPrivate( SingleApplication *q_ptr ); |
|||
~SingleApplicationPrivate(); |
|||
|
|||
void genBlockServerName(); |
|||
void initializeMemoryBlock(); |
|||
void startPrimary(); |
|||
void startSecondary(); |
|||
void connectToPrimary(int msecs, ConnectionType connectionType ); |
|||
quint16 blockChecksum(); |
|||
qint64 primaryPid(); |
|||
void readInitMessageHeader(QLocalSocket *socket); |
|||
void readInitMessageBody(QLocalSocket *socket); |
|||
|
|||
SingleApplication *q_ptr; |
|||
QSharedMemory *memory; |
|||
QLocalSocket *socket; |
|||
QLocalServer *server; |
|||
quint32 instanceNumber; |
|||
QString blockServerName; |
|||
SingleApplication::Options options; |
|||
QMap<QLocalSocket*, ConnectionInfo> connectionMap; |
|||
|
|||
public Q_SLOTS: |
|||
void slotConnectionEstablished(); |
|||
void slotDataAvailable( QLocalSocket*, quint32 ); |
|||
void slotClientConnectionClosed( QLocalSocket*, quint32 ); |
|||
}; |
|||
|
|||
#endif // SINGLEAPPLICATION_P_H
|
|||
Loading…
Reference in new issue