stvpn/sockhand.cpp

extern "C" {
#include <sys/socket.h>
}

#include <expected>
#include <string>
#include <iostream>
#include <thread>
#include <chrono>
#include <cstring>
#include <semaphore>
#include <format>

#include <msgheader.hpp>
#include <sockhand.hpp>
#include <uxlogger.hpp>


#include <uxcontrol.pb.h>

using namespace std::chrono_literals;


void SocketHandler::Handle(int newsock) {
        sock = newsock;

        auto createRes = interface.Create(std::format("uxsrv{}", sock));
        if (!createRes) {
                uxlogger.Log(createRes.error());
                return;
        }
        auto upRes = interface.Up();
        if (!createRes) {
                uxlogger.Log(createRes.error());
                return;
        }

        std::thread sendThr(&SocketHandler::SendMessages, this);
        sendThr.detach();

        std::thread recvThr(&SocketHandler::RecvMessages, this);
        recvThr.detach();

        done.acquire();
        uxlogger.Log("Handler done");
}


void SocketHandler::SendMessages(void) {
        while (true) {
                MessageHeader header(0);
                auto rawHeader = header.Encode();
                int wsize;
                {
                        if ((wsize = write(sock, rawHeader.data(), rawHeader.size())) < 0) {
                                int errnoCopy = errno;
                                std::string error = std::strerror(errnoCopy);
                                uxlogger.Log(std::format("Write message error: {}", error));
                                break;
                        }
                }
                std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        done.release();
        uxlogger.Log("Send messages done");
}

void SocketHandler::RecvMessages(void) {
        while (true) {
                int rsize = 0;
                std::string rawHeader(msgHeaderSize, 0);
                if ((rsize = recv(sock, rawHeader.data(), rawHeader.size(), MSG_WAITALL)) < 0) {
                        int errnoCopy = errno;
                        std::string error = std::strerror(errnoCopy);
                        uxlogger.Log(std::format("Read header error: {}", error));
                        break;
                }
                if (rsize < msgHeaderSize) {
                        uxlogger.Log(std::format("Read only {} from {} bytes", rsize, msgHeaderSize));
                        break;
                }
                uxlogger.Log(std::format("Receive header rsize {}", rsize));

                MessageHeader header;
                auto decodeRes = header.Decode(rawHeader);
                if (!decodeRes) {
                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
                        break;
                }
                auto pSize = header.PacketSize();
                uxlogger.Log(std::format("Message size {}", pSize));

                if (pSize > 0) {
                        std::string rawMessage(pSize, 0);
                        if ((rsize = recv(sock, rawMessage.data(), rawMessage.size(), MSG_WAITALL)) < 0) {
                                int errnoCopy = errno;
                                std::string error = std::strerror(errnoCopy);
                                uxlogger.Log(std::format("Read message error: {}", error));
                                break;
                        }
                        uxlogger.Log(std::format("Receive message rsize {}", rsize));
                        uxcontrol::Message msg;
                        msg.ParseFromString(rawMessage);
                        uxlogger.Log(std::format("Receive message, kind {}", msg.meta().kind()));
                }
        }
        done.release();
        uxlogger.Log("Recv messages done");
}