net_http.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_http.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
#ifdef CONFIG_OVE_NET_HTTP
 
namespace ove::http
{
 
class Response
{
      public:
    Response() = default;
 
    ~Response() noexcept
    {
        ove_http_response_free(&raw_);
    }
 
    Response(const Response &) = delete;
    Response &operator=(const Response &) = delete;
 
    Response(Response &&other) noexcept : raw_(other.raw_)
    {
        other.raw_ = {};
    }
 
    Response &operator=(Response &&other) noexcept
    {
        if (this != &other) {
            ove_http_response_free(&raw_);
            raw_ = other.raw_;
            other.raw_ = {};
        }
        return *this;
    }
 
    int status() const
    {
        return raw_.status;
    }
 
    const char *body() const
    {
        return raw_.body;
    }
 
    size_t body_len() const
    {
        return raw_.body_len;
    }
 
    const char *headers() const
    {
        return raw_.headers;
    }
 
    size_t headers_len() const
    {
        return raw_.headers_len;
    }
 
    ove_http_response_t *raw()
    {
        return &raw_;
    }
 
    ove_http_response_t raw_{}; 
};
 
class Client
{
      public:
    Client()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_http_client_init(&handle_, &storage_);
#else
        int err = ove_http_client_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Client() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_http_client_deinit(handle_);
#else
        ove_http_client_destroy(handle_);
#endif
    }
 
    Client(const Client &) = delete;
    Client &operator=(const Client &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Client(Client &&) = delete;
    Client &operator=(Client &&) = delete;
#else
    Client(Client &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Client &operator=(Client &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_http_client_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] Result<Response> get(const char *url) noexcept
    {
        Response resp;
        const int rc = ove_http_get(handle_, url, &resp.raw_);
        return from_rc(rc, std::move(resp));
    }
 
    [[nodiscard]] Result<Response> post(const char *url, const char *content_type,
                        const void *body, size_t body_len) noexcept
    {
        Response resp;
        const int rc =
            ove_http_post(handle_, url, content_type, body, body_len, &resp.raw_);
        return from_rc(rc, std::move(resp));
    }
 
    [[nodiscard]] Result<Response> request(ove_http_method_t method, const char *url,
                           const char *content_type, const void *body,
                           size_t body_len) noexcept
    {
        Response resp;
        const int rc = ove_http_request(handle_, method, url, content_type, body, body_len,
                        &resp.raw_);
        return from_rc(rc, std::move(resp));
    }
 
    [[nodiscard]] Result<Response> request(ove_http_method_t method, const char *url,
                           const char *content_type, const void *body,
                           size_t body_len, const ove_http_header_t *headers,
                           size_t header_count) noexcept
    {
        Response resp;
        const int rc = ove_http_request_ex(handle_, method, url, content_type, body,
                           body_len, headers, header_count, &resp.raw_);
        return from_rc(rc, std::move(resp));
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_http_client_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_http_client_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_http_client_storage_t storage_ = {};
#endif
};
 
} /* namespace ove::http */
 
#endif /* CONFIG_OVE_NET_HTTP */