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>
 
#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; }
 
    void set_port(uint16_t p) { raw.port = p; }
 
    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() {
        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]] int up(const NetIfConfig &cfg) {
        return ove_netif_up(handle_, &cfg.raw);
    }
 
    void down() {
        ove_netif_down(handle_);
    }
 
    [[nodiscard]] int get_addr(Address *ip = nullptr,
                   Address *gateway = nullptr,
                   Address *netmask = nullptr) {
        return 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() {
        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]] int connect(const Address &addr,
                  uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_socket_connect(handle_, &addr.raw, timeout_ms);
    }
 
    [[nodiscard]] int send(const void *data, size_t len,
                   size_t *sent = nullptr) {
        return ove_socket_send(handle_, data, len, sent);
    }
 
    [[nodiscard]] int recv(void *buf, size_t len,
                   size_t *received = nullptr,
                   uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_socket_recv(handle_, buf, len, received, timeout_ms);
    }
 
    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() {
        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]] int bind(const Address &addr) {
        return ove_socket_bind(handle_, &addr.raw);
    }
 
    [[nodiscard]] int send_to(const void *data, size_t len,
                  const Address &dest,
                  size_t *sent = nullptr) {
        return ove_socket_sendto(handle_, data, len, sent, &dest.raw);
    }
 
    [[nodiscard]] int recv_from(void *buf, size_t len,
                    Address *src = nullptr,
                    size_t *received = nullptr,
                    uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        return ove_socket_recvfrom(handle_, buf, len, received,
                       src ? &src->raw : nullptr,
                       timeout_ms);
    }
 
    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() {
        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]] int bind(const Address &addr) {
        return ove_socket_bind(handle_, &addr.raw);
    }
 
    [[nodiscard]] int listen(int backlog = 4) {
        return ove_socket_listen(handle_, backlog);
    }
 
    [[nodiscard]] int accept(TcpSocket &client,
                 uint32_t timeout_ms = OVE_WAIT_FOREVER) {
        ove_socket_t cli_handle{};
        ove_socket_storage_t cli_storage{};
        int err = ove_socket_accept(handle_, &cli_handle,
                        &cli_storage, timeout_ms);
        if (err == OVE_OK) {
            client.close();
            client.handle_ = cli_handle;
            client.storage_ = cli_storage;
            client.open_ = true;
        }
        return err;
    }
 
    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 int resolve(const char *hostname, Address &addr,
                 uint32_t timeout_ms = 5000) {
    return ove_dns_resolve(hostname, &addr.raw, timeout_ms);
}
 
} /* namespace dns */
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_NET */