Issue #22: Get source IP from TCP packages

Author: taketook34

src/kpi_rover_ecu/include/IClient.h

@@ -0,0 +1,25 @@
+#ifndef ICLIENT_H
+#define ICLIENT_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+class IClient {
+   protected:
+    IClient() = default;
+
+   public:
+    virtual bool Send(const std::vector<std::uint8_t>& data) = 0;
+    virtual bool Receive(std::vector<std::uint8_t>& data) = 0;
+    virtual int Init(std::string ip_address, int port) = 0;
+    virtual void Destroy() = 0;
+    virtual ~IClient() = default;
+
+    IClient(const IClient&) = delete;
+    IClient& operator=(const IClient&) = delete;
+    IClient(IClient&&) = delete;
+    IClient& operator=(IClient&&) = delete;
+};
+
+#endif

src/kpi_rover_ecu/include/IMUController.h

@@ -15,7 +15,6 @@ class IMUController {
     int Init();
     void SetEnable();
     void SetDisable();
-    bool GetEnable();
     void Stop();
     std::vector<float> GetData();
     uint8_t GetId();

src/kpi_rover_ecu/include/KPIRoverECU.h

@@ -14,7 +14,7 @@
 static constexpr std::uint32_t kTimerPrecision = 100000;   // 100 milliseconds in microsecond (for timer)
 static constexpr std::uint32_t kOneSecondMicro = 1000000;  // 1 s in microseconds
 static constexpr std::uint32_t kOneSecondMilli = 1000;     // 1 s in milliseconds
-static constexpr std::uint32_t kTimeStop = 5;              // 5 seconds
+static constexpr std::uint32_t kTimeStop = 1;              // 5 seconds
 static constexpr std::uint32_t k16MaxCount = 65535;
 
 class KPIRoverECU {

src/kpi_rover_ecu/include/TCPTransport.h

@@ -1,6 +1,7 @@
 #ifndef TCPTRANSPORT_H
 #define TCPTRANSPORT_H
 
+#include <arpa/inet.h>
 #include <atomic>
 #include <cstdint>
 #include <cstring>
@@ -28,9 +29,14 @@ class TCPTransport : public ITransport {
     int Init() override;
     void Destroy() override;
 
+    std::string GetSourceIp();
+    int GetSourcePort();
+
    private:
     int sockfd_, client_sockfd_;
     char* server_address_;
+    char source_address_[INET_ADDRSTRLEN];
+    int source_port_;
     int server_portnum_;
     std::atomic<bool> running_;
     std::thread acceptThread_;

src/kpi_rover_ecu/include/UDPClient.h

@@ -5,31 +5,31 @@
 #include <netinet/in.h>
 
 #include <cstdint>
+#include <string>
 #include <vector>
 
-#include "ITransport.h"
+#include "IClient.h"
 
-class UDPClient : public ITransport {
+class UDPClient : public IClient {
    public:
-    UDPClient(const char* ip_address, int port);
+    UDPClient();
 
     UDPClient(const UDPClient&) = delete;
     UDPClient& operator=(const UDPClient&) = delete;
     UDPClient(UDPClient&&) = delete;
     UDPClient& operator=(UDPClient&&) = delete;
 
-    int Init() override;
+    int Init(std::string ip_address, int port) override;
     bool Send(const std::vector<std::uint8_t>& data) override;
     bool Receive(std::vector<std::uint8_t>& data) override;
-    void Start() override;
     void Destroy() override;
     ~UDPClient() override;
 
    private:
     int sockfd_;
     sockaddr_in serverStruct_;
-    char* server_address_;
-    int client_portnum_;
+    char server_address_[INET_ADDRSTRLEN];
+    int server_portnum_;
 };
 
 #endif

src/kpi_rover_ecu/src/IMUController.cpp

@@ -28,8 +28,6 @@ void IMUController::SetEnable() { isStarted_ = true; }
 
 void IMUController::SetDisable() { isStarted_ = false; }
 
-bool IMUController::GetEnable() { return isStarted_; }
-
 std::vector<float> IMUController::GetData() {
     if (!isStarted_) {
         return {};

src/kpi_rover_ecu/src/KPIRoverECU.cpp

@@ -40,14 +40,25 @@ bool KPIRoverECU::Start() {
 void KPIRoverECU::IMUThreadFucntion(IMUController *workClass) {
     uint16_t packet_number = 0;
 
+    std::string destination_address = "";
+    int destination_port = 0;
+
+    while (destination_address.empty()) {
+        destination_address = tcp_transport_->GetSourceIp();
+        destination_port = tcp_transport_->GetSourcePort();
+    }
+
+    udp_client_->Init(destination_address, destination_port);
+
     while (runningProcess_) {
-        if (workClass->GetEnable()) {
+        const std::vector<float> kImuData = workClass->GetData();
+        if (!kImuData.empty()) {
             if (packet_number == k16MaxCount) {
                 packet_number = 0;
             }
             packet_number += 1;
 
-            const std::vector<float> kImuData = workClass->GetData();
+            //std::cout << "Client connected " << tcp_transport_->GetSourceIp() << ":" << tcp_transport_->GetSourcePort() << '!' << '\n';
             std::vector<uint8_t> send_val;
             send_val.push_back(workClass->GetId());
 
@@ -102,9 +113,7 @@ void KPIRoverECU::ProcessingThreadFunction() {
     while (runningProcess_) {
         std::vector<uint8_t> message;
         if (tcp_transport_->Receive(message)) {
-            if (!imu_controller_->GetEnable()) {
-                imu_controller_->SetEnable();
-            }
+            imu_controller_->SetEnable();
 
             counter_.store(GetCounter());
             const std::vector<uint8_t> kReturnMessage = protocol_handler_->HandleMessage(message);

src/kpi_rover_ecu/src/TCPTransport.cpp

@@ -20,7 +20,8 @@ TCPTransport::TCPTransport(const char *ip_address, int port)
       client_sockfd_(-1),
       server_portnum_(port),
       running_(true),
-      server_address_(new char[strlen(ip_address) + 1]) {
+      server_address_(new char[strlen(ip_address) + 1]),
+      source_port_(-1) {
     strncpy(server_address_, ip_address, strlen(ip_address) + 1);
 }
 
@@ -38,6 +39,7 @@ TCPTransport::~TCPTransport() {
 int TCPTransport::Init() {
     struct sockaddr_in serv_addr = {};
     int reuseaddr = 1;
+    source_address_[0] = '\0';
 
     sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
 
@@ -73,11 +75,16 @@ int TCPTransport::Init() {
 
 void TCPTransport::Start() {
     acceptThread_ = std::thread([this]() {
+        struct sockaddr_in client_addr;
+        socklen_t client_add_size = sizeof(client_addr);
+
         while (running_) {
             std::cout << "Waiting for connection..." << '\n';
-            client_sockfd_ = accept(sockfd_, nullptr, nullptr);
+            client_sockfd_ = accept(sockfd_, reinterpret_cast<sockaddr*>(&client_addr), &client_add_size);
             if (client_sockfd_ >= 0) {
-                std::cout << "Client connected." << '\n';
+                inet_ntop(AF_INET, &client_addr.sin_addr, source_address_, INET_ADDRSTRLEN);
+                source_port_ = static_cast<int>(ntohs(client_addr.sin_port));
+                //std::cout << "Client connected " << source_address_ << ":" << ntohs(client_addr.sin_port) << '\n';
                 while (true) {  // Use true instead of 1
                     std::uint8_t buffer[kBufferSize];
                     const ssize_t kBytesReceived = recv(client_sockfd_, buffer, sizeof(buffer), 0);
@@ -105,6 +112,10 @@ bool TCPTransport::Send(const std::vector<std::uint8_t> &data) {
 
 bool TCPTransport::Receive(std::vector<std::uint8_t> &data) { return messageQueue_.Pop(data, kTimeoutMs); }
 
+std::string TCPTransport::GetSourceIp() { return std::string(source_address_); }
+
+int TCPTransport::GetSourcePort() { return source_port_; }
+
 void TCPTransport::Destroy() {
     running_ = false;
     shutdown(sockfd_, SHUT_RDWR);

src/kpi_rover_ecu/src/UDPClient.cpp

@@ -10,16 +10,18 @@
 #include <cstdio>
 #include <cstring>
 #include <iostream>
+#include <string>
 #include <vector>
 
-UDPClient::UDPClient(const char *ip_address, int port)
-    : sockfd_(-1), client_portnum_(port), server_address_(new char[strlen(ip_address) + 1]) {
-    strncpy(server_address_, ip_address, strlen(ip_address) + 1);
-}
+UDPClient::UDPClient()
+    : sockfd_(-1), server_portnum_(0), server_address_({0}) {}
+
+int UDPClient::Init(std::string ip_address, int port) {
+    std::strncpy(server_address_, ip_address.c_str(), INET_ADDRSTRLEN);
+    server_address_[INET_ADDRSTRLEN - 1] = '\0';
 
-void UDPClient::Start() {}
+    server_portnum_ = port;
 
-int UDPClient::Init() {
     std::cout << "initialize socket" << '\n';
     sockfd_ = socket(AF_INET, SOCK_DGRAM, 0);
     if (sockfd_ == -1) {
@@ -30,7 +32,7 @@ int UDPClient::Init() {
     memset(&serverStruct_, 0, sizeof(serverStruct_));
     serverStruct_.sin_family = AF_INET;
     serverStruct_.sin_addr.s_addr = inet_addr(server_address_);  // Server IP address (localhost)
-    serverStruct_.sin_port = htons(client_portnum_);
+    serverStruct_.sin_port = htons(server_portnum_);
 
     return 0;
 }

src/kpi_rover_ecu/src/main.cpp

@@ -86,9 +86,9 @@ int main(int argc, char* argv[]) {
     }
 
     TCPTransport tcp_transport(server_address, server_portnum);
-    UDPClient udp_client(udp_server_address, udp_server_portnum);
+    UDPClient udp_client;
 
-    if (tcp_transport.Init() == -1 || udp_client.Init() == -1) {
+    if (tcp_transport.Init() == -1) {
         std::cout << "[ERROR] Error creating socket" << '\n';
         tcp_transport.Destroy();
         udp_client.Destroy();