Mercurial > hg > webserver / file revision

/*
 * 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.
 */

#include "httpclient.h"

#include "../util/socket.h"

#include <cx/buffer.h>
#include <cx/string.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

static int client_connected(EventHandler *ev, Event *event);
static int client_io(EventHandler *ev, Event *event);
static int client_finished(EventHandler *ev, Event *event);

static int client_send_request(HttpClient *client);

HttpClient* http_client_new(EventHandler *ev) {
    CxMempool *mp = cxMempoolCreate(32, CX_MEMPOOL_TYPE_PURE);
    if(!mp) {
        return NULL;
    }
    
    HttpClient *client = malloc(sizeof(HttpClient));
    HeaderArray *req_headers = header_array_create();
    HeaderArray *resp_headers = header_array_create();
    if(!client || !req_headers || !resp_headers) {
        free(client);
        header_array_free(req_headers);
        header_array_free(resp_headers);
        cxMempoolFree(mp);
        return NULL;
    }
    
    memset(client, 0, sizeof(HttpClient));
    client->ev = ev;
    client->socketfd = -1;
    client->request_headers = req_headers;
    client->response_headers = resp_headers;
    
    client->buffer.maxsize = HTTP_CLIENT_BUFFER_SIZE;
    client->buffer.inbuf = malloc(HTTP_CLIENT_BUFFER_SIZE);
    HttpParser *parser = http_parser_new2(1, &client->buffer, resp_headers);
    if(!parser || !client->buffer.inbuf) {
        http_client_free(client);
        return NULL;
    }
    client->parser = parser;
    
    return client;
}

void http_client_free(HttpClient *client) {
    cxMempoolFree(client->mp);
    header_array_free(client->request_headers);
    http_parser_free(client->parser);
    free(client->buffer.inbuf);
    free(client->addr);
    free(client->method);
    free(client->uri);
    free(client);
}

int http_client_set_addr(HttpClient *client, const struct sockaddr *addr, socklen_t addrlen) {
   free(client->addr);
   client->addr = NULL;
   client->addrlen = 0;
   
   void *newaddr = malloc(addrlen);
   if(!newaddr) {
       return 1;
   }
   memcpy(newaddr, addr, addrlen);
   client->addr = newaddr;
   client->addrlen = addrlen;
   
   return 0;
}

int http_client_set_method(HttpClient *client, const char *method) {
    return http_client_set_method_len(client, method, method ? strlen(method) : 0);
}

int http_client_set_uri(HttpClient *client, const char *uri) {
    return http_client_set_uri_len(client, uri, uri ? strlen(uri) : 0);
}

static int client_set_str(char **ptr, const char *str, size_t len) {
    free(*ptr);
    if(str) {
        char *newvalue = malloc(len+1);
        if(!newvalue) {
            *ptr = NULL;
            return 1;
        }
        memcpy(newvalue, str, len);
        newvalue[len] = 0;
        *ptr = newvalue;
    } else {
        *ptr = NULL;
    }
    return 0;
}

int http_client_set_method_len(HttpClient *client, const char *method, size_t len) {
    return client_set_str(&client->method, method, len);
}

int http_client_set_uri_len(HttpClient *client, const char *uri, size_t len) {
    return client_set_str(&client->uri, uri, len);
}

int http_client_add_request_header(HttpClient *client, cxmutstr name, cxmutstr value) {
    return header_array_add(client->request_headers, name, value);
}

int http_client_add_request_header_copy(HttpClient *client, cxstring name, cxstring value) {
    if(!client->mp) {
        client->mp = cxMempoolCreate(64, CX_MEMPOOL_TYPE_PURE);
        if(!client->mp) {
            return 1;
        }
    }
    
    cxmutstr n = cx_strdup_a(client->mp->allocator, name);
    cxmutstr v = cx_strdup_a(client->mp->allocator, value);
    
    int err = 1;
    if(n.ptr && v.ptr) {
        err = http_client_add_request_header(client, n, v);
    }
    if(err) {
        cxFree(client->mp->allocator, n.ptr);
        cxFree(client->mp->allocator, v.ptr);
    }
    return err;
}

int http_client_set_content_length(HttpClient *client, int64_t contentlength) {
    client->req_content_length = contentlength;
    char ctlen_buf[32];
    size_t len = snprintf(ctlen_buf, 32, "%" PRId64, contentlength);
    return http_client_add_request_header_copy(client, cx_str("content-length"), cx_strn(ctlen_buf, len));
}

