Allows to use IPv6 addresses for UE to gNB link

src/gnb.cpp

@@ -48,7 +48,7 @@ static nr::gnb::GnbConfig *ReadConfigYaml()
     result->gnbIdLength = yaml::GetInt32(config, "idLength", 22, 32);
     result->tac = yaml::GetInt32(config, "tac", 0, 0xFFFFFF);
 
-    result->portalIp = yaml::GetIp4(config, "linkIp");
+    result->portalIp = yaml::GetIp(config, "linkIp");
     result->ngapIp = yaml::GetIp4(config, "ngapIp");
     result->gtpIp = yaml::GetIp4(config, "gtpIp");
 

src/lib/udp/server.cpp

@@ -9,31 +9,50 @@
 #include "server.hpp"
 
 #include <cstring>
+#include <utils/common.hpp>
 
 namespace udp
 {
 
-UdpServer::UdpServer() : socket{Socket::CreateUdp4()}
+UdpServer::UdpServer(): sockets{}
 {
+    sockets.push_back(Socket::CreateUdp6());
+    sockets.push_back(Socket::CreateUdp4());
 }
 
-UdpServer::UdpServer(const std::string &address, uint16_t port) : socket{Socket::CreateAndBindUdp({address, port})}
+UdpServer::UdpServer(const std::string &address, uint16_t port): sockets{}
 {
+    sockets.push_back(Socket::CreateAndBindUdp({address, port}));
 }
 
-int UdpServer::Receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddress &outPeerAddress) const
+int UdpServer::Receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddress &outPeerAddress)
 {
-    return socket.receive(buffer, bufferSize, timeoutMs, outPeerAddress);
+    // Use the first socket ready for receiving data
+    // Warning: this may lead to starvation since there is no round robin implemented yet in `Socket::Select`
+    std::vector<Socket> ws;
+    return Socket::Select(sockets, ws, timeoutMs).receive(buffer, bufferSize, 0, outPeerAddress);
 }
 
-void UdpServer::Send(const InetAddress &address, const uint8_t *buffer, size_t bufferSize) const
+int UdpServer::Send(const InetAddress &address, const uint8_t *buffer, size_t bufferSize) const
 {
-    socket.send(address, buffer, bufferSize);
+    int version = address.getIpVersion();
+    // invalid family
+    if (!version)
+        return -1;
+    // send on first socket matching ip version
+    for(const Socket &s : sockets)
+    {
+        if (s.getIpVersion() == version)
+            return s.send(address, buffer, bufferSize);
+    }
+    // no socket found
+    return -1;
 }
 
 UdpServer::~UdpServer()
 {
-    socket.close();
+    for (Socket &s : sockets)
+        s.close();
 }
 
 } // namespace udp

src/lib/udp/server.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <string>
+#include <unistd.h>
 
 #include <utils/network.hpp>
 
@@ -18,15 +19,15 @@ namespace udp
 class UdpServer
 {
   private:
-    Socket socket;
+    std::vector<Socket> sockets;
 
   public:
     UdpServer();
     UdpServer(const std::string &address, uint16_t port);
     ~UdpServer();
 
-    int Receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddress &outPeerAddress) const;
-    void Send(const InetAddress &address, const uint8_t *buffer, size_t bufferSize) const;
+    int Receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddress &outPeerAddress);
+    int Send(const InetAddress &address, const uint8_t *buffer, size_t bufferSize) const;
 };
 
 } // namespace udp

src/utils/io.cpp

@@ -219,6 +219,36 @@ std::string GetIp4OfInterface(const std::string &ifName)
     return std::string{str};
 }
 
+std::string GetIp6OfInterface(const std::string &ifName)
+{
+    std::string res;
+
+    struct ifreq ifr = {};
+
+    int fd = socket(AF_INET6, SOCK_DGRAM, 0);
+    if (fd <= 0)
+        return "";
+
+    ifr.ifr_addr.sa_family = AF_INET6;
+    strncpy(ifr.ifr_name, ifName.c_str(), IFNAMSIZ - 1);
+
+    if (ioctl(fd, SIOCGIFADDR, &ifr))
+    {
+        close(fd);
+        return "";
+    }
+
+    close(fd);
+
+    auto address = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
+
+    char str[INET6_ADDRSTRLEN] = {0};
+    if (inet_ntop(AF_INET6, &address, str, INET6_ADDRSTRLEN) == nullptr)
+        return "";
+
+    return std::string{str};
+}
+
 std::string GetHostByName(const std::string &name)
 {
     struct addrinfo hints = {};

src/utils/io.hpp

@@ -42,6 +42,8 @@ void AppendPath(std::string &source, const std::string &target);
 
 std::string GetIp4OfInterface(const std::string &ifName);
 
+std::string GetIp6OfInterface(const std::string &ifName);
+
 std::string GetHostByName(const std::string& name);
 
 } // namespace io

