stvpn/uxclient.cpp

extern "C" {
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
}

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

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

#include <uxcontrol.pb.h>

using namespace std::chrono_literals;

UxClient::UxClient() {
        sock = 0;
        family = 0;
}

std::expected<void, std::string> UxClient::Connect(const std::string naddress, const int port) {

        struct sockaddr_in sa;
        if (inet_pton(AF_INET, naddress.c_str(), &(sa.sin_addr)) == 1) {
                family = AF_INET;
        } else if (inet_pton(AF_INET6, naddress.c_str(), &(sa.sin_addr)) == 1) {
                family = AF_INET6;
        } else {
                int errnocopy = errno;
                std::string error = std::strerror(errnocopy);
                return std::unexpected("Incorrect address " + naddress);
        }

        sock = socket(family, SOCK_STREAM, 0);
        if (sock < 0) {
                return std::unexpected("Error opening socket");
        }
        struct sockaddr_in serv_addr;
        memset(&serv_addr, 0, sizeof(serv_addr));

        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(port);
        const char* addr = naddress.data();
        if (inet_pton(AF_INET, addr, &serv_addr.sin_addr) <= 0) {
                return std::unexpected("Invalid server IP address");
        }

        struct timeval timeout;
        timeout.tv_sec = 5;
        timeout.tv_usec = 0;

        if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout) < 0) {
                int errnoCopy = errno;
                std::string error = std::strerror(errnoCopy);
                return std::unexpected(std::format("Set timeout error: {}", error));
        }
        if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof timeout) < 0) {
                int errnoCopy = errno;
                std::string error = std::strerror(errnoCopy);
                return std::unexpected(std::format("Set send timeout error: {}", error));
        }
        if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
                int errnoCopy = errno;
                std::string error = std::strerror(errnoCopy);
                return std::unexpected(std::format("Connect error: {}", error));

        }
        return {};
}

void UxClient::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;
                }
                MessageHeader header;
                auto decodeRes = header.Decode(rawHeader);
                if (!decodeRes) {
                        uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
                }
                auto pSize = header.PacketSize();
                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 with size {}", pSize));
        }
        done.release();
        return;
}

void UxClient::SendMessages(void) {
        while (true) {

                auto readRes = interface.Read();
                if (!readRes) {
                        uxlogger.Log(std::format("Read packet error: {}", readRes.error()));
                }
                auto packet = readRes.value();
                uxlogger.Log(std::format("Read packet size {}", packet.size()));

                int wsize = 0;
                MessageHeader header(packet.size());
                auto rawHeader = header.Encode();
                if ((wsize = write(sock, rawHeader.data(), rawHeader.size())) < 0) {
                        int errnoCopy = errno;
                        std::string error = std::strerror(errnoCopy);
                        uxlogger.Log(std::format("Write header error: {}", error));
                        break;
                }
                uxlogger.Log(std::format("Write header wsize: {}", wsize));

                uxcontrol::InternetPacket intPacket;
                auto meta = intPacket.mutable_meta();
                meta->set_kind("internetPacket");
                intPacket.set_payload(packet);

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

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

                //std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        done.release();
        return;
}


std::expected<void, std::string> UxClient::Run(void) {

        auto createRes = interface.Create("uxcli0");
        if (!createRes) {
                return std::unexpected(createRes.error());
        }
        auto setAddrRes = interface.SetIP4Address("10.1.1.2");
        if (!setAddrRes) {
                return std::unexpected(setAddrRes.error());
        }
        auto setMaskRes = interface.SetIP4Netmask(24);
        if (!setMaskRes) {
                return std::unexpected(setMaskRes.error());
        }
        auto setMTURes = interface.SetMTU(1280);
        if (!setMTURes) {
                return std::unexpected(setMTURes.error());
        }
        auto upRes = interface.Up();
        if (!createRes) {
                return std::unexpected(createRes.error());
        }
        std::thread sendThr(&UxClient::SendMessages, this);
        sendThr.detach();

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

        done.acquire();
        uxlogger.Log("Client done");
        return {};
}

UxClient::~UxClient() {
        if (sock != 0) {
                close(sock);
        }
}