stvpn/sockhand.cpp

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

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

//#include <uxcontrol.pb.h>

using namespace std::chrono_literals;

void SocketHandler::RecvMessages(void) {
        while (true) {
                uxlogger.Log("Handle socket");
                int rsize = 0;
                std::string rawHeader(msgHeaderSize, 0);
                {

                        if ((rsize = read(sock, rawHeader.data(), rawHeader.size())) < 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;
                }
                MessageHeader header;
                auto decodeRes = header.Decode(rawHeader);
                if (!decodeRes) {
                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
                }
                std::string rawMessage(header.PacketSize(), 0);
                {
                        if ((rsize = read(sock, rawMessage.data(), rawMessage.size())) < 0) {
                                int errnoCopy = errno;
                                std::string error = std::strerror(errnoCopy);
                                uxlogger.Log(std::format("Read message error: {}", error));
                                break;
                        }
                }
        }
        done.release();
        uxlogger.Log("RecvMessages 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("SendMessages done");
}

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

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

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

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