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>
 
#ifdef CONFIG_OVE_NET_HTTP
 
namespace ove {
 
namespace http {
 
class Response {
public:
    Response() = default;
 
    ~Response() { 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() {
        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]] int get(const char *url, Response &resp) {
        return ove_http_get(handle_, url, &resp.raw_);
    }
 
    [[nodiscard]] int post(const char *url, const char *content_type,
                   const void *body, size_t body_len,
                   Response &resp) {
        return ove_http_post(handle_, url, content_type,
                     body, body_len, &resp.raw_);
    }
 
    [[nodiscard]] int request(ove_http_method_t method, const char *url,
                  const char *content_type,
                  const void *body, size_t body_len,
                  Response &resp) {
        return ove_http_request(handle_, method, url, content_type,
                       body, body_len, &resp.raw_);
    }
 
    [[nodiscard]] int 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,
                  Response &resp) {
        return ove_http_request_ex(handle_, method, url, content_type,
                      body, body_len, headers,
                      header_count, &resp.raw_);
    }
 
    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 http */
 
} // namespace ove
 
#endif /* CONFIG_OVE_NET_HTTP */