net.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/net.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
#ifdef CONFIG_OVE_NET
 
namespace ove
{
 
/* ── Address (value type, copyable) ─────────────────────────────── */
 
class Address
{
      public:
    Address() : raw{}
    {
    }
 
    static Address ipv4(uint8_t a, uint8_t b, uint8_t c, uint8_t d, uint16_t port)
    {
        Address addr;
        ove_sockaddr_ipv4(&addr.raw, a, b, c, d, port);
        return addr;
    }
 
    uint16_t port() const
    {
        return raw.port;
    }
 
    Address &set_port(uint16_t p)
    {
        raw.port = p;
        return *this;
    }
 
    ove_sockaddr_t raw;
};
 
/* ── NetIfConfig (builder, copyable) ────────────────────────────── */
 
class NetIfConfig
{
      public:
    NetIfConfig() : raw{}
    {
    }
 
    NetIfConfig &static_ip(const Address &ip, const Address &mask, const Address &gw)
    {
        raw.use_dhcp = 0;
        raw.static_ip = ip.raw;
        raw.netmask = mask.raw;
        raw.gateway = gw.raw;
        return *this;
    }
 
    NetIfConfig &dhcp()
    {
        raw.use_dhcp = 1;
        return *this;
    }
 
    NetIfConfig &dns(const Address &d)
    {
        raw.dns = d.raw;
        return *this;
    }
 
