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 <networkaux.hpp>
#include <iprouter.hpp>

#include <uxcontrol.pb.h>

void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, std::vector<std::string> routes) {
        sock = newsock;
        tunAddress = raddr;
        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, 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.Debug(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.Error(std::format("Write message error: {}", error));
                        return;
                }
        }
        {
                uxlogger.Debug(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.Error(std::format("Write message error: {}", error));
                        return;
                }
        }

        for (const auto& route : routes) {
                auto prefixRes = netprefix(route);
                if (!prefixRes) {
                        uxlogger.Error(prefixRes.error());
                        continue;
                }
                auto networkRes = network(route);
                if (!networkRes) {
                        uxlogger.Error(networkRes.error());
                        continue;
                }
                auto network = networkRes.value();
                auto prefix = prefixRes.value();

                uxlogger.Info(std::format("Send route message for {}/{}", network, prefix));
                uxcontrol::RouteMessage routeMsg;
                auto meta = routeMsg.mutable_meta();
                meta->set_kind(localRouteMsg);
                routeMsg.set_address(network);
                routeMsg.set_prefix(prefix);
                std::string rawMessage;
                routeMsg.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.Error(std::format("Write message error: {}", error));
                        return;
                }

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

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

void SocketHandler::SendMessages(void) {
        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.Error(std::format("Write packet error: {}", error));
                        break;
                }
                uxlogger.Debug("Send internetPacket message");

        }
        done.release();
        uxlogger.Info("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.Error(std::format("Read header error: {}", error));
                        break;
                }
                if (rsize < msgHeaderSize) {
                        uxlogger.Error(std::format("Read only {} from {} header bytes", rsize, msgHeaderSize));
                        break;
                }
                MessageHeader header;
                auto decodeRes = header.Decode(rawHeader);
                if (!decodeRes) {
                        uxlogger.Error(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.Error(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 if (kind == localRouteMsg) {
                        uxcontrol::RouteMessage routeMessage;
                        routeMessage.ParseFromString(rawMessage);
                        auto network = routeMessage.address();
                        auto prefix = routeMessage.prefix();
                        auto networkRes = nethost(network, prefix, 0);
                        if (!networkRes) {
                                uxlogger.Error(networkRes.error());
                                break;
                        }
                        network = networkRes.value();
                        uxlogger.Info(std::format("Received route {}/{} gw {}", network, prefix, tunAddress));
                        if (tunAddress != "") {
                                Router router;
                                auto addRouteRes = router.AddRoute(network, prefix, tunAddress, interface.Name());
                                if (!addRouteRes) {
                                        uxlogger.Error(addRouteRes.error());
                                } else {
                                        uxlogger.Warning(std::format("Add route {}/{}", network, prefix));
                                }
                        }
                } else {
                        uxlogger.Warning("Received unknown kind of message");
                }
        }
        done.release();
        uxlogger.Info("Recv messages done");
}