HomePhorge
Diffusion Ant (feature/nursery) Code

ant/src/modules/fetch.c
ddfe6237cab5feature/nursery

Last Change
Raw File

fetch.c
View Options

#include <compat.h> // IWYU pragma: keep
#include <uv.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <tlsuv/tlsuv.h>
#include <tlsuv/http.h>
#include <utarray.h>
#include "ant.h"
#include "errors.h"
#include "config.h"
#include "common.h"
#include "internal.h"
#include "runtime.h"
#include "modules/fetch.h"
#include "modules/json.h"
#include "modules/timer.h"
typedef struct {
char *data;
size_t size;
size_t capacity;
} fetch_buffer_t;
typedef struct fetch_request_s {
struct js *js;
jsval_t promise;
tlsuv_http_t http_client;
tlsuv_http_req_t *http_req;
fetch_buffer_t response_buffer;
int status_code;
int completed;
int failed;
char *error_msg;
jsval_t headers_obj;
char *method;
char *body;
size_t body_len;
} fetch_request_t;
static uv_loop_t *fetch_loop = NULL;
static UT_array *pending_requests = NULL;
static void free_fetch_request(fetch_request_t *req) {
if (!req) return;
if (req->response_buffer.data) free(req->response_buffer.data);
if (req->error_msg) free(req->error_msg);
if (req->method) free(req->method);
if (req->body) free(req->body);
free(req);
}
static void remove_pending_request(fetch_request_t *req) {
if (!req || !pending_requests) return;
fetch_request_t **p = NULL;
unsigned int i = 0;
while ((p = (fetch_request_t**)utarray_next(pending_requests, p))) {
if (*p == req) { utarray_erase(pending_requests, i, 1); break; }
i++;
}
}
static jsval_t fetch_fail_oom(struct js *js, jsval_t promise, fetch_request_t *req, bool close_http, const char *msg, size_t len) {
jsval_t err = js_mkstr(js, msg, len);
js_reject_promise(js, promise, err);
if (close_http) tlsuv_http_close(&req->http_client, NULL);
remove_pending_request(req); free_fetch_request(req);
return js_mkundef();
}
static jsval_t response_text(struct js *js, jsval_t *args, int nargs) {
jsval_t this = js_getthis(js);
jsval_t body = js_get_slot(js, this, SLOT_DATA);
jsval_t promise = js_mkpromise(js);
js_resolve_promise(js, promise, body);
return promise;
}
static jsval_t response_json(struct js *js, jsval_t *args, int nargs) {
jsval_t this = js_getthis(js);
jsval_t body = js_get_slot(js, this, SLOT_DATA);
jsval_t parsed = js_json_parse(js, &body, 1);
jsval_t promise = js_mkpromise(js);
if (vtype(parsed) == T_ERR) {
js_reject_promise(js, promise, parsed);
} else js_resolve_promise(js, promise, parsed);
return promise;
}
static jsval_t create_response(struct js *js, int status, const char *body, size_t body_len) {
jsval_t response_obj = js_mkobj(js);
jsval_t body_str = js_mkstr(js, body, body_len);
js_set(js, response_obj, "ok", js_bool(status >= 200 && status < 300));
js_set(js, response_obj, "status", js_mknum(status));
js_set_slot(js, response_obj, SLOT_DATA, body_str);
js_set(js, response_obj, "text", js_mkfun(response_text));
js_set(js, response_obj, "json", js_mkfun(response_json));
return response_obj;
}
static void complete_request(fetch_request_t *req) {
if (req->failed) {
jsval_t err = js_mkstr(req->js, req->error_msg ? req->error_msg : "Unknown error", req->error_msg ? strlen(req->error_msg) : 13);
js_reject_promise(req->js, req->promise, err);
} else {
const char *body = req->response_buffer.data ? req->response_buffer.data : "";
size_t body_len = req->response_buffer.data ? req->response_buffer.size : 0;
jsval_t response = create_response(req->js, req->status_code, body, body_len);
js_resolve_promise(req->js, req->promise, response);
}
remove_pending_request(req);
free_fetch_request(req);
}
static void on_http_close(tlsuv_http_t *client) {
fetch_request_t *req = (fetch_request_t *)client->data;
if (req && req->completed) complete_request(req);
}
static void body_cb(tlsuv_http_req_t *http_req, char *body, ssize_t len) {
fetch_request_t *req = (fetch_request_t *)http_req->data;
if (len == UV_EOF) {
req->completed = 1;
tlsuv_http_close(&req->http_client, on_http_close);
return;
}
if (len < 0) {
req->failed = 1;
req->error_msg = strdup(uv_strerror((int)len));
req->completed = 1;
tlsuv_http_close(&req->http_client, on_http_close);
return;
}
if (req->response_buffer.size + len > req->response_buffer.capacity) {
size_t new_capacity = req->response_buffer.capacity * 2;
while (new_capacity < req->response_buffer.size + len) new_capacity *= 2;
char *new_data = realloc(req->response_buffer.data, new_capacity);
if (!new_data) {
req->failed = 1;
req->error_msg = strdup("Out of memory");
req->completed = 1;
tlsuv_http_close(&req->http_client, on_http_close);
return;
}
req->response_buffer.data = new_data;
req->response_buffer.capacity = new_capacity;
}
memcpy(req->response_buffer.data + req->response_buffer.size, body, len);
req->response_buffer.size += len;
}
static void resp_cb(tlsuv_http_resp_t *resp, void *data) {
(void)data;
fetch_request_t *req = (fetch_request_t *)resp->req->data;
if (resp->code < 0) {
req->failed = 1;
req->error_msg = strdup(uv_strerror(resp->code));
req->completed = 1;
tlsuv_http_close(&req->http_client, on_http_close);
return;
}
req->status_code = resp->code;
resp->body_cb = body_cb;
}
static jsval_t do_fetch_microtask(struct js *js, jsval_t *args, int nargs) {
(void)args;
(void)nargs;
jsval_t current_func = js_getcurrentfunc(js);
jsval_t url_val = js_get(js, current_func, "url");
jsval_t options_val = js_get(js, current_func, "options");
jsval_t promise = js_get_slot(js, current_func, SLOT_DATA);
char *url_str = js_getstr(js, url_val, NULL);
if (!url_str) {
jsval_t err = js_mkstr(js, "Invalid URL", 11);
js_reject_promise(js, promise, err);
return js_mkundef();
}
fetch_request_t *req = calloc(1, sizeof(fetch_request_t));
if (!req) {
jsval_t err = js_mkstr(js, "Out of memory", 13);
js_reject_promise(js, promise, err);
return js_mkundef();
}
req->js = js;
req->promise = promise;
req->headers_obj = options_val;
req->response_buffer.capacity = 16384;
req->response_buffer.data = malloc(req->response_buffer.capacity);
req->response_buffer.size = 0;
if (!req->response_buffer.data) {
jsval_t err = js_mkstr(js, "Out of memory", 13);
js_reject_promise(js, promise, err);
free(req);
return js_mkundef();
}
if (!pending_requests) utarray_new(pending_requests, &ut_ptr_icd);
utarray_push_back(pending_requests, &req);
const char *scheme_end = strstr(url_str, "://");
if (!scheme_end) return fetch_fail_oom(js, promise, req, false, "Invalid URL: no scheme", 22);
const char *host_start = scheme_end + 3;
const char *path_start = strchr(host_start, '/');
const char *at_in_host = NULL;
for (const char *p = host_start; p < (path_start ? path_start : host_start + strlen(host_start)); p++) {
if (*p == '@') at_in_host = p;
} if (at_in_host) host_start = at_in_host + 1;
size_t scheme_len = scheme_end - url_str;
size_t host_len = path_start ? (size_t)(path_start - host_start) : strlen(host_start);
const char *path = path_start ? path_start : "/";
if (host_len == 0) return fetch_fail_oom(js, promise, req, false, "Invalid URL: no host", 20);
char *host_url = calloc(1, scheme_len + 3 + host_len + 1);
if (!host_url) return fetch_fail_oom(js, promise, req, false, "Out of memory", 13);
snprintf(host_url, scheme_len + 3 + host_len + 1, "%.*s://%.*s", (int)scheme_len, url_str, (int)host_len, host_start);
int rc = tlsuv_http_init(fetch_loop, &req->http_client, host_url); free(host_url);
if (rc != 0) return fetch_fail_oom(js, promise, req, false, "Failed to initialize HTTP client", 33);
req->http_client.data = req;
req->method = NULL;
req->body = NULL;
req->body_len = 0;
if (is_special_object(options_val)) {
jsval_t method_val = js_get(js, options_val, "method");
if (vtype(method_val) == T_STR) {
char *str = js_getstr(js, method_val, NULL);
if (str) {
req->method = strdup(str);
if (!req->method) return fetch_fail_oom(js, promise, req, true, "Out of memory", 13);
}
}
jsval_t body_val = js_get(js, options_val, "body");
if (vtype(body_val) == T_STR) {
size_t len;
char *str = js_getstr(js, body_val, &len);
if (str && len > 0) {
req->body = malloc(len);
if (!req->body) return fetch_fail_oom(js, promise, req, true, "Out of memory", 13);
memcpy(req->body, str, len);
req->body_len = len;
}
}
}
if (!req->method) {
req->method = strdup("GET");
if (!req->method) return fetch_fail_oom(js, promise, req, true, "Out of memory", 13);
}
req->http_req = tlsuv_http_req(&req->http_client, req->method, path, resp_cb, req);
if (!req->http_req) return fetch_fail_oom(js, promise, req, true, "Failed to create HTTP request", 30);
req->http_req->data = req;
char user_agent[256];
snprintf(user_agent, sizeof(user_agent), "ant/%s", ANT_VERSION);
tlsuv_http_req_header(req->http_req, "User-Agent", user_agent);
if (is_special_object(options_val)) {
jsval_t headers_val = js_get(js, options_val, "headers");
if (is_special_object(headers_val)) {
ant_iter_t iter = js_prop_iter_begin(js, headers_val);
const char *key;
size_t key_len;
jsval_t value;
while (js_prop_iter_next(&iter, &key, &key_len, &value)) {
char *value_str = js_getstr(js, value, NULL);
if (value_str) {
char *key_str = strndup(key, key_len);
if (key_str) { tlsuv_http_req_header(req->http_req, key_str, value_str); free(key_str); }
}
}
js_prop_iter_end(&iter);
}
}
if (req->body && req->body_len > 0) {
tlsuv_http_req_data(req->http_req, req->body, req->body_len, body_cb);
}
return js_mkundef();
}
static jsval_t js_fetch(struct js *js, jsval_t *args, int nargs) {
if (nargs < 1) return js_mkerr(js, "fetch requires at least 1 argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "fetch URL must be a string");
jsval_t url_val = args[0];
jsval_t options_val = nargs > 1 ? args[1] : js_mkundef();
jsval_t promise = js_mkpromise(js);
jsval_t wrapper_obj = js_mkobj(js);
js_set_slot(js, wrapper_obj, SLOT_CFUNC, js_mkfun(do_fetch_microtask));
js_set_slot(js, wrapper_obj, SLOT_DATA, promise);
js_set(js, wrapper_obj, "url", url_val);
js_set(js, wrapper_obj, "options", options_val);
queue_microtask(js, js_obj_to_func(wrapper_obj));
return promise;
}
void init_fetch_module() {
if (!fetch_loop) fetch_loop = uv_default_loop();
struct js *js = rt->js;
js_set(js, js_glob(js), "fetch", js_mkfun(js_fetch));
}
int has_pending_fetches(void) {
return (pending_requests && utarray_len(pending_requests) > 0) || (fetch_loop && uv_loop_alive(fetch_loop));
}
void fetch_poll_events(void) {
if (fetch_loop && fetch_loop == uv_default_loop() && (rt->flags & ANT_RUNTIME_EXT_EVENT_LOOP)) return;
if (fetch_loop && uv_loop_alive(fetch_loop)) {
uv_run(fetch_loop, fetch_loop == uv_default_loop() ? UV_RUN_NOWAIT : UV_RUN_ONCE);
if (pending_requests && utarray_len(pending_requests) > 0) usleep(1000);
}
}
void fetch_gc_update_roots(GC_OP_VAL_ARGS) {
if (!pending_requests) return;
unsigned int len = utarray_len(pending_requests);
for (unsigned int i = 0; i < len; i++) {
fetch_request_t **reqp = (fetch_request_t **)utarray_eltptr(pending_requests, i);
if (reqp && *reqp) {
op_val(ctx, &(*reqp)->promise);
op_val(ctx, &(*reqp)->headers_obj);
}
}
}

Owner Packages

  • No Owners