    ove_netif_config_t raw;
};
 
/* ── NetIf (RAII network interface) ─────────────────────────────── */
 
class NetIf
{
      public:
    NetIf()
    {
        int err = ove_netif_init(&handle_, &storage_);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~NetIf() noexcept
    {
        if (!handle_)
            return;
        ove_netif_deinit(handle_);
    }
 
    NetIf(const NetIf &) = delete;
    NetIf &operator=(const NetIf &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    NetIf(NetIf &&) = delete;
    NetIf &operator=(NetIf &&) = delete;
#else
    NetIf(NetIf &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    NetIf &operator=(NetIf &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_netif_deinit(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] Result<void> up(const NetIfConfig &cfg) noexcept
    {
        return from_rc(ove_netif_up(handle_, &cfg.raw));
    }
 
    void down()
    {
        ove_netif_down(handle_);
    }
 
    [[nodiscard]] Result<void> get_addr(Address *ip = nullptr, Address *gateway = nullptr,
                        Address *netmask = nullptr) noexcept
    {
        return from_rc(ove_netif_get_addr(handle_, ip ? &ip->raw : nullptr,
                          gateway ? &gateway->raw : nullptr,
                          netmask ? &netmask->raw : nullptr));
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_netif_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_netif_t handle_{};
    ove_netif_storage_t storage_{};
};
 
/* ── Forward declaration for friend access ──────────────────────── */
 
class TcpListener;
 
/* ── TcpSocket (RAII TCP socket) ────────────────────────────────── */
 
class TcpSocket
{
      public:
    TcpSocket()
    {
        int err = ove_socket_open(&handle_, &storage_, OVE_AF_INET, OVE_SOCK_STREAM);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
        open_ = true;
    }
 
    ~TcpSocket() noexcept
    {
        if (open_)
            ove_socket_close(handle_);
    }
 
    TcpSocket(const TcpSocket &) = delete;
    TcpSocket &operator=(const TcpSocket &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    TcpSocket(TcpSocket &&) = delete;
    TcpSocket &operator=(TcpSocket &&) = delete;
#else
    TcpSocket(TcpSocket &&other) noexcept
        : handle_(other.handle_), storage_(other.storage_), open_(other.open_)
    {
        other.handle_ = nullptr;
        other.open_ = false;
    }
 
    TcpSocket &operator=(TcpSocket &&other) noexcept
    {
        if (this != &other) {
            if (open_)
                ove_socket_close(handle_);
            handle_ = other.handle_;
            storage_ = other.storage_;
            open_ = other.open_;
            other.handle_ = nullptr;
            other.open_ = false;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] Result<void> connect(const Address &addr,
                       std::chrono::nanoseconds timeout = wait_forever) noexcept
    {
        return from_rc(ove_socket_connect(handle_, &addr.raw, to_timeout_ns(timeout)));
    }
 
    [[nodiscard]] Result<size_t> send(const void *data, size_t len) noexcept
    {
        size_t sent = 0;
        const int rc = ove_socket_send(handle_, data, len, &sent);
        return from_rc(rc, sent);
    }
 
    [[nodiscard]] Result<size_t> recv(void *buf, size_t len,
                      std::chrono::nanoseconds timeout = wait_forever) noexcept
    {
        size_t received = 0;
        const int rc =
            ove_socket_recv(handle_, buf, len, &received, to_timeout_ns(timeout));
        return from_rc(rc, received);
    }
 
    void close()
    {
        if (open_) {
            ove_socket_close(handle_);
            open_ = false;
        }
    }
 
    bool is_open() const
    {
        return open_;
    }
 
    ove_socket_t handle() const
    {
        return handle_;
    }
 
      private:
    friend class TcpListener;
 
    TcpSocket(ove_socket_t h, ove_socket_storage_t s) : handle_(h), storage_(s), open_(true)
    {
    }
 
    ove_socket_t handle_{};
    ove_socket_storage_t storage_{};
    bool open_{false};
};
 
/* ── UdpSocket (RAII UDP socket) ────────────────────────────────── */
 
class UdpSocket
{
      public:
    UdpSocket()
    {
        int err = ove_socket_open(&handle_, &storage_, OVE_AF_INET, OVE_SOCK_DGRAM);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
        open_ = true;
    }
 
    ~UdpSocket() noexcept
    {
        if (open_)
            ove_socket_close(handle_);
    }
 
    UdpSocket(const UdpSocket &) = delete;
    UdpSocket &operator=(const UdpSocket &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    UdpSocket(UdpSocket &&) = delete;
    UdpSocket &operator=(UdpSocket &&) = delete;
#else
    UdpSocket(UdpSocket &&other) noexcept
        : handle_(other.handle_), storage_(other.storage_), open_(other.open_)
    {
        other.handle_ = nullptr;
        other.open_ = false;
    }
 
    UdpSocket &operator=(UdpSocket &&other) noexcept
    {
        if (this != &other) {
            if (open_)
                ove_socket_close(handle_);
            handle_ = other.handle_;
            storage_ = other.storage_;
            open_ = other.open_;
            other.handle_ = nullptr;
            other.open_ = false;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] Result<void> bind(const Address &addr) noexcept
    {
        return from_rc(ove_socket_bind(handle_, &addr.raw));
    }
 
    [[nodiscard]] Result<size_t> send_to(const void *data, size_t len,
                         const Address &dest) noexcept
    {
        size_t sent = 0;
        const int rc = ove_socket_sendto(handle_, data, len, &sent, &dest.raw);
        return from_rc(rc, sent);
    }
 
    [[nodiscard]] Result<size_t>
    recv_from(void *buf, size_t len, Address *src = nullptr,
          std::chrono::nanoseconds timeout = wait_forever) noexcept
    {
        size_t received = 0;
        const int rc = ove_socket_recvfrom(handle_, buf, len, &received,
                           src ? &src->raw : nullptr,
                           to_timeout_ns(timeout));
        return from_rc(rc, received);
    }
 
    void close()
    {
        if (open_) {
            ove_socket_close(handle_);
            open_ = false;
        }
    }
 
    bool is_open() const
    {
        return open_;
    }
 
    ove_socket_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_socket_t handle_{};
    ove_socket_storage_t storage_{};
    bool open_{false};
};
 
/* ── TcpListener (RAII listening socket) ────────────────────────── */
 
class TcpListener
{
      public:
    TcpListener()
    {
        int err = ove_socket_open(&handle_, &storage_, OVE_AF_INET, OVE_SOCK_STREAM);
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
        open_ = true;
    }
 
    ~TcpListener() noexcept
    {
        if (open_)
            ove_socket_close(handle_);
    }
 
    TcpListener(const TcpListener &) = delete;
    TcpListener &operator=(const TcpListener &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    TcpListener(TcpListener &&) = delete;
    TcpListener &operator=(TcpListener &&) = delete;
#else
    TcpListener(TcpListener &&other) noexcept
        : handle_(other.handle_), storage_(other.storage_), open_(other.open_)
    {
        other.handle_ = nullptr;
        other.open_ = false;
    }
 
    TcpListener &operator=(TcpListener &&other) noexcept
    {
        if (this != &other) {
            if (open_)
                ove_socket_close(handle_);
            handle_ = other.handle_;
            storage_ = other.storage_;
            open_ = other.open_;
            other.handle_ = nullptr;
            other.open_ = false;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] Result<void> bind(const Address &addr) noexcept
    {
        return from_rc(ove_socket_bind(handle_, &addr.raw));
    }
 
    [[nodiscard]] Result<void> listen(int backlog = 4) noexcept
    {
        return from_rc(ove_socket_listen(handle_, backlog));
    }
 
    [[nodiscard]] Result<void> accept(TcpSocket &client,
                      std::chrono::nanoseconds timeout = wait_forever) noexcept
    {
        ove_socket_t cli_handle{};
        ove_socket_storage_t cli_storage{};
        const int rc = ove_socket_accept(handle_, &cli_handle, &cli_storage,
                         to_timeout_ns(timeout));
        if (rc == OVE_OK) {
            client.close();
            client.handle_ = cli_handle;
            client.storage_ = cli_storage;
            client.open_ = true;
        }
        return from_rc(rc);
    }
 
    void close()
    {
        if (open_) {
            ove_socket_close(handle_);
            open_ = false;
        }
    }
 
    bool is_open() const
    {
        return open_;
    }
 
    ove_socket_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_socket_t handle_{};
    ove_socket_storage_t storage_{};
    bool open_{false};
};
 
/* ── DNS ────────────────────────────────────────────────────────── */
 
namespace dns
{
 
[[nodiscard]] inline Result<Address>
resolve(const char *hostname, std::chrono::nanoseconds timeout = std::chrono::seconds{5}) noexcept
{
    Address addr;
    const int rc = ove_dns_resolve(hostname, &addr.raw, to_timeout_ns(timeout));
    return from_rc(rc, addr);
}
 
} /* namespace dns */
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_NET */