Exploration

apps/gnb/gnb.cpp

@@ -64,6 +64,16 @@
 #include "srsran/support/tracing/event_tracing.h"
 #include "srsran/support/versioning/build_info.h"
 #include "srsran/support/versioning/version.h"
+#include <thread>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <fstream>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include "srsran/adt/byte_buffer.h"
+#include "srsran/adt/span.h"
 #include <atomic>
 #ifdef DPDK_FOUND
 #include "srsran/hal/dpdk/dpdk_eal_factory.h"
@@ -196,6 +206,122 @@ static void autoderive_cu_up_parameters_after_parsing(cu_up_unit_config& cu_up_c
   }
 }
 
+void start_tcp_control_server(srsran::srs_cu_cp::ngap_interface* ngap, srslog::basic_logger& gnb_logger)
+{
+  std::thread server_thread([=, &gnb_logger]() {
+    int server_fd, new_socket;
+    struct sockaddr_in address;
+    int addrlen = sizeof(address);
+    char buffer[4096] = {0};
+
+    server_fd = socket(AF_INET, SOCK_STREAM, 0);
+    if (server_fd == 0) {
+      gnb_logger.error("TCP server: Failed to create socket");
+      return;
+    }
+
+    int opt = 1;
+    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+    address.sin_family = AF_INET;
+    address.sin_addr.s_addr = INADDR_ANY;
+    address.sin_port = htons(8899);
+
+    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
+      gnb_logger.error("TCP server: Bind failed");
+      close(server_fd);
+      return;
+    }
+
+    if (listen(server_fd, 3) < 0) {
+      gnb_logger.error("TCP server: Listen failed");
+      close(server_fd);
+      return;
+    }
+
+    gnb_logger.info("TCP server started on port 8899. Use 'telnet 127.0.0.1 8899' to send commands.");
+
+    while (true) {
+      new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
+      if (new_socket < 0) {
+        gnb_logger.error("TCP server: Accept failed");
+        continue;
+      }
+
+      ssize_t read_size;
+      while ((read_size = read(new_socket, buffer, sizeof(buffer) - 1)) > 0) {
+        buffer[read_size] = '\0';
+        std::string line(buffer);
+        std::istringstream iss(line);
+        std::string command;
+        iss >> command;
+        if (command == "send") {
+          std::vector<uint8_t> bytes;
+          std::string byte_str;
+          while (iss >> byte_str) {
+            try {
+              uint8_t byte = static_cast<uint8_t>(std::stoul(byte_str, nullptr, 16));
+              bytes.push_back(byte);
+            } catch (const std::exception& e) {
+              gnb_logger.error("Parse error '{}': {}", byte_str, e.what());
+            }
+          }
+
+          if (bytes.empty()) {
+            gnb_logger.error("No valid bytes received for send");
+            continue;
+          }
+
+          srsran::byte_buffer buf;
+          span<const uint8_t> bytes_view(bytes.data(), bytes.size());
+          if (not buf.append(bytes_view)) {
+            gnb_logger.error("Failed to build byte_buffer");
+            continue;
+          }
+
+          if (ngap->send_custom_pdu(std::move(buf))) {
+            gnb_logger.info("Sent dynamic NGAP packet ({} bytes)", bytes.size());
+          } else {
+            gnb_logger.error("Failed to send dynamic NGAP packet");
+          }
+        } else if (command == "sendfile") {
+          std::string filepath;
+          iss >> filepath;
+          if (filepath.empty()) {
+            gnb_logger.error("No filepath provided");
+            continue;
+          }
+          std::ifstream file(filepath, std::ios::binary);
+          if (!file.is_open()) {
+            gnb_logger.error("Failed to open file '{}'", filepath);
+            continue;
+          }
+          std::vector<uint8_t> bytes((std::istreambuf_iterator<char>(file)),
+                                      std::istreambuf_iterator<char>());
+
+          srsran::byte_buffer buf;
+          span<const uint8_t> bytes_view(bytes.data(), bytes.size());
+          if (not buf.append(bytes_view)) {
+            gnb_logger.error("Failed to build byte_buffer from file");
+            continue;
+          }
+
+          if (ngap->send_custom_pdu(std::move(buf))) {
+            gnb_logger.info("Sent NGAP packet from file '{}' ({} bytes)", filepath, bytes.size());
+          } else {
+            gnb_logger.error("Failed to send NGAP packet from file");
+          }
+        } else {
+          gnb_logger.error("Unknown command '{}'", command);
+        }
+      }
+      close(new_socket);
+    }
+  });
+  server_thread.detach();
+}
+
+
 int main(int argc, char** argv)
 {
   // Set the application error handler.
@@ -495,6 +621,49 @@ int main(int argc, char** argv)
     report_error("CU-CP failed to connect to AMF");
   }
 
+  auto my_plmn_expected = srsran::plmn_identity::parse("00101");
+
+  if (my_plmn_expected.has_value()) {
+    plmn_identity my_plmn = my_plmn_expected.value();
+
+    // Get NGAP notifier
+    srsran::srs_cu_cp::ngap_interface* ngap = o_cucp_obj.get_cu_cp().find_ngap_by_plmn(my_plmn);
+
+    if (ngap != nullptr) {
+      gnb_logger.info("Connected to AMF. Ready to send packets.");
+
+      start_tcp_control_server(ngap, gnb_logger);
+
+      /*
+      // Example fake NGAP packet (not real ASN.1, just for testing transmission)
+      std::vector<uint8_t> my_raw_bytes = {
+        0x00, 0x08, // Message Length (fake)
+        0x00, 0x01, // NGAP Procedure Code (fake)
+        0x01, 0x00, // Criticality (fake)
+        0x02, 0x00, // Some Information Element (fake)
+        0x03, 0x04  // Some other field (fake)
+      };
+
+      span<const uint8_t> bytes_view(my_raw_bytes.data(), my_raw_bytes.size());
+      byte_buffer my_custom_buffer;
+
+      if (not my_custom_buffer.append(bytes_view)) {
+        gnb_logger.error("Failed to build byte_buffer from custom raw bytes");
+      }
+
+      bool success = ngap->send_custom_pdu(std::move(my_custom_buffer));
+      if (success) {
+          gnb_logger.info("Successfully sent custom NGAP PDU");
+      } else {
+          gnb_logger.error("Failed to send custom NGAP PDU");
+      }*/
+    } else {
+      gnb_logger.info("NGAP interface is not ready");
+    }
+  } else {
+    gnb_logger.info("Failed to parse PLMN identity");
+  }
+
   // Connect F1-C to O-CU-CP and start listening for new F1-C connection requests.
   f1c_gw->attach_cu_cp(o_cucp_obj.get_cu_cp().get_f1c_handler());