int http_client_enable_chunked_transfer_encoding(HttpClient *client) {
    client->req_content_length = -1;
    return http_client_add_request_header(client, cx_mutstr("transfer-encoding"), cx_mutstr("chunked"));
}

int http_client_start(HttpClient *client) {
    int socketfd = socket(AF_INET, SOCK_STREAM, 0);
    if(socketfd < 0) {
        return 1;
    }
    
    if(util_socket_setnonblock(socketfd, 1)) {
        close(socketfd);
        return 1;
    }
    
    client->socketfd = socketfd;
    
    client->writeev.cookie = client;
    client->writeev.fn = client_connected;
    
    int ret = 1;
    if(connect(socketfd, client->addr, client->addrlen)) {
        int err = errno;
        if(err == EINPROGRESS) {
            ret = ev_pollout(client->ev, socketfd, &client->writeev);
        } else {
            log_ereport(LOG_FAILURE, "http-client-start: connect failed: %s", strerror(err));
        }
    } else {
        // TODO: call client_connected directly
    }
    
    if(ret) {
        close(socketfd);
    }
    return ret;
}

static int create_req_buffer(HttpClient *client) {
    CxBuffer buf;
    if(cxBufferInit(&buf, cxDefaultAllocator, NULL, HTTP_CLIENT_BUFFER_SIZE, CX_BUFFER_AUTO_EXTEND)) {
        return 1;
    }
    
    if(client->method) {
        cxBufferPutString(&buf, "GET ");
    } else {
        cxBufferPutString(&buf, client->method);
    }
    cxBufferPutString(&buf, client->uri ? client->uri : "/");
    cxBufferPutString(&buf, " HTTP/1.1\r\n");
    
    HeaderArray *hdr = client->request_headers;
    while(hdr) {
        for(int i=0;i<hdr->len;i++) {
            cxBufferPutString(&buf, hdr->headers[i].name);
            cxBufferPutString(&buf, ": ");
            cxBufferPutString(&buf, hdr->headers[i].value);
            cxBufferPutString(&buf, "\r\n");
        }
        hdr = hdr->next;
    }
    cxBufferPutString(&buf, "\r\n");
    client->req_buffer = buf.space;
    client->req_buffer_alloc = buf.capacity;
    client->req_buffer_len = buf.size;
    
    return 0;
}

static int client_connected(EventHandler *ev, Event *event) {
    HttpClient *client = event->cookie;
    if(create_req_buffer(client)) {
        // TODO: set error
        return 0; // end
    }
    event->fn = client_io;
    
    return client_io(ev, event);
}

static int client_io(EventHandler *ev, Event *event) {
    HttpClient *client = event->cookie;
    if(client->req_buffer_pos < client->req_buffer_len) {
        if(client_send_request(client)) {
            return client->error == 0;
        }
    }
    
    // do we need to send a request body?
    if(client->req_content_length != 0) {
        while(!client->request_body_complete) {
            ssize_t r = client->request_body_read(client, client->req_buffer, client->req_buffer_alloc, client->request_body_read_userdata);
            if(r <= 0) {
                if(r == HTTP_CLIENT_CALLBACK_WOULD_BLOCK) {
                    return 1;
                } else if(r == 0) {
                    // EOF
                    client->request_body_complete = 1;
                    break;
                } else {
                    // error
                    client->error = 1;
                    return 0;
                }
            }
            client->req_contentlength_pos += r;
            client->req_buffer_pos = 0;
            client->req_buffer_len = r;
            if(client_send_request(client)) {
                return client->error == 0;
            }
        }
        
        if(client->req_content_length > 0 && client->req_content_length != client->req_contentlength_pos) {
            // incomplete request body
            client->error = 1;
            return 0;
        }
    }
    
    
    
    // writing complete, switch to read events
    event->events = EVENT_POLLIN;
    
    
    char *buffer;
    size_t nbytes;
    if(client->header_complete) {
        buffer = client->buffer.inbuf;
        nbytes = client->buffer.maxsize;
    } else {
        buffer = client->buffer.inbuf + client->buffer.pos;
        nbytes = client->buffer.maxsize - client->buffer.cursize;
    }
    
    
    ssize_t r;
    while((r = read(client->socketfd, buffer, nbytes)) > 0) {
        client->buffer.cursize += r;
        if(!client->header_complete) {
            switch(http_parser_process(client->parser)) {
                case 0: { // finish
                    if(!http_parser_validate(client->parser)) {
                        client->error = 1;
                        return 0;
                    }
                    client->statuscode = client->parser->status;
                    
                    client->header_complete = 1;
                    if(client->response_start) {
                        cxmutstr msg = client->parser->msg;
                        char t = msg.ptr[msg.length];
                        msg.ptr[msg.length] = 0;
                        int ret = client->response_start(client, client->statuscode, msg.ptr, client->response_start_userdata);
                        msg.ptr[msg.length] = t;
                        
                        // TODO: check ret
                    }
                    break;
                }
                case 1: { // need more data
                    continue;
                }
                case 2: { // error
                    client->error = 1;
                    return 0;
                }
            }
        }
        
        // header complete
        
        char *out = client->buffer.inbuf + client->buffer.pos;
        size_t len = client->buffer.cursize - client->buffer.pos;
        
        if(client->response_body_write) {
            int ret = client->response_body_write(client, out, len, client->response_body_write_userdata);
            // TODO: check ret
        }
        
        client->buffer.pos = 0;
        client->buffer.cursize = 0;
    }
    
    if(r < 0) {
        if(errno == EAGAIN) {
            return 1;
        } else {
            log_ereport(LOG_FAILURE, "http-client: IO error: %s", strerror(errno));
        }
    }
    
    // request finished
    if(client->response_finished) {
        client->response_finished(client, client->response_finished_userdata);
    }
    
    return 0;
}

