sonic-screenlocker/greeteripcserver.cpp at master · Sonic-DE/sonic-screenlocker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
/*
    SPDX-FileCopyrightText: 2024 KDE contributors

    SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "greeteripcserver.h"

#include "kscreenlocker_logging.h"

#include <QCoreApplication>
#include <QDataStream>
#include <QLocalServer>
#include <QLocalSocket>
#include <QThread>

GreeterIpcServer::GreeterIpcServer(QObject *parent)
    : QObject(parent)
    , m_server(nullptr)
{
}

GreeterIpcServer::~GreeterIpcServer()
{
    if (m_server) {
        // Disconnect all pending connections
        for (QLocalSocket *client : m_server->findChildren<QLocalSocket *>()) {
            client->disconnect();
            client->close();
        }
        m_server->close();
        delete m_server;
        m_server = nullptr;
    }
}

QString GreeterIpcServer::socketName()
{
    // Use a unique socket name based on the process ID
    return QStringLiteral("kscreenlocker-greeter-ipc-%1").arg(QCoreApplication::applicationPid());
}

bool GreeterIpcServer::initialize()
{
    if (m_server) {
        qCWarning(KSCREENLOCKER) << "GreeterIpcServer: Already initialized";
        return true;
    }

    m_server = new QLocalServer(this);

    // Remove any existing socket with the same name
    QLocalServer::removeServer(socketName());

    if (!m_server->listen(socketName())) {
        qCWarning(KSCREENLOCKER) << "GreeterIpcServer: Failed to listen on socket" << socketName() << "Error:" << m_server->errorString();
        delete m_server;
        m_server = nullptr;
        return false;
    }

    connect(m_server, &QLocalServer::newConnection, this, &GreeterIpcServer::handleNewConnection);

    return true;
}

void GreeterIpcServer::handleNewConnection()
{
    QLocalSocket *clientSocket = m_server->nextPendingConnection();
    if (!clientSocket) {
        return;
    }

    connect(clientSocket, &QLocalSocket::readyRead, this, [this, clientSocket]() {
        handleDataAvailable(clientSocket);
    });
    connect(clientSocket, &QLocalSocket::disconnected, this, [this, clientSocket]() {
        handleClientDisconnected(clientSocket);
    });
}

void GreeterIpcServer::handleDataAvailable(QLocalSocket *clientSocket)
{
    QDataStream in(clientSocket);

    // Read message header: messageType + messageId
    while (clientSocket->bytesAvailable() >= static_cast<qint64>(sizeof(quint64))) {
        quint32 messageType;
        quint32 messageId;
        in >> messageType >> messageId;

        switch (messageType) {
        case MsgRegisterWindow: {
            quint32 winId;
            QString screenName;
            in >> winId >> screenName;
            Q_EMIT greeterWindowRegistered(winId, screenName);
            sendResponse(clientSocket, messageId, true);
            break;
        }
        case MsgUnregisterWindow: {
            quint32 winId;
            in >> winId;
            Q_EMIT greeterWindowUnregistered(winId);
            sendResponse(clientSocket, messageId, true);
            break;
        }
        case MsgAuthenticationSuccess: {
            Q_EMIT greeterAuthenticationSuccess();
            sendResponse(clientSocket, messageId, true);
            break;
        }
        case MsgGetFocus: {
            QString screenName;
            in >> screenName;
            Q_EMIT greeterGetFocusRequested(screenName);
            sendResponse(clientSocket, messageId, true);
            break;
        }
        case MsgScreenAdded: {
            QString screenName;
            QRect geometry;
            in >> screenName >> geometry;
            Q_EMIT screenAdded(screenName, geometry);
            sendResponse(clientSocket, messageId, true);
            break;
        }
        case MsgScreenRemoved: {
            QString screenName;
            in >> screenName;
            Q_EMIT screenRemoved(screenName);
            sendResponse(clientSocket, messageId, true);
            break;
        }
        default:
            qCWarning(KSCREENLOCKER) << "GreeterIpcServer: Unknown message type" << messageType;
            sendResponse(clientSocket, messageId, false);
            break;
        }
    }
}

void GreeterIpcServer::handleClientDisconnected(QLocalSocket *clientSocket)
{
    m_clientMessageIds.remove(clientSocket);
    clientSocket->deleteLater();
}

void GreeterIpcServer::sendResponse(QLocalSocket *clientSocket, quint32 messageId, bool success)
{
    if (!clientSocket || clientSocket->state() != QLocalSocket::ConnectedState) {
        return;
    }

    QByteArray block;
    QDataStream out(&block, QIODevice::WriteOnly);
    out << MsgResponse << messageId << static_cast<quint8>(success ? 1 : 0);

    clientSocket->write(block);
    clientSocket->flush();
}