src/server/proxy/httpclient.h

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2026 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef PROXY_HTTPCLIENT_H
#define PROXY_HTTPCLIENT_H

#include "../public/nsapi.h"
#include "../daemon/httpparser.h"
#include "../util/io.h"

#include <sys/socket.h>
#include <cx/string.h>
#include <cx/mempool.h>
#include <cx/test.h>

#include <inttypes.h>

#ifdef __cplusplus
extern "C" {
#endif
    
#define HTTP_CLIENT_BUFFER_SIZE 4096
    
#define HTTP_CLIENT_CALLBACK_WOULD_BLOCK -1
#define HTTP_CLIENT_CALLBACK_ERROR       -2

typedef struct HttpClient HttpClient;
struct HttpClient {
    EventHandler *ev;
    CxMempool *mp;
    char *method;
    char *uri;
    
    struct sockaddr *addr;
    size_t addrlen;
    
    int socketfd;
    HttpStream *stream;
    
    HeaderArray *request_headers;
    HeaderArray *response_headers;
    
    /*
     * request content length
     * 0: no request body
     * > 0: request body with static length
     * -1: request body with chunked transfer encoding
     */
    int64_t req_content_length;
    
    int error;
    int statuscode;
    
    /*
     * Request body callback function
     * 
     * ssize_t request_body_read(HttpClient *client, void *buf, size_t size, void *userdata)
     * 
     * Return: number of processed bytes,
     *         HTTP_CLIENT_CALLBACK_WOULD_BLOCK or HTTP_CLIENT_CALLBACK_ERROR.
     */
    ssize_t (*request_body_read)(HttpClient *, void *, size_t, void *);
    void *request_body_read_userdata;
    
    /*
     * Response start callback function
     * 
     * int response_start(HttpClient *client, int status, char *message, void *userdata)
     * 
     * Return: 0 success
     *         HTTP_CLIENT_CALLBACK_WOULD_BLOCK or HTTP_CLIENT_CALLBACK_ERROR
     */
    int (*response_start)(HttpClient *, int, char *, void *);
    void *response_start_userdata;
    
    /*
     * Response body write function
     * 
     * int response_body_write(HttpClient *client, void *buf, size_t size, void *userdata)
     * 
     * Return: number of processed bytes,
     *         HTTP_CLIENT_CALLBACK_WOULD_BLOCK or HTTP_CLIENT_CALLBACK_ERROR.
     */
    ssize_t (*response_body_write)(HttpClient *, void *, size_t, void *);
    void *response_body_write_userdata;
    
    /*
     * Websocket write callback function
     * 
     * ssize_t ws_write(HttpClient *client, void *buf, size_t size, void *userdata)
     * 
     * Return: number of processed bytes,
     *         HTTP_CLIENT_CALLBACK_WOULD_BLOCK or HTTP_CLIENT_CALLBACK_ERROR.
     */
    ssize_t (*ws_write)(HttpClient *, void *, size_t, void *);
    void *ws_write_userdata;
    
    /*
     * Websocket message IO available
     * 
     * This function is called, when client->socketfd is ready to accept
     * new messages (http_client_add_message) 
     */
    int (*ws_msg_ready)(HttpClient *, void *);
    void *ws_msg_ready_userdata;
    
    /*
     * Response finished callback
     * 
     * After this callback, the client object is no longer used. The callback
     * is allowed to free the client object or reuse it.
     * 
     * void response_finished(HttpClient *client, void *userdata)
     */
    void (*response_finished)(HttpClient *, void *);
    void *response_finished_userdata;
    
    
    // internals
    HttpParser *parser;
    netbuf buffer;
    
    // transfer_buffer: buffer for sending data to socketfd
    char *transfer_buffer;
    size_t transfer_buffer_alloc;
    size_t transfer_buffer_len;
    size_t transfer_buffer_pos;
    
    // transfer2_buffer: buffer for response_body_write or ws_write
    char *transfer2_buffer;
    size_t transfer2_buffer_alloc;
    size_t transfer2_buffer_len;
    size_t transfer2_buffer_pos;
    
    size_t req_contentlength_pos;
    
    int stage; // 0: request, 1: response, 2: websocket
    int request_body_complete;
    int request_body_terminated;
    int response_header_complete;
    int keep_alive;
    
    Event event;
};

HttpClient* http_client_new(EventHandler *ev);

void http_client_free(HttpClient *client);

int http_client_set_addr(HttpClient *client, const struct sockaddr *addr, socklen_t addrlen);

int http_client_set_method(HttpClient *client, const char *method);

int http_client_set_uri(HttpClient *client, const char *uri);

int http_client_set_method_len(HttpClient *client, const char *method, size_t len);

int http_client_set_uri_len(HttpClient *client, const char *uri, size_t len);

/*
 * Adds a request header
 * 
 * This function does not create a copy of name/value. The string pointers must
 * be valid for the lifetime of the HttpClient.
 */
int http_client_add_request_header(HttpClient *client, cxmutstr name, cxmutstr value);

/*
 * Adds a request header
 * 
 * This functions creates a copy of name/value and the original pointers can be
 * discarded after the function returns.
 */
int http_client_add_request_header_copy(HttpClient *client, cxstring name, cxstring value);

/*
 * Sets the content length for the request body
 */
int http_client_set_content_length(HttpClient *client, int64_t contentlength);

/*
 * Enables a request body with a chunked transfer encoding
 */
int http_client_enable_chunked_transfer_encoding(HttpClient *client);

/*
 * Start request processing
 */
int http_client_start(HttpClient *client);

/*
 * Handle HttpClient IO and process the request/response
 */
int http_client_process(HttpClient *client);

/*
 * Adds message data, that will be sent to client->socketfd. This function
 * should only be called when processing websockets.
 */
int http_client_add_message(HttpClient *client, const void *buf, size_t size);

size_t http_client_message_buf_size_available(HttpClient *client);


void http_client_add_tests(CxTestSuite *suite);

#ifdef __cplusplus
}
#endif

#endif /* PROXY_HTTPCLIENT_H */