working commit

msgheader.cpp

@@ -12,6 +12,10 @@ extern "C" {
 
 #include <msgheader.hpp>
 
+const std::string internetPkgMsg = "internetPkg";
+const std::string tunAddressMsg = "tunAddress";
+const std::string Msg = "localRoute";
+
 MessageHeader::MessageHeader(const uint32_t ipSize) {
         pSize = ipSize;
 }

msgheader.hpp

@@ -4,6 +4,10 @@
 constexpr uint32_t msgMagic = 0xABBA;
 constexpr int msgHeaderSize = 8;
 
+extern const std::string internetPkgMsg;
+extern const std::string tunAddressMsg;
+extern const std::string localRouteMsg;
+
 class MessageHeader {
 private:
         uint32_t pSize = 0;

sockhand.cpp

@@ -19,9 +19,7 @@ extern "C" {
 
 #include <uxcontrol.pb.h>
 
-const std::string internetPkgMsg = "internetPkg";
+
-const std::string tunAddressMsg = "tunAddress";
-const std::string Msg = "localRoute";
 
 
 using namespace std::chrono_literals;
@@ -52,10 +50,21 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, in
                 return;
         }
 
+
         std::thread recvThr(&SocketHandler::RecvMessages, this);
         recvThr.detach();
 
-#if 1
+        std::thread sendThr(&SocketHandler::SendMessages, this, raddr, prefix);
+        sendThr.detach();
+
+        done.acquire();
+        uxlogger.Log("Handler done");
+}
+
+void SocketHandler::SendMessages(std::string raddr, int prefix) {
+
+        uxlogger.Log(std::format("Send address message"));
+
         uxcontrol::AddressMessage addrMsg;
         auto meta = addrMsg.mutable_meta();
         meta->set_kind(tunAddressMsg);
@@ -77,17 +86,39 @@ void SocketHandler::Handle(int newsock, std::string laddr, std::string raddr, in
                 uxlogger.Log(std::format("Write message error: {}", error));
                 return;
         }
-#endif
-        std::thread sendThr(&SocketHandler::SendMessages, this);
-        sendThr.detach();
-
-        done.acquire();
-        uxlogger.Log("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.Log(std::format("Write packet error: {}", error));
+                        break;
+                }
+                uxlogger.Log("Send internetPacket message");
+                /*
                 MessageHeader header(0);
                 auto rawHeader = header.Encode();
                 int wsize;
@@ -99,7 +130,8 @@ void SocketHandler::SendMessages(void) {
                                 break;
                         }
                 }
-                std::this_thread::sleep_for(std::chrono::seconds(30));
+                std::this_thread::sleep_for(std::chrono::seconds(3));
+                */
         }
         done.release();
         uxlogger.Log("Send messages done");

sockhand.hpp

@@ -9,9 +9,7 @@
 
 #include <interface.hpp>
 
-extern const std::string internetPkgMsg;
+
-extern const std::string tunAddressMsg;
-extern const std::string localRouteMsg;
 
 
 class SocketHandler {
@@ -23,7 +21,7 @@ private:
 public:
         void Handle(int newsock, std::string laddr, std::string raddr, int prefix);
         void RecvMessages(void);
-        void SendMessages(void);
+        void SendMessages(std::string raddr, int prefix);
 };
 
 #endif

uxclient.cpp

@@ -56,11 +56,10 @@ std::expected<void, std::string> UxClient::Connect(const std::string naddress, c
         if (inet_pton(AF_INET, addr, &serv_addr.sin_addr) <= 0) {
                 return std::unexpected("Invalid server IP address");
         }
-
+#ifdef CLI_TIMEOUT
         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);
@@ -71,6 +70,7 @@ std::expected<void, std::string> UxClient::Connect(const std::string naddress, c
                 std::string error = std::strerror(errnoCopy);
                 return std::unexpected(std::format("Set send timeout error: {}", error));
         }
+#endif
         if (connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
                 int errnoCopy = errno;
                 std::string error = std::strerror(errnoCopy);
@@ -101,17 +101,41 @@ void UxClient::RecvMessages(void) {
                         uxlogger.Log(std::format("Decode header error: {}", decodeRes.error()));
                 }
                 auto pSize = header.PayloadSize();
-                if (pSize > 0) {
+                uxlogger.Log(std::format("Receive message with size {}", pSize));
-                        std::string rawMessage(pSize, 0);
+                if (pSize == 0) {
-                        if ((rsize = recv(sock, rawMessage.data(), rawMessage.size(), MSG_WAITALL)) < 0) {
+                        continue;
-                                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));
+                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 meta;
+                meta.ParseFromString(rawMessage);
+                auto metaPart = meta.meta();
+                auto kind = metaPart.kind();
+                uxlogger.Debug(std::format("Receive message with call {}", kind));
+                if (kind == tunAddressMsg) {
+                        uxcontrol::AddressMessage addrMessage;
+                        addrMessage.ParseFromString(rawMessage);
+
+                        uxlogger.Debug(std::format("Receive address {}", addrMessage.address()));
+                        uxlogger.Debug(std::format("Receive prefix {}", addrMessage.prefix()));
+
+                        auto setAddrRes = interface.SetIP4Address(addrMessage.address());
+                        if (!setAddrRes) {
+                                uxlogger.Error(setAddrRes.error());
+                        }
+                        auto setMaskRes = interface.SetIP4Netmask(addrMessage.prefix());
+                        if (!setMaskRes) {
+                                uxlogger.Error(setMaskRes.error());
+                        }
+                } else {
+                        uxlogger.Warning("Received unknown kind of message");
+                }
         }
         done.release();
         return;
@@ -130,7 +154,7 @@ void UxClient::SendMessages(void) {
 
                 uxcontrol::PacketMessage intPacket;
                 auto meta = intPacket.mutable_meta();
-                meta->set_kind("internetPacket");
+                meta->set_kind(internetPkgMsg);
                 intPacket.set_payload(packet);
 
                 std::string rawMessage;
@@ -139,17 +163,15 @@ void UxClient::SendMessages(void) {
                 MessageHeader header(rawMessage.size());
                 auto rawHeader = header.Encode();
 
+                std::string rawPacket;
+                rawPacket.append(rawHeader);
+                rawPacket.append(rawMessage);
+
                 int wsize = 0;
-                if ((wsize = send(sock, rawHeader.data(), rawHeader.size(), 0)) < 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 header error: {}", error));
+                        uxlogger.Log(std::format("Write packet error: {}", error));
-                        break;
-                }
-                if ((wsize = send(sock, rawMessage.data(), rawMessage.size(), 0)) < 0) {
-                        int errnoCopy = errno;
-                        std::string error = std::strerror(errnoCopy);
-                        uxlogger.Log(std::format("Write message error: {}", error));
                         break;
                 }
                 uxlogger.Log("Send message");
@@ -165,14 +187,7 @@ std::expected<void, std::string> UxClient::Run(void) {
         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(30);
-        if (!setMaskRes) {
-                return std::unexpected(setMaskRes.error());
-        }
         auto setMTURes = interface.SetMTU(1280);
         if (!setMTURes) {
                 return std::unexpected(setMTURes.error());
@@ -182,12 +197,13 @@ std::expected<void, std::string> UxClient::Run(void) {
                 return std::unexpected(createRes.error());
         }
 
-        Router router;
+        /*
-        auto addRouteRes = router.AddRoute("1.1.1.2", 32, "10.1.1.2");
+                Router router;
-        if (!addRouteRes) {
+                auto addRouteRes = router.AddRoute("1.1.1.2", 32, "10.1.1.2");
-                return std::unexpected(addRouteRes.error());
+                if (!addRouteRes) {
-        }
+                        return std::unexpected(addRouteRes.error());
-
+                }
+        */
         std::thread sendThr(&UxClient::SendMessages, this);
         sendThr.detach();