File indexing completed on 2024-06-23 05:24:07

 // SPDX-FileCopyrightText: 2023 Arjen Hiemstra <ahiemstra@heimr.nl>
 //
 // SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 
 #include "Server.h"
 
 #include <vector>
 
 #include <QCoreApplication>
 
 #include <freerdp/channels/channels.h>
 #include <freerdp/freerdp.h>
 #include <winpr/ssl.h>
 
 #include "RdpConnection.h"
 
 #include "krdp_logging.h"
 
 using namespace KRdp;
 
 class KRDP_NO_EXPORT Server::Private
 {
 public:
     std::vector<std::unique_ptr<RdpConnection>> sessions;
     rdp_settings *settings = nullptr;
 
     QHostAddress address = QHostAddress::LocalHost;
     quint16 port = 3389;
 
     QString userName;
     QString password;
 
     std::filesystem::path tlsCertificate;
     std::filesystem::path tlsCertificateKey;
 };
 
 Server::Server(QObject *parent)
     : QTcpServer(parent)
     , d(std::make_unique<Private>())
 {
     winpr_InitializeSSL(WINPR_SSL_INIT_DEFAULT);
     WTSRegisterWtsApiFunctionTable(FreeRDP_InitWtsApi());
 }
 
 Server::~Server()
 {
     stop();
 }
 
 bool Server::start()
 {
     if (!std::filesystem::exists(d->tlsCertificate) || !std::filesystem::exists(d->tlsCertificateKey)) {
         qCCritical(KRDP).nospace() << "A valid TLS certificate (" << QString::fromStdString(d->tlsCertificate.filename().string()) << ") and key ("
                                    << QString::fromStdString(d->tlsCertificateKey.filename().string()) << ") is required for the server to run!";
         return false;
     }
 
     if (!listen(d->address, d->port)) {
         qCCritical(KRDP) << "Unable to listen for connections on" << serverAddress() << serverPort();
         return false;
     }
 
 #ifdef FREERDP3
     // FreeRDP3 tries to use a global instance of the settings object when
     // initializing a new peer. However, it seems to fail at actually creating a
     // global default instance. So create one here and use that.
     d->settings = freerdp_settings_new(FREERDP_SETTINGS_SERVER_MODE);
 #endif
 
     qCDebug(KRDP) << "Listening for connections on" << serverAddress() << serverPort();
     return true;
 }
 
 void Server::stop()
 {
     close();
 
     if (d->settings) {
         freerdp_settings_free(d->settings);
         d->settings = nullptr;
     }
 }
 
 QHostAddress Server::address() const
 {
     return d->address;
 }
 
 void Server::setAddress(const QHostAddress &newAddress)
 {
     if (newAddress == d->address) {
         return;
     }
 
     d->address = newAddress;
 }
 
 quint16 Server::port() const
 {
     return d->port;
 }
 
 void Server::setPort(quint16 newPort)
 {
     if (newPort == d->port) {
         return;
     }
 
     d->port = newPort;
 }
 
 QString Server::userName() const
 {
     return d->userName;
 }
 
 void Server::setUserName(const QString &newUserName)
 {
     if (newUserName == d->userName) {
         return;
     }
 
     d->userName = newUserName;
 }
 
 QString Server::password() const
 {
     return d->password;
 }
 
 void Server::setPassword(const QString &newPassword)
 {
     if (newPassword == d->password) {
         return;
     }
 
     d->password = newPassword;
 }
 
 std::filesystem::path Server::tlsCertificate() const
 {
     return d->tlsCertificate;
 }
 
 void Server::setTlsCertificate(const std::filesystem::path &newTlsCertificate)
 {
     if (newTlsCertificate == d->tlsCertificate) {
         return;
     }
 
     d->tlsCertificate = newTlsCertificate;
 }
 
 std::filesystem::path Server::tlsCertificateKey() const
 {
     return d->tlsCertificateKey;
 }
 
 void Server::setTlsCertificateKey(const std::filesystem::path &newTlsCertificateKey)
 {
     if (newTlsCertificateKey == d->tlsCertificateKey) {
         return;
     }
 
     d->tlsCertificateKey = newTlsCertificateKey;
 }
 
 void Server::incomingConnection(qintptr handle)
 {
     auto session = std::make_unique<RdpConnection>(this, handle);
     auto sessionPtr = session.get();
     connect(session.get(), &RdpConnection::stateChanged, this, [this, sessionPtr]() {
         if (sessionPtr->state() == RdpConnection::State::Closed) {
             auto itr = std::find_if(d->sessions.begin(), d->sessions.end(), [sessionPtr](auto &session) {
                 return session.get() == sessionPtr;
             });
             d->sessions.erase(itr);
         }
     });
     d->sessions.push_back(std::move(session));
     Q_EMIT newConnection(sessionPtr);
 }
 
 rdp_settings *Server::rdpSettings() const
 {
     return d->settings;
 }
 
 #include "moc_Server.cpp"