Implement Custom IPC Solution

[josephcrowell]

Describe the task

Replace D-Bus with a custom IPC solution combining QLocalSocket / QLocalServer with QDataStream.

It should be done because

Because we want to free ourselves from dependency on systemd/dbus components. They should be an option, not a requirement.

Additional context

Pairing QLocalSocket with QDataStream provides a type-safe, asynchronous mechanism that handles Qt types natively.

It fits our requirements:

• Lightweight: It is a direct peer-to-peer connection. There is no middleman daemon, zero XML parsing, and no message routing overhead.
• Asynchronous: Built entirely on top of Qt’s event loop using non-blocking signals and slots (readyRead(), disconnected()).
• Secure: UNIX domain sockets are restricted by standard file system permissions.

Extra fields

• I have checked the existing issues
• I'd like to work on this issue

[josephcrowell]

Implementation Example

1. The Server (Receiver)

// MyServer.h
#include <QObject>
#include <QLocalServer>
#include <QLocalSocket>

class MyServer : public QObject {
    Q_OBJECT
public:
    MyServer(QObject *parent = nullptr);
private slots:
    void handleNewConnection();
    void readClientData();
private:
    QLocalServer *server;
};

// MyServer.cpp
#include "MyServer.h"
#include <QDataStream>
#include <QDebug>

MyServer::MyServer(QObject *parent) : QObject(parent) {
    server = new QLocalServer(this);
    
    // Ensure the socket file is cleaned up if a previous crash occurred
    QLocalServer::removeServer("my_secure_ipc_pipe");

    connect(server, &QLocalServer::newConnection, this, &MyServer::handleNewConnection);
    
    if (!server->listen("my_secure_ipc_pipe")) {
        qCritical() << "Server failed to start:" << server->errorString();
    }
}

void MyServer::handleNewConnection() {
    QLocalSocket *clientSocket = server->nextPendingConnection();
    if (!clientSocket) return;

    connect(clientSocket, &QLocalSocket::readyRead, this, &MyServer::readClientData);
    
    // Auto-delete socket memory on disconnect
    connect(clientSocket, &QLocalSocket::disconnected, clientSocket, &QLocalSocket::deleteLater);
}

void MyServer::readClientData() {
    auto *socket = qobject_cast<QLocalSocket*>(sender());
    if (!socket) return;

    QDataStream in(socket);
    in.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    // Asynchronous streaming logic using a transaction loop
    in.startTransaction();

    QString messageType;
    QVariantMap payload;
    in >> messageType >> payload;

    if (in.commitTransaction()) {
        qDebug() << "Received IPC Command:" << messageType << "with payload:" << payload;
        // Process data asynchronously here...
    } else {
        // Not enough data arrived yet; wait for the next readyRead signal
        return;
    }
}

2. The Client (Sender)

// MyClient.h
#include <QObject>
#include <QLocalSocket>

class MyClient : public QObject {
    Q_OBJECT
public:
    MyClient(QObject *parent = nullptr);
    void sendAsynchronousCommand(const QString &command, const QVariantMap &data);
private:
    QLocalSocket *socket;
};

// MyClient.cpp
#include "MyClient.h"
#include <QDataStream>

MyClient::MyClient(QObject *parent) : QObject(parent) {
    socket = new QLocalSocket(this);
}

void MyClient::sendAsynchronousCommand(const QString &command, const QVariantMap &data) {
    if (socket->state() != QLocalSocket::ConnectedState) {
        socket->connectToServer("my_secure_ipc_pipe");
        // Wait for connection asynchronously or use standard signals.
        // For brevity, we assume an active connection or buffer management.
    }

    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    // Stream the data into a safe byte block
    out << command << data;

    // Write asynchronously to the OS socket buffer
    socket->write(block);
    socket->flush(); 
}

[josephcrowell]

Securing the IPC Channel

Because QLocalServer creates a physical file on UNIX/BSD file systems (usually in /tmp or a runtime directory), security relies on POSIX file permissions.

1. Place Sockets Safely: Do not use public directories like /tmp. Use standard user-specific runtime directories. In Qt, you can get a secure path using:

QString securePath = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
// e.g., /run/user/1000/my_secure_ipc_pipe

2. Restrict Permissions Directly: After your server starts listening, immediately restrict file access explicitly using native system calls so other OS users cannot read or write to it:

#include <sys/stat.h>
// ... after server->listen() ...
QString socketPath = server->fullServerName();
chmod(socketPath.toUtf8().constData(), S_IRUSR | S_IWUSR); // Only Owner Read/Write (0600)

[josephcrowell]

##Possible Alternative

Qt Remote Objects (QtRO): A built-in Qt module designed to replicate standard Qt Signals/Slots seamlessly across different processes. It can run directly over QLocalServer domain sockets, eliminating D-Bus while giving you a high-level, object-oriented RPC architecture.