net_httpd.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_httpd.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
#include <string_view>
 
#ifdef CONFIG_OVE_NET_HTTPD
 
namespace ove
{
 
namespace httpd
{
 
class Request
{
      public:
    explicit Request(ove_httpd_req_t *raw) : raw_(raw)
    {
    }
 
    Request(const Request &) = delete;
    Request &operator=(const Request &) = delete;
    Request(Request &&) = delete;
    Request &operator=(Request &&) = delete;
 
    const char *method() const
    {
        return ove_httpd_req_method(raw_);
    }
 
    const char *path() const
    {
        return ove_httpd_req_path(raw_);
    }
 
    const char *query() const
    {
        return ove_httpd_req_query(raw_);
    }
 
    const char *body() const
    {
        return ove_httpd_req_body(raw_);
    }
 
    size_t body_len() const
    {
        return ove_httpd_req_body_len(raw_);
    }
 
    const char *segment(int idx) const
    {
        return ove_httpd_req_segment(raw_, idx);
    }
 
    ove_httpd_req_t *raw() const
    {
        return raw_;
    }
 
      private:
    ove_httpd_req_t *raw_;
};
 
class Response
{
      public:
    explicit Response(ove_httpd_resp_t *raw) : raw_(raw)
    {
    }
 
    Response(const Response &) = delete;
    Response &operator=(const Response &) = delete;
    Response(Response &&) = delete;
    Response &operator=(Response &&) = delete;
 
    [[nodiscard]] Result<void> json(int status, const char *json) noexcept
    {
        return from_rc(ove_httpd_resp_json(raw_, status, json));
    }
 
    [[nodiscard]] Result<void> html(int status, const char *html, size_t len) noexcept
    {
        return from_rc(ove_httpd_resp_html(raw_, status, html, len));
    }
 
    [[nodiscard]] Result<void> send(int status, const char *content_type, const void *body,
                    size_t len) noexcept
    {
        return from_rc(ove_httpd_resp_send(raw_, status, content_type, body, len));
    }
 
    [[nodiscard]] Result<void> send_gz(int status, const char *content_type, const void *body,
                       size_t len) noexcept
    {
        return from_rc(ove_httpd_resp_send_gz(raw_, status, content_type, body, len));
    }
 
    [[nodiscard]] Result<void> error(int status, const char *msg) noexcept
    {
        return from_rc(ove_httpd_resp_error(raw_, status, msg));
    }
 
    ove_httpd_resp_t *raw() const
    {
        return raw_;
    }
 
      private:
    ove_httpd_resp_t *raw_;
};
 
using Handler = ove_httpd_handler_t;
 
struct Config {
    uint16_t port{80};   
    int max_body_size{1024}; 
};
 
[[nodiscard]] inline Result<void> start(const Config &cfg = {}) noexcept
{
    ove_httpd_config_t c{cfg.port, cfg.max_body_size};
    return from_rc(ove_httpd_start(&c));
}
 
inline void stop()
{
    ove_httpd_stop();
}
 
[[nodiscard]] inline Result<void> route(const char *method, const char *path,
                    Handler handler) noexcept
{
    return from_rc(ove_httpd_route(method, path, handler));
}
 
inline void register_builtin_routes()
{
    ove_httpd_register_builtin_routes();
}
 
inline void set_netif(ove_netif_t netif)
{
    ove_httpd_set_netif(netif);
}
 
#ifdef CONFIG_OVE_AUDIO
inline void set_audio_graph(struct ove_audio_graph *g)
{
    ove_httpd_set_audio_graph(g);
}
#endif
 
#ifdef CONFIG_OVE_INFER
inline void set_model(ove_model_t model)
{
    ove_httpd_set_model(model);
}
#endif
 
} /* namespace httpd */
 
#ifdef CONFIG_OVE_NET_HTTPD_WS
 
namespace ws
{
 
class Connection
{
      public:
    explicit Connection(ove_httpd_ws_conn_t *raw) : raw_(raw)
    {
    }
 
    [[nodiscard]] Result<void> send(const void *data, size_t len) noexcept
    {
        return from_rc(ove_httpd_ws_send(raw_, data, len));
    }
 
    [[nodiscard]] Result<void> send(std::string_view sv) noexcept
    {
        return from_rc(ove_httpd_ws_send(raw_, sv.data(), sv.size()));
    }
 
    ove_httpd_ws_conn_t *raw() const
    {
        return raw_;
    }
 
      private:
    ove_httpd_ws_conn_t *raw_;
};
 
using Handler = ove_httpd_ws_handler_t;
 
using CloseHandler = ove_httpd_ws_close_handler_t;
 
[[nodiscard]] inline Result<void> route(const char *path, Handler on_message,
                    CloseHandler on_close = nullptr) noexcept
{
    return from_rc(ove_httpd_ws_route(path, on_message, on_close));
}
 
inline int broadcast(const char *path, const void *data, size_t len)
{
    return ove_httpd_ws_broadcast(path, data, len);
}
 
inline int broadcast(const char *path, std::string_view sv)
{
    return ove_httpd_ws_broadcast(path, sv.data(), sv.size());
}
 
inline int active_count()
{
    return ove_httpd_ws_active_count();
}
 
} /* namespace ws */
 
#endif /* CONFIG_OVE_NET_HTTPD_WS */
 
} // namespace ove
 
#endif /* CONFIG_OVE_NET_HTTPD */