Something went wrong. Try again.
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions ant.themackabu.dev
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351#include <uv.h>#include <stdlib.h>#include <string.h>#include <strings.h>#include <tlsuv/http.h>
#include "modules/http.h"#include "streams/brotli.h"
struct ant_http_request_s { tlsuv_http_t client; ant_http_response_t response; tlsuv_http_req_t *req; ant_http_response_cb on_response; ant_http_body_cb on_body; ant_http_complete_cb on_complete; void *user_data; char *error_message; brotli_stream_state_t *brotli_decoder; ant_http_result_t result; int error_code; bool completed; bool canceled; bool decode_brotli;};
void ant_http_headers_free(ant_http_header_t *headers) {while (headers) { ant_http_header_t *next = headers->next; free(headers->name); free(headers->value); free(headers); headers = next;}}
static void ant_http_request_free(ant_http_request_t *req) { if (!req) return; free((char *)req->response.status_text); ant_http_headers_free((ant_http_header_t *)req->response.headers); free(req->error_message); if (req->brotli_decoder) brotli_stream_state_destroy(req->brotli_decoder); free(req);}
static void ant_http_upload_chunk_cb(tlsuv_http_req_t *http_req, char *body, ssize_t len) { free(body);}
static char *ant_http_copy_slice(const char *src, size_t len) { char *out = malloc(len + 1); if (!out) return NULL; memcpy(out, src, len); out[len] = '\0'; return out;}
static char *ant_http_build_host_url(const struct tlsuv_url_s *url) { size_t size = 0; char port_buf[16] = {0}; int port_len = 0;
if (url->port != 0) port_len = snprintf(port_buf, sizeof(port_buf), ":%u", url->port); size = url->scheme_len + 3 + url->hostname_len + (size_t)port_len + 1;
char *host_url = malloc(size); if (!host_url) return NULL; snprintf( host_url, size, "%.*s://%.*s%s", (int)url->scheme_len, url->scheme, (int)url->hostname_len, url->hostname, port_buf ); return host_url;}
static char *ant_http_build_path(const struct tlsuv_url_s *url) { const char *path = (url->path && url->path_len > 0) ? url->path : "/"; size_t path_len = (url->path && url->path_len > 0) ? url->path_len : 1; size_t query_extra = url->query && url->query_len > 0 ? (size_t)url->query_len + 1 : 0; char *request_path = malloc(path_len + query_extra + 1); if (!request_path) return NULL;
memcpy(request_path, path, path_len); if (query_extra > 0) { request_path[path_len] = '?'; memcpy(request_path + path_len + 1, url->query, url->query_len); request_path[path_len + query_extra] = '\0'; } else request_path[path_len] = '\0';
return request_path;}
static ant_http_header_t *ant_http_header_dup(const char *name, const char *value) { ant_http_header_t *hdr = calloc(1, sizeof(*hdr)); if (!hdr) return NULL;
hdr->name = strdup(name ? name : ""); hdr->value = strdup(value ? value : ""); if (!hdr->name || !hdr->value) { free(hdr->name); free(hdr->value); free(hdr); return NULL; }
return hdr;}
static ant_http_header_t *ant_http_copy_headers(tlsuv_http_resp_t *resp) { ant_http_header_t *head = NULL; ant_http_header_t **tail = &head; tlsuv_http_hdr *hdr = NULL;
LIST_FOREACH(hdr, &resp->headers, _next) { ant_http_header_t *copy = ant_http_header_dup(hdr->name, hdr->value); if (!copy) { ant_http_headers_free(head); return NULL; } *tail = copy; tail = ©->next; }
return head;}
static const char *ant_http_find_header(const ant_http_header_t *headers, const char *name) { for (const ant_http_header_t *entry = headers; entry; entry = entry->next) { if (entry->name && name && strcasecmp(entry->name, name) == 0) return entry->value; } return NULL;}
static void ant_http_on_close(tlsuv_http_t *client) { ant_http_request_t *req = (ant_http_request_t *)client->data; if (!req) return;
if (req->on_complete) req->on_complete( req, req->result, req->error_code, req->error_message, req->user_data ); ant_http_request_free(req);}
static void ant_http_complete(ant_http_request_t *req, int error_code, const char *error_message) { if (!req || req->completed) return; req->completed = 1; req->error_code = error_code; if (error_code == 0) req->result = ANT_HTTP_RESULT_OK; else if (req->canceled) req->result = ANT_HTTP_RESULT_ABORTED; else req->result = ANT_HTTP_RESULT_NETWORK_ERROR;
free(req->error_message); req->error_message = error_message ? strdup(error_message) : NULL;
tlsuv_http_close(&req->client, ant_http_on_close);}
static int ant_http_brotli_body_cb(void *ctx, const uint8_t *chunk, size_t len) { ant_http_request_t *req = (ant_http_request_t *)ctx; if (req->on_body && len > 0) req->on_body(req, chunk, len, req->user_data); return 0;}
static void ant_http_tlsuv_body_cb(tlsuv_http_req_t *http_req, char *body, ssize_t len) { ant_http_request_t *req = (ant_http_request_t *)http_req->data; if (!req) return;
if (len == UV_EOF) { if (req->decode_brotli && req->brotli_decoder && brotli_stream_finish(req->brotli_decoder, ant_http_brotli_body_cb, req) != 0) { ant_http_complete(req, UV_EINVAL, "brotli decompression failed"); return; } ant_http_complete(req, 0, NULL); return; }
if (len < 0) { ant_http_complete(req, (int)len, uv_strerror((int)len)); return; }
if (req->decode_brotli && req->brotli_decoder) { if (brotli_stream_process( req->brotli_decoder, (const uint8_t *)body, (size_t)len, ant_http_brotli_body_cb, req) != 0 ) ant_http_complete(req, UV_EINVAL, "brotli decompression failed"); return; }
if (req->on_body && len > 0) req->on_body(req, (const uint8_t *)body, (size_t)len, req->user_data);}
static void ant_http_resp_cb(tlsuv_http_resp_t *resp, void *data) { ant_http_request_t *req = (ant_http_request_t *)resp->req->data; const char *content_encoding = NULL; if (!req) return;
if (resp->code < 0) { ant_http_complete(req, resp->code, uv_strerror(resp->code)); return; }
req->response.status = resp->code; req->response.status_text = resp->status ? strdup(resp->status) : strdup(""); req->response.headers = ant_http_copy_headers(resp); if (!req->response.status_text || (resp->headers.lh_first && !req->response.headers)) { ant_http_complete(req, UV_ENOMEM, "out of memory"); return; }
content_encoding = ant_http_find_header(req->response.headers, "content-encoding"); if (content_encoding && strcasecmp(content_encoding, "br") == 0) { req->brotli_decoder = brotli_stream_state_new(true); if (!req->brotli_decoder) { ant_http_complete(req, UV_ENOMEM, "out of memory"); return; } req->decode_brotli = 1; }
resp->body_cb = ant_http_tlsuv_body_cb; if (req->on_response) req->on_response(req, &req->response, req->user_data);}
const ant_http_response_t *ant_http_request_response(ant_http_request_t *req) { return req ? &req->response : NULL;}
int ant_http_request_cancel(ant_http_request_t *req) { if (!req || !req->req || req->completed) return 0; req->canceled = true; return tlsuv_http_req_cancel(&req->client, req->req);}
int ant_http_request_write(ant_http_request_t *req, const uint8_t *chunk, size_t len) { uint8_t *copy = NULL; int rc = 0;
if (!req || !req->req || req->completed) return UV_EINVAL; if (len == 0) return 0;
copy = malloc(len); if (!copy) return UV_ENOMEM; memcpy(copy, chunk, len);
rc = tlsuv_http_req_data(req->req, (const char *)copy, len, ant_http_upload_chunk_cb); if (rc != 0) free(copy); return rc;}
void ant_http_request_end(ant_http_request_t *req) { if (!req || !req->req || req->completed) return; tlsuv_http_req_end(req->req);}
int ant_http_request_start( uv_loop_t *loop, const ant_http_request_options_t *options, ant_http_response_cb on_response, ant_http_body_cb on_body, ant_http_complete_cb on_complete, void *user_data, ant_http_request_t **out_req) { struct tlsuv_url_s parsed = {0}; ant_http_request_t *req = NULL; char *host_url = NULL; char *request_path = NULL; int rc = 0;
if (out_req) *out_req = NULL; if (!loop || !options || !options->method || !options->url) return UV_EINVAL; if (tlsuv_parse_url(&parsed, options->url) != 0) return UV_EINVAL; if (!parsed.scheme || !parsed.hostname) return UV_EINVAL;
req = calloc(1, sizeof(ant_http_request_t)); if (!req) return UV_ENOMEM;
req->on_response = on_response; req->on_body = on_body; req->on_complete = on_complete; req->user_data = user_data;
host_url = ant_http_build_host_url(&parsed); request_path = ant_http_build_path(&parsed); if (!host_url || !request_path) { free(host_url); free(request_path); ant_http_request_free(req); return UV_ENOMEM; }
rc = tlsuv_http_init(loop, &req->client, host_url); free(host_url); if (rc != 0) { free(request_path); ant_http_request_free(req); return rc; }
req->client.data = req; tlsuv_http_header(&req->client, "Accept-Encoding", NULL); req->req = tlsuv_http_req( &req->client, options->method, request_path, ant_http_resp_cb, req ); free(request_path);
if (!req->req) { tlsuv_http_close(&req->client, NULL); ant_http_request_free(req); return UV_ENOMEM; }
req->req->data = req; if (options->chunked_body) tlsuv_http_req_header(req->req, "transfer-encoding", "chunked"); for (const ant_http_header_t *hdr = options->headers; hdr; hdr = hdr->next) { tlsuv_http_req_header(req->req, hdr->name, hdr->value); }
if (options->body && options->body_len > 0) { rc = tlsuv_http_req_data(req->req, (const char *)options->body, options->body_len, NULL); if (rc != 0) { ant_http_complete(req, rc, uv_strerror(rc)); if (out_req) *out_req = req; return 0; }}
if (out_req) *out_req = req; return 0;}