I just discovered a neat trick for enforcing a single instance of a C++ program.

It’s just a small and stateless function that uses UNIX sockets.

 1bool processAlreadyExists()
 2{
 3    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
 4
 5    sockaddr_un addr;
 6    memset(&addr, 0, sizeof(addr));
 7    addr.sun_family = AF_UNIX;
 8
 9    // make socket 'abstract' by setting the first char of the name to '\0'
10    string socket_name = " jot_lock";
11    socket_name[0] = '\0';
12
13    memcpy(addr.sun_path, socket_name.data(), socket_name.size());
14
15    if (bind(fd, (sockaddr*)&addr, sizeof(addr)) == -1)
16    {
17        // bind fails, return true
18        // means a first instance has already started
19        return true;
20    }
21
22    // bind succeeds, return false
23    // this is the first instance
24    return false;
25}

And here’s a small program that demonstrates how to use it.

 1//
 2// *nix
 3//
 4#include <sys/socket.h>
 5#include <sys/un.h>
 6
 7//
 8// std
 9//
10#include <string>
11#include <iostream>
12using namespace std;
13
14bool processAlreadyExists()
15{
16    int fd = socket(AF_UNIX, SOCK_STREAM, 0);
17
18    sockaddr_un addr;
19    memset(&addr, 0, sizeof(addr));
20    addr.sun_family = AF_UNIX;
21
22    // make socket 'abstract' by setting the first char of the name to '\0'
23    string socket_name = " jot_lock";
24    socket_name[0] = '\0';
25
26    memcpy(addr.sun_path, socket_name.data(), socket_name.size());
27
28    if (bind(fd, (sockaddr*)&addr, sizeof(addr)) == -1)
29    {
30        // bind fails, return true
31        // means a first instance has already started
32        return true;
33    }
34
35    // bind succeeds, return false
36    // this is the first instance
37    return false;
38}
39
40int main()
41{
42    if (processAlreadyExists())
43    {
44        cout << "second process, exiting now..." << endl;
45        return EXIT_SUCCESS;
46    }
47
48    cout << "first process, exiting in 5 seconds..." << endl;
49    sleep(5);
50
51    return EXIT_SUCCESS;
52}

It works perfectly on Linux, leveraging a unique feature called Abstract Sockets. When a UNIX socket is given a name beginning with a zero ('\0' , not '0'), it is considered Abstract. That means the system will not create a file for the socket in the file system, which is the default behaviour. The following is the relevant exert from the documentation.

an abstract socket address is distinguished (from a pathname socket) by the fact that sun_path[0] is a null byte (‘\0’). The socket’s address in this namespace is given by the additional bytes in sun_path that are covered by the specified length of the address structure. (Null bytes in the name have no special significance.) The name has no connection with filesystem pathnames. When the address of an abstract socket is returned, the returned addrlen is greater than sizeof(sa_family_t) (i.e., greater than 2), and the name of the socket is contained in the first (addrlen - sizeof(sa_family_t)) bytes of sun_path.

This means that the socket ceases to exist entirely at the end of the process that created it. That’s important because otherwise you’d need to care about whether a dangling socket file was leftover by a previous process. With abstract sockets the system will do all the cleanup for you, no matter what.

I’m using this trick now in an old project that I picked up after letting it sit for several months. It’s called ‘jot’, a small program that creates virtual key presses. I use it now just to type out date codes like the ones in this post.

I love discovering little tricks like this. If you have any of your own, let me know!

Email me at mail@lzon.ca, or reach out through one of my social accounts linked on the homepage.