static int client_finished(EventHandler *ev, Event *event) {
    HttpClient *client = event->cookie;
    
    close(client->socketfd);
    client->socketfd = -1;
    
    // request finished
    if(client->response_finished) {
        client->response_finished(client, client->response_finished_userdata);
    }
    
    return 0;
}

static int client_send_request(HttpClient *client) {
    size_t nbytes = client->req_buffer_len - client->req_buffer_pos;
    ssize_t w;
    while((w = write(client->socketfd, client->req_buffer + client->req_buffer_pos, nbytes)) > 0) {
        client->req_buffer_pos += w;
        nbytes = client->req_buffer_len - client->req_buffer_pos;
        if(nbytes == 0) {
            break;
        }
    }
    
    if(w <= 0) {
        if(errno != EAGAIN) {
            // TODO: log correct host
            log_ereport(LOG_VERBOSE, "http-client %s - %s: write failed: %s", "localhost", client->uri, strerror(errno));
            client->error = 1;
        }
        return 1;
    }
    
    return client->req_buffer_pos < client->req_buffer_len;
}



/* --------------------------------- Tests --------------------------------- */

static CX_TEST(test_http_client_send_request) {
    CX_TEST_DO {
        EventHandler dummy;
        HttpClient *client = http_client_new(&dummy);
        
        int fds[2];
        util_socketpair(fds);
        util_socket_setnonblock(fds[0], 1);
        util_socket_setnonblock(fds[1], 1);
        client->socketfd = fds[0];
        int sock = fds[1];
        
        // create a large test buffer, that is bigger than the socket buffer
        // 32mb should be enough
        size_t len = 32*1024*1024;
        char *str = malloc(len);
        // init the buffer with random data
        for(size_t i=0;i<len;i+=sizeof(int)) {
            int *p = (int*)(str+i);
            *p = rand();;
        }
        
        client->req_buffer = str;
        client->req_buffer_len = len;
        
        // test client_send_request
        
        int ret = client_send_request(client);
        // It is very likely that the first client_send_request call doesn't
        // fully write the request buffer to the socket
        // In that case it returns 1 but without the error flag
        CX_TEST_ASSERT(ret == 1 && !client->error);
        CX_TEST_ASSERT(client->req_buffer_pos > 0);
        CX_TEST_ASSERT(client->req_buffer_pos < len);
        
        // read the request buffer from sock and continue with client_send_request
        CxBuffer buf;
        cxBufferInit(&buf, cxDefaultAllocator, NULL, len, CX_BUFFER_AUTO_EXTEND|CX_BUFFER_FREE_CONTENTS);
        char tmpbuf[1024];
        int writes = 1;
        while(client->req_buffer_pos < client->req_buffer_len && writes < 2000000) {
            ssize_t r = read(sock, tmpbuf, 1024);
            CX_TEST_ASSERT(r >= 0);
            cxBufferWrite(tmpbuf, 1, r, &buf);
            ret = client_send_request(client);
            CX_TEST_ASSERT(ret == 0 || (ret == 1 && !client->error));
            
            writes++;
        }
        CX_TEST_ASSERT(client->req_buffer_pos == client->req_buffer_len);
        
        // finish reading the request buffer from sock
        ssize_t r;
        while((r = read(sock, tmpbuf, 1024)) > 0 && writes < 2000000) {
            cxBufferWrite(tmpbuf, 1, r, &buf);
            writes++;
        }
        
        CX_TEST_ASSERT(buf.size == len);
        CX_TEST_ASSERT(!memcmp(str, buf.space, len));
        
        // cleanup
        close(fds[0]);
        close(fds[1]);
        http_client_free(client);
        cxBufferDestroy(&buf);
    }
}

typedef struct TestResponse {
    int status;
    char *msg;
    CxBuffer *response;
} TestResponse;

static int test_response_start(HttpClient *client, int status, char *msg, void *userdata) {
    TestResponse *test = userdata;
    test->status = status;
    test->msg = strdup(msg);
    return 0;
}

static ssize_t test_response_body_write(HttpClient *client, void *buf, size_t size, void *userdata) {
    TestResponse *test = userdata;
    cxBufferWrite(buf, 1, size, test->response);
    return size;
}

static CX_TEST(test_http_client_io_simple) {
    CX_TEST_DO {
        EventHandler dummy;
        HttpClient *client = http_client_new(&dummy);
        
        int fds[2];
        util_socketpair(fds);
        util_socket_setnonblock(fds[0], 1);
        util_socket_setnonblock(fds[1], 1);
        client->socketfd = fds[0];
        int sock = fds[1];
        
        // setup client
        http_client_set_uri(client, "/test/uri/");
        http_client_set_method(client, "GET");
        http_client_add_request_header(client, cx_mutstr("Host"), cx_mutstr("localhost"));
        http_client_add_request_header(client, cx_mutstr("Test1"), cx_mutstr("value1"));
        http_client_add_request_header(client, cx_mutstr("Test2"), cx_mutstr("value2"));
        create_req_buffer(client);
        
        size_t req_header_len = client->req_buffer_len;
        
        // response buffer
        CxBuffer buf;
        cxBufferInit(&buf, cxDefaultAllocator, NULL, 1024, CX_BUFFER_AUTO_EXTEND|CX_BUFFER_FREE_CONTENTS);
        
        TestResponse testr = { 0 };
        testr.response = &buf;
        client->response_start = test_response_start;
        client->response_start_userdata = &testr;
        client->response_body_write = test_response_body_write;
        client->response_body_write_userdata = &testr;
        
        // test IO
        Event event;
        event.cookie = client;
        int ret = client_io(&dummy, &event);
        CX_TEST_ASSERT(!client->error);
        CX_TEST_ASSERT(ret == 1);
        
        // do IO and read request until the header is processed
        size_t req_header_pos = 0;
        char req_buf[4];
        while(req_header_pos < req_header_len) {
            ssize_t r = read(sock, req_buf, 4);
            if(r == 0) {
                break;
            }
            CX_TEST_ASSERT(r > 0);
            req_header_pos += r;
            ret = client_io(&dummy, &event);
            CX_TEST_ASSERT(!client->error);
            CX_TEST_ASSERT(ret == 1);
        }
        CX_TEST_ASSERT(req_header_pos == req_header_len);
        
        char *response_str = 
                "HTTP/1.1 200 OK\r\n"
                "Host: localhost\r\n"
                "Content-length: 13\r\n"
                "\r\n"
                "Hello World!\n";
        size_t response_str_len = strlen(response_str);
        size_t response_str_pos = 0;
        
        // send response and do IO
        while(response_str_pos < response_str_len) {
            size_t len = response_str_len - response_str_pos;
            if(len > 3) {
                //len = 3;
            }
            ssize_t w = write(sock, response_str + response_str_pos, len);
            if(w == 0) {
                break;
            }
            CX_TEST_ASSERT(w > 0);
            response_str_pos += w;
            
            ret = client_io(&dummy, &event);
            
            CX_TEST_ASSERT(!client->error);
            CX_TEST_ASSERT(ret == 1);
        }
        CX_TEST_ASSERT(response_str_pos == response_str_len);
        CX_TEST_ASSERT(testr.status == 200);
        CX_TEST_ASSERT(testr.msg);
        CX_TEST_ASSERT(!strcmp(testr.msg, "OK"));
        CX_TEST_ASSERT(testr.response->size == 13);
        CX_TEST_ASSERT(!cx_strcmp(cx_strn(testr.response->space, testr.response->size), "Hello World!\n"));
        
        // cleanup
        free(testr.msg);
        close(fds[0]);
        close(fds[1]);
        http_client_free(client);
        cxBufferDestroy(&buf);
    }
}

void http_client_add_tests(CxTestSuite *suite) {
    cx_test_register(suite, test_http_client_send_request);
    cx_test_register(suite, test_http_client_io_simple);
}