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>

void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, int prefix) {
        sock = newsock;
        auto interfaceName = std::format("uxsrv{}", sock);
        auto createRes = interface.Create(interfaceName);
        if (!createRes) {
                uxlogger.Error(createRes.error());
                return;
        }
        uxlogger.Debug(std::format("Set local ip address {}/{} for {}", laddr, prefix, interfaceName));
        auto setAddrRes = interface.SetIP4Address(laddr);
        if (!setAddrRes) {
                uxlogger.Error(setAddrRes.error());
                return;
        }
        auto setPrefixRes = interface.SetIP4Netmask(30);
        if (!setPrefixRes) {
                uxlogger.Error(setPrefixRes.error());
                return;
        }
        auto upRes = interface.Up();
        if (!createRes) {
                uxlogger.Error(createRes.error());
                return;
        }
        std::thread recvThr(&SocketHandler::RecvMessages, this);
        recvThr.detach();
        {
                uxlogger.Log(std::format("Send debug empty message"));
                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));
                        return;
                }
        }
        {
                uxlogger.Log(std::format("Send address message"));
                uxcontrol::AddressMessage addrMsg;
                auto meta = addrMsg.mutable_meta();
                meta->set_kind(tunAddressMsg);
                addrMsg.set_address(raddr);
                addrMsg.set_prefix(30);
                std::string rawMessage;
                addrMsg.SerializeToString(&rawMessage);

                MessageHeader header(rawMessage.size());
                auto rawHeader = header.Encode();
                std::string rawPacket;
                rawPacket.append(rawHeader);
                rawPacket.append(rawMessage);

                int wsize;
                if ((wsize = write(sock, rawPacket.data(), rawPacket.size())) < 0) {
                        int errnoCopy = errno;
                        std::string error = std::strerror(errnoCopy);
                        uxlogger.Log(std::format("Write message error: {}", error));
                        return;
                }
        }

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

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

void SocketHandler::SendMessages(std::string raddr) {

        while (true) {
                auto readRes = interface.Read();
                if (!readRes) {
                        uxlogger.Error(std::format("Read packet error: {}", readRes.error()));
                        continue;

                }
                auto packet = readRes.value();

                uxcontrol::PacketMessage intPacket;
                auto meta = intPacket.mutable_meta();
                meta->set_kind(internetPkgMsg);
                intPacket.set_payload(packet);

                std::string rawMessage;
                intPacket.SerializeToString(&rawMessage);

                MessageHeader header(rawMessage.size());
                auto rawHeader = header.Encode();

                std::string rawPacket;
                rawPacket.append(rawHeader);
                rawPacket.append(rawMessage);

                int wsize = 0;
                if ((wsize = send(sock, rawPacket.data(), rawPacket.size(), 0)) < 0) {
                        int errnoCopy = errno;
                        std::string error = std::strerror(errnoCopy);
                        uxlogger.Log(std::format("Write packet error: {}", error));
                        break;
                }
                uxlogger.Log("Send internetPacket message");

        }
        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 {} header bytes", rsize, msgHeaderSize));
                        break;
                }
                MessageHeader header;
                auto decodeRes = header.Decode(rawHeader);
                if (!decodeRes) {
                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
                        break;
                }
                auto pSize = header.PayloadSize();
                if (pSize == 0) {
                        continue;
                }
                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;
                }
                uxcontrol::SimpleMessage simpleMsg;
                simpleMsg.ParseFromString(rawMessage);

                auto metaPart = simpleMsg.meta();
                auto kind = metaPart.kind();
                uxlogger.Debug(std::format("Received message kind of {}", kind));

                if (kind == internetPkgMsg) {
                        uxcontrol::PacketMessage packetMessage;
                        packetMessage.ParseFromString(rawMessage);
                        auto payload = packetMessage.payload();
                        auto writeRes = interface.Write(payload);
                        if (!writeRes) {
                                auto error = writeRes.error();
                                uxlogger.Error(std::format("Write packet error: {}", error));
                        }
                } else {
                        uxlogger.Warning("Received unknown kind of message");
                }
        }
        done.release();
        uxlogger.Log("Recv messages done");
}