src/utils/network.cpp

@@ -78,7 +78,7 @@ InetAddress::InetAddress(const std::string &address, uint16_t port) : storage{},
     if (s != 0)
         throw LibError("Bad Inet address: " + address, errno);
 
-    if (result->ai_family != AF_INET && result->ai_family == AF_INET6)
+    if (result->ai_family != AF_INET && result->ai_family != AF_INET6)
     {
         freeaddrinfo(result);
         throw std::runtime_error("Bad Inet address: " + address);
@@ -89,6 +89,16 @@ InetAddress::InetAddress(const std::string &address, uint16_t port) : storage{},
     freeaddrinfo(result);
 }
 
+int InetAddress::getIpVersion() const
+{
+    if (storage.ss_family == AF_INET)
+        return 4;
+    else if (storage.ss_family == AF_INET6)
+        return 6;
+    else
+        return 0;
+}
+
 InetAddress::InetAddress(const OctetString &address, uint16_t port) : InetAddress(OctetStringToIpString(address), port)
 {
 }
@@ -111,6 +121,7 @@ uint16_t InetAddress::getPort() const
 Socket::Socket(int domain, int type, int protocol)
 {
     int sd = socket(domain, type, protocol);
+    socketDomain = domain;
     if (sd < 0)
         throw LibError("Socket could not be created:", errno);
     this->fd = sd;
@@ -185,7 +196,7 @@ int Socket::receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddre
     return 0;
 }
 
-void Socket::send(const InetAddress &address, const uint8_t *buffer, size_t size) const
+int Socket::send(const InetAddress &address, const uint8_t *buffer, size_t size) const
 {
     ssize_t rc = sendto(fd, buffer, size, MSG_DONTWAIT, address.getSockAddr(), address.getSockLen());
     if (rc == -1)
@@ -194,6 +205,7 @@ void Socket::send(const InetAddress &address, const uint8_t *buffer, size_t size
         if (err != EAGAIN)
             throw LibError("sendto failed: ", errno);
     }
+    return rc;
 }
 
 bool Socket::hasFd() const
@@ -297,3 +309,13 @@ InetAddress Socket::getAddress() const
 
     return InetAddress(storage, len);
 }
+
+int Socket::getIpVersion() const
+{
+    if (socketDomain == AF_INET6)
+        return 6;
+    else if (socketDomain == AF_INET)
+        return 4;
+    else
+        return 0;
+}

src/utils/network.hpp

@@ -38,6 +38,7 @@ struct InetAddress
         return len;
     }
 
+    [[nodiscard]] int getIpVersion() const;
     [[nodiscard]] uint16_t getPort() const;
 };
 
@@ -45,6 +46,7 @@ class Socket
 {
   private:
     int fd;
+    int socketDomain;
 
   public:
     Socket();
@@ -53,10 +55,11 @@ class Socket
   public:
     void bind(const InetAddress &address) const;
     int receive(uint8_t *buffer, size_t bufferSize, int timeoutMs, InetAddress &outAddress) const;
-    void send(const InetAddress &address, const uint8_t *buffer, size_t size) const;
+    int send(const InetAddress &address, const uint8_t *buffer, size_t size) const;
     void close();
     [[nodiscard]] bool hasFd() const;
     [[nodiscard]] InetAddress getAddress() const;
+    [[nodiscard]] int getIpVersion() const;
 
     /* Socket options */
     void setReuseAddress() const;

src/utils/yaml_utils.cpp

@@ -158,6 +158,24 @@ std::string GetIp4(const YAML::Node &node, const std::string &name)
     return ipFromIf;
 }
 
+
+std::string GetIp(const YAML::Node &node, const std::string & name)
+{
+    std::string s = GetString(node, name);
+
+    int version = utils::GetIpVersion(s);
+    if (version == 6 || version == 4)
+        return s;
+    auto ip4FromIf = io::GetIp4OfInterface(s);
+    if (!ip4FromIf.empty())
+        return ip4FromIf;
+    auto ip6FromIf = io::GetIp6OfInterface(s);
+    if (!ip6FromIf.empty())
+        return ip6FromIf;
+    FieldError(name, "must be a valid IP address or a valid network interface with an IP address");
+
+}
+
 void AssertHasBool(const YAML::Node &node, const std::string &name)
 {
     AssertHasField(node, name);

src/utils/yaml_utils.hpp

@@ -42,6 +42,7 @@ std::string GetString(const YAML::Node &node, const std::string &name, std::opti
                       std::optional<int> maxLength);
 
 std::string GetIp4(const YAML::Node &node, const std::string &name);
+std::string GetIp(const YAML::Node &node, const std::string &name);
 
 bool GetBool(const YAML::Node &node, const std::string &name);