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 <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;
 
    int json(int status, const char *json) {
        return ove_httpd_resp_json(raw_, status, json);
    }
 
    int html(int status, const char *html, size_t len) {
        return ove_httpd_resp_html(raw_, status, html, len);
    }
 
    int send(int status, const char *content_type,
         const void *body, size_t len) {
        return ove_httpd_resp_send(raw_, status, content_type,
                      body, len);
    }
 
    int send_gz(int status, const char *content_type,
            const void *body, size_t len) {
        return ove_httpd_resp_send_gz(raw_, status, content_type,
                         body, len);
    }
 
    int error(int status, const char *msg) {
        return 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 int start(const Config &cfg = {}) {
    ove_httpd_config_t c{cfg.port, cfg.max_body_size};
    return ove_httpd_start(&c);
}
 
inline void stop() {
    ove_httpd_stop();
}
 
[[nodiscard]] inline int route(const char *method, const char *path,
                   Handler handler) {
    return 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) {}
 
    int send(const void *data, size_t len) {
        return ove_httpd_ws_send(raw_, data, len);
    }
 
    int send(std::string_view sv) {
        return 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 int route(const char *path,
                   Handler on_message,
                   CloseHandler on_close = nullptr) {
    return 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 */