blob: bcaf8565b0bf11f4e7e87414cb5f33893ff62f2d [file] [log] [blame]
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) hongzhidao
* Copyright (C) NGINX, Inc.
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_event.h>
#include <ngx_event_connect.h>
#include "ngx_js.h"
typedef struct ngx_js_http_s ngx_js_http_t;
typedef struct {
ngx_uint_t state;
ngx_uint_t code;
u_char *status_text;
u_char *status_text_end;
ngx_uint_t count;
ngx_flag_t chunked;
off_t content_length_n;
u_char *header_name_start;
u_char *header_name_end;
u_char *header_start;
u_char *header_end;
} ngx_js_http_parse_t;
typedef struct {
u_char *pos;
uint64_t chunk_size;
uint8_t state;
uint8_t last;
} ngx_js_http_chunk_parse_t;
struct ngx_js_http_s {
ngx_log_t *log;
ngx_pool_t *pool;
njs_vm_t *vm;
njs_external_ptr_t external;
njs_vm_event_t vm_event;
ngx_js_event_handler_pt event_handler;
ngx_resolver_ctx_t *ctx;
ngx_addr_t addr;
ngx_addr_t *addrs;
ngx_uint_t naddrs;
ngx_uint_t naddr;
in_port_t port;
ngx_peer_connection_t peer;
ngx_msec_t timeout;
ngx_int_t buffer_size;
ngx_int_t max_response_body_size;
njs_str_t url;
ngx_array_t headers;
ngx_buf_t *buffer;
ngx_buf_t *chunk;
njs_chb_t chain;
njs_opaque_value_t reply;
njs_opaque_value_t promise;
njs_opaque_value_t promise_callbacks[2];
uint8_t done;
uint8_t body_used;
ngx_js_http_parse_t http_parse;
ngx_js_http_chunk_parse_t http_chunk_parse;
ngx_int_t (*process)(ngx_js_http_t *http);
};
#define ngx_js_http_error(http, err, fmt, ...) \
do { \
njs_vm_value_error_set((http)->vm, njs_value_arg(&(http)->reply), \
fmt, ##__VA_ARGS__); \
ngx_js_http_fetch_done(http, &(http)->reply, NJS_ERROR); \
} while (0)
static ngx_js_http_t *ngx_js_http_alloc(njs_vm_t *vm, ngx_pool_t *pool,
ngx_log_t *log);
static void ngx_js_resolve_handler(ngx_resolver_ctx_t *ctx);
static njs_int_t ngx_js_fetch_result(njs_vm_t *vm, ngx_js_http_t *http,
njs_value_t *result, njs_int_t rc);
static njs_int_t ngx_js_fetch_promissified_result(njs_vm_t *vm,
njs_value_t *result, njs_int_t rc);
static void ngx_js_http_fetch_done(ngx_js_http_t *http,
njs_opaque_value_t *retval, njs_int_t rc);
static njs_int_t ngx_js_http_promise_trampoline(njs_vm_t *vm,
njs_value_t *args, njs_uint_t nargs, njs_index_t unused);
static njs_int_t ngx_js_http_connect(ngx_js_http_t *http);
static njs_int_t ngx_js_http_next(ngx_js_http_t *http);
static void ngx_js_http_write_handler(ngx_event_t *wev);
static void ngx_js_http_read_handler(ngx_event_t *rev);
static ngx_int_t ngx_js_http_process_status_line(ngx_js_http_t *http);
static ngx_int_t ngx_js_http_process_headers(ngx_js_http_t *http);
static ngx_int_t ngx_js_http_process_body(ngx_js_http_t *http);
static ngx_int_t ngx_js_http_parse_status_line(ngx_js_http_parse_t *hp,
ngx_buf_t *b);
static ngx_int_t ngx_js_http_parse_header_line(ngx_js_http_parse_t *hp,
ngx_buf_t *b);
static ngx_int_t ngx_js_http_parse_chunked(ngx_js_http_chunk_parse_t *hcp,
ngx_buf_t *b, njs_chb_t *chain);
static void ngx_js_http_dummy_handler(ngx_event_t *ev);
static njs_int_t ngx_response_js_ext_headers_get(njs_vm_t *vm,
njs_value_t *args, njs_uint_t nargs, njs_index_t as_array);
static njs_int_t ngx_response_js_ext_headers_has(njs_vm_t *vm,
njs_value_t *args, njs_uint_t nargs, njs_index_t unused);
static njs_int_t ngx_response_js_ext_header(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_keys(njs_vm_t *vm, njs_value_t *value,
njs_value_t *keys);
static njs_int_t ngx_response_js_ext_status(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_status_text(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_ok(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_body_used(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_type(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
static njs_int_t ngx_response_js_ext_body(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused);
static njs_external_t ngx_js_ext_http_response_headers[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Headers",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("get"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_headers_get,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("getAll"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_headers_get,
.magic8 = 1
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("has"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_headers_has,
}
},
};
static njs_external_t ngx_js_ext_http_response[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Response",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("arrayBuffer"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_body,
#define NGX_JS_BODY_ARRAY_BUFFER 0
#define NGX_JS_BODY_JSON 1
#define NGX_JS_BODY_TEXT 2
.magic8 = NGX_JS_BODY_ARRAY_BUFFER
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("bodyUsed"),
.enumerable = 1,
.u.property = {
.handler = ngx_response_js_ext_body_used,
}
},
{
.flags = NJS_EXTERN_OBJECT,
.name.string = njs_str("headers"),
.enumerable = 1,
.u.object = {
.enumerable = 1,
.properties = ngx_js_ext_http_response_headers,
.nproperties = njs_nitems(ngx_js_ext_http_response_headers),
.prop_handler = ngx_response_js_ext_header,
.keys = ngx_response_js_ext_keys,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("json"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_body,
.magic8 = NGX_JS_BODY_JSON
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("ok"),
.enumerable = 1,
.u.property = {
.handler = ngx_response_js_ext_ok,
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("redirected"),
.enumerable = 1,
.u.property = {
.handler = ngx_js_ext_boolean,
.magic32 = 0,
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("status"),
.enumerable = 1,
.u.property = {
.handler = ngx_response_js_ext_status,
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("statusText"),
.enumerable = 1,
.u.property = {
.handler = ngx_response_js_ext_status_text,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("text"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = ngx_response_js_ext_body,
.magic8 = NGX_JS_BODY_TEXT
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("type"),
.enumerable = 1,
.u.property = {
.handler = ngx_response_js_ext_type,
}
},
{
.flags = NJS_EXTERN_PROPERTY,
.name.string = njs_str("url"),
.enumerable = 1,
.u.property = {
.handler = ngx_js_ext_string,
.magic32 = offsetof(ngx_js_http_t, url),
}
},
};
njs_int_t
ngx_js_ext_fetch(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
int64_t i, length;
njs_int_t ret;
njs_str_t method, body, name, header;
ngx_url_t u;
njs_bool_t has_host;
ngx_pool_t *pool;
njs_value_t *init, *value, *headers, *keys;
ngx_js_http_t *http;
ngx_connection_t *c;
ngx_resolver_ctx_t *ctx;
njs_external_ptr_t external;
njs_opaque_value_t *start, lvalue, headers_value;
static const njs_str_t body_key = njs_str("body");
static const njs_str_t headers_key = njs_str("headers");
static const njs_str_t buffer_size_key = njs_str("buffer_size");
static const njs_str_t body_size_key = njs_str("max_response_body_size");
static const njs_str_t method_key = njs_str("method");
external = njs_vm_external(vm, njs_argument(args, 0));
if (external == NULL) {
njs_vm_error(vm, "\"this\" is not an external");
return NJS_ERROR;
}
c = ngx_external_connection(vm, external);
pool = ngx_external_pool(vm, external);
http = ngx_js_http_alloc(vm, pool, c->log);
if (http == NULL) {
return NJS_ERROR;
}
http->external = external;
http->event_handler = ngx_external_event_handler(vm, external);
http->buffer_size = 4096;
http->max_response_body_size = 32 * 1024;
ret = ngx_js_string(vm, njs_arg(args, nargs, 1), &http->url);
if (ret != NJS_OK) {
njs_vm_error(vm, "failed to convert url arg");
goto fail;
}
ngx_memzero(&u, sizeof(ngx_url_t));
u.url.len = http->url.length;
u.url.data = http->url.start;
u.default_port = 80;
u.uri_part = 1;
u.no_resolve = 1;
if (u.url.len > 7
&& ngx_strncasecmp(u.url.data, (u_char *) "http://", 7) == 0)
{
u.url.len -= 7;
u.url.data += 7;
} else {
njs_vm_error(vm, "unsupported URL prefix");
goto fail;
}
if (ngx_parse_url(pool, &u) != NGX_OK) {
njs_vm_error(vm, "invalid url");
goto fail;
}
init = njs_arg(args, nargs, 2);
method = njs_str_value("GET");
body = njs_str_value("");
headers = NULL;
if (njs_value_is_object(init)) {
value = njs_vm_object_prop(vm, init, &method_key, &lvalue);
if (value != NULL && ngx_js_string(vm, value, &method) != NGX_OK) {
goto fail;
}
headers = njs_vm_object_prop(vm, init, &headers_key, &headers_value);
if (headers != NULL && !njs_value_is_object(headers)) {
njs_vm_error(vm, "headers is not an object");
goto fail;
}
value = njs_vm_object_prop(vm, init, &body_key, &lvalue);
if (value != NULL && ngx_js_string(vm, value, &body) != NGX_OK) {
goto fail;
}
value = njs_vm_object_prop(vm, init, &buffer_size_key, &lvalue);
if (value != NULL
&& ngx_js_integer(vm, value, &http->buffer_size)
!= NGX_OK)
{
goto fail;
}
value = njs_vm_object_prop(vm, init, &body_size_key, &lvalue);
if (value != NULL
&& ngx_js_integer(vm, value, &http->max_response_body_size)
!= NGX_OK)
{
goto fail;
}
}
njs_chb_init(&http->chain, njs_vm_memory_pool(vm));
njs_chb_append(&http->chain, method.start, method.length);
njs_chb_append_literal(&http->chain, " ");
if (u.uri.len == 0 || u.uri.data[0] != '/') {
njs_chb_append_literal(&http->chain, "/");
}
njs_chb_append(&http->chain, u.uri.data, u.uri.len);
njs_chb_append_literal(&http->chain, " HTTP/1.1" CRLF);
njs_chb_append_literal(&http->chain, "Connection: close" CRLF);
has_host = 0;
if (headers != NULL) {
keys = njs_vm_object_keys(vm, headers, njs_value_arg(&lvalue));
if (keys == NULL) {
goto fail;
}
start = (njs_opaque_value_t *) njs_vm_array_start(vm, keys);
if (start == NULL) {
goto fail;
}
(void) njs_vm_array_length(vm, keys, &length);
for (i = 0; i < length; i++) {
if (ngx_js_string(vm, njs_value_arg(start), &name) != NGX_OK) {
goto fail;
}
start++;
value = njs_vm_object_prop(vm, headers, &name, &lvalue);
if (ret != NJS_OK) {
goto fail;
}
if (njs_value_is_null_or_undefined(value)) {
continue;
}
if (ngx_js_string(vm, value, &header) != NGX_OK) {
goto fail;
}
if (name.length == 4
&& ngx_strncasecmp(name.start, (u_char *) "Host", 4) == 0)
{
has_host = 1;
}
njs_chb_append(&http->chain, name.start, name.length);
njs_chb_append_literal(&http->chain, ": ");
njs_chb_append(&http->chain, header.start, header.length);
njs_chb_append_literal(&http->chain, CRLF);
}
}
if (!has_host) {
njs_chb_append_literal(&http->chain, "Host: ");
njs_chb_append(&http->chain, u.host.data, u.host.len);
njs_chb_append_literal(&http->chain, CRLF);
}
if (body.length != 0) {
njs_chb_sprintf(&http->chain, 32, "Content-Length: %uz" CRLF CRLF,
body.length);
njs_chb_append(&http->chain, body.start, body.length);
} else {
njs_chb_append_literal(&http->chain, CRLF);
}
if (u.addrs == NULL) {
ctx = ngx_resolve_start(ngx_external_resolver(vm, external), NULL);
if (ctx == NULL) {
njs_vm_memory_error(vm);
return NJS_ERROR;
}
if (ctx == NGX_NO_RESOLVER) {
njs_vm_error(vm, "no resolver defined");
goto fail;
}
http->ctx = ctx;
http->port = u.port;
ctx->name = u.host;
ctx->handler = ngx_js_resolve_handler;
ctx->data = http;
ctx->timeout = ngx_external_resolver_timeout(vm, external);
ret = ngx_resolve_name(http->ctx);
if (ret != NGX_OK) {
http->ctx = NULL;
njs_vm_memory_error(vm);
return NJS_ERROR;
}
} else {
http->naddrs = 1;
ngx_memcpy(&http->addr, &u.addrs[0], sizeof(ngx_addr_t));
http->addrs = &http->addr;
ret = ngx_js_http_connect(http);
}
return ngx_js_fetch_result(vm, http, njs_value_arg(&http->reply), ret);
fail:
return ngx_js_fetch_result(vm, http, njs_vm_retval(vm), NJS_ERROR);
}
static ngx_js_http_t *
ngx_js_http_alloc(njs_vm_t *vm, ngx_pool_t *pool, ngx_log_t *log)
{
ngx_js_http_t *http;
http = ngx_pcalloc(pool, sizeof(ngx_js_http_t));
if (http == NULL) {
goto failed;
}
http->pool = pool;
http->log = log;
http->vm = vm;
http->timeout = 10000;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, log, 0, "js http alloc:%p", http);
return http;
failed:
njs_vm_error(vm, "internal error");
return NULL;
}
static void
ngx_js_resolve_handler(ngx_resolver_ctx_t *ctx)
{
u_char *p;
size_t len;
socklen_t socklen;
ngx_uint_t i;
ngx_js_http_t *http;
struct sockaddr *sockaddr;
http = ctx->data;
if (ctx->state) {
ngx_js_http_error(http, 0, "\"%V\" could not be resolved (%i: %s)",
&ctx->name, ctx->state,
ngx_resolver_strerror(ctx->state));
return;
}
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, http->log, 0,
"http fetch resolved: \"%V\"", &ctx->name);
#if (NGX_DEBUG)
{
u_char text[NGX_SOCKADDR_STRLEN];
ngx_str_t addr;
ngx_uint_t i;
addr.data = text;
for (i = 0; i < ctx->naddrs; i++) {
addr.len = ngx_sock_ntop(ctx->addrs[i].sockaddr, ctx->addrs[i].socklen,
text, NGX_SOCKADDR_STRLEN, 0);
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, http->log, 0,
"name was resolved to \"%V\"", &addr);
}
}
#endif
http->naddrs = ctx->naddrs;
http->addrs = ngx_pcalloc(http->pool, http->naddrs * sizeof(ngx_addr_t));
if (http->addrs == NULL) {
goto failed;
}
for (i = 0; i < ctx->naddrs; i++) {
socklen = ctx->addrs[i].socklen;
sockaddr = ngx_palloc(http->pool, socklen);
if (sockaddr == NULL) {
goto failed;
}
ngx_memcpy(sockaddr, ctx->addrs[i].sockaddr, socklen);
ngx_inet_set_port(sockaddr, http->port);
http->addrs[i].sockaddr = sockaddr;
http->addrs[i].socklen = socklen;
p = ngx_pnalloc(http->pool, NGX_SOCKADDR_STRLEN);
if (p == NULL) {
goto failed;
}
len = ngx_sock_ntop(sockaddr, socklen, p, NGX_SOCKADDR_STRLEN, 1);
http->addrs[i].name.len = len;
http->addrs[i].name.data = p;
}
ngx_resolve_name_done(ctx);
http->ctx = NULL;
(void) ngx_js_http_connect(http);
return;
failed:
ngx_js_http_error(http, 0, "memory error");
}
static void
njs_js_http_destructor(njs_external_ptr_t external, njs_host_event_t host)
{
ngx_js_http_t *http;
http = host;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, http->log, 0, "js http destructor:%p",
http);
if (http->ctx != NULL) {
ngx_resolve_name_done(http->ctx);
http->ctx = NULL;
}
if (http->peer.connection != NULL) {
ngx_close_connection(http->peer.connection);
http->peer.connection = NULL;
}
}
static njs_int_t
ngx_js_fetch_result(njs_vm_t *vm, ngx_js_http_t *http, njs_value_t *result,
njs_int_t rc)
{
njs_int_t ret;
njs_function_t *callback;
njs_vm_event_t vm_event;
njs_opaque_value_t arguments[2];
ret = njs_vm_promise_create(vm, njs_value_arg(&http->promise),
njs_value_arg(&http->promise_callbacks));
if (ret != NJS_OK) {
goto error;
}
callback = njs_vm_function_alloc(vm, ngx_js_http_promise_trampoline);
if (callback == NULL) {
goto error;
}
vm_event = njs_vm_add_event(vm, callback, 1, http, njs_js_http_destructor);
if (vm_event == NULL) {
goto error;
}
http->vm_event = vm_event;
if (rc == NJS_ERROR) {
njs_value_assign(&arguments[0], &http->promise_callbacks[1]);
njs_value_assign(&arguments[1], result);
ret = njs_vm_post_event(vm, vm_event, njs_value_arg(&arguments), 2);
if (ret == NJS_ERROR) {
goto error;
}
}
njs_vm_retval_set(vm, njs_value_arg(&http->promise));
return NJS_OK;
error:
njs_vm_error(vm, "internal error");
return NJS_ERROR;
}
static njs_int_t
ngx_js_fetch_promissified_result(njs_vm_t *vm, njs_value_t *result,
njs_int_t rc)
{
njs_int_t ret;
njs_function_t *callback;
njs_vm_event_t vm_event;
njs_opaque_value_t retval, arguments[2];
ret = njs_vm_promise_create(vm, njs_value_arg(&retval),
njs_value_arg(&arguments));
if (ret != NJS_OK) {
goto error;
}
callback = njs_vm_function_alloc(vm, ngx_js_http_promise_trampoline);
if (callback == NULL) {
goto error;
}
vm_event = njs_vm_add_event(vm, callback, 1, NULL, NULL);
if (vm_event == NULL) {
goto error;
}
njs_value_assign(&arguments[0], &arguments[(rc != NJS_OK)]);
njs_value_assign(&arguments[1], result);
ret = njs_vm_post_event(vm, vm_event, njs_value_arg(&arguments), 2);
if (ret == NJS_ERROR) {
goto error;
}
njs_vm_retval_set(vm, njs_value_arg(&retval));
return NJS_OK;
error:
njs_vm_error(vm, "internal error");
return NJS_ERROR;
}
static void
ngx_js_http_fetch_done(ngx_js_http_t *http, njs_opaque_value_t *retval,
njs_int_t rc)
{
njs_opaque_value_t arguments[2], *action;
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, http->log, 0,
"js fetch done http:%p rc:%i", http, (ngx_int_t) rc);
if (http->peer.connection != NULL) {
ngx_close_connection(http->peer.connection);
http->peer.connection = NULL;
}
if (http->vm_event != NULL) {
action = &http->promise_callbacks[(rc != NJS_OK)];
njs_value_assign(&arguments[0], action);
njs_value_assign(&arguments[1], retval);
http->event_handler(http->external, http->vm_event,
njs_value_arg(&arguments), 2);
}
}
static njs_int_t
ngx_js_http_promise_trampoline(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
njs_function_t *callback;
callback = njs_value_function(njs_argument(args, 1));
if (callback != NULL) {
return njs_vm_call(vm, callback, njs_argument(args, 2), 1);
}
return NJS_OK;
}
static njs_int_t
ngx_js_http_connect(ngx_js_http_t *http)
{
ngx_int_t rc;
ngx_addr_t *addr;
addr = &http->addrs[http->naddr];
ngx_log_debug2(NGX_LOG_DEBUG_EVENT, http->log, 0,
"js http connect %ui/%ui", http->naddr, http->naddrs);
http->peer.sockaddr = addr->sockaddr;
http->peer.socklen = addr->socklen;
http->peer.name = &addr->name;
http->peer.get = ngx_event_get_peer;
http->peer.log = http->log;
http->peer.log_error = NGX_ERROR_ERR;
rc = ngx_event_connect_peer(&http->peer);
if (rc == NGX_ERROR) {
ngx_js_http_error(http, 0, "connect failed");
return NJS_ERROR;
}
if (rc == NGX_BUSY || rc == NGX_DECLINED) {
return ngx_js_http_next(http);
}
http->peer.connection->data = http;
http->peer.connection->pool = http->pool;
http->peer.connection->write->handler = ngx_js_http_write_handler;
http->peer.connection->read->handler = ngx_js_http_read_handler;
http->process = ngx_js_http_process_status_line;
if (http->timeout) {
ngx_add_timer(http->peer.connection->read, http->timeout);
ngx_add_timer(http->peer.connection->write, http->timeout);
}
if (rc == NGX_OK) {
ngx_js_http_write_handler(http->peer.connection->write);
}
return NJS_OK;
}
static njs_int_t
ngx_js_http_next(ngx_js_http_t *http)
{
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, http->log, 0, "js http next");
if (++http->naddr >= http->naddrs) {
ngx_js_http_error(http, 0, "connect failed");
return NJS_ERROR;
}
if (http->peer.connection != NULL) {
ngx_close_connection(http->peer.connection);
http->peer.connection = NULL;
}
http->buffer = NULL;
return ngx_js_http_connect(http);
}
static void
ngx_js_http_write_handler(ngx_event_t *wev)
{
ssize_t n, size;
ngx_buf_t *b;
ngx_js_http_t *http;
ngx_connection_t *c;
c = wev->data;
http = c->data;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, wev->log, 0, "js http write handler");
if (wev->timedout) {
ngx_js_http_error(http, NGX_ETIMEDOUT, "write timed out");
return;
}
b = http->buffer;
if (b == NULL) {
size = njs_chb_size(&http->chain);
if (size < 0) {
ngx_js_http_error(http, 0, "memory error");
return;
}
b = ngx_create_temp_buf(http->pool, size);
if (b == NULL) {
ngx_js_http_error(http, 0, "memory error");
return;
}
njs_chb_join_to(&http->chain, b->last);
b->last += size;
http->buffer = b;
}
size = b->last - b->pos;
n = ngx_send(c, b->pos, size);
if (n == NGX_ERROR) {
(void) ngx_js_http_next(http);
return;
}
if (n > 0) {
b->pos += n;
if (n == size) {
wev->handler = ngx_js_http_dummy_handler;
http->buffer = NULL;
if (wev->timer_set) {
ngx_del_timer(wev);
}
if (ngx_handle_write_event(wev, 0) != NGX_OK) {
ngx_js_http_error(http, 0, "write failed");
}
return;
}
}
if (!wev->timer_set && http->timeout) {
ngx_add_timer(wev, http->timeout);
}
}
static void
ngx_js_http_read_handler(ngx_event_t *rev)
{
ssize_t n, size;
ngx_int_t rc;
ngx_buf_t *b;
ngx_js_http_t *http;
ngx_connection_t *c;
c = rev->data;
http = c->data;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, rev->log, 0, "js http read handler");
if (rev->timedout) {
ngx_js_http_error(http, NGX_ETIMEDOUT, "read timed out");
return;
}
if (http->buffer == NULL) {
b = ngx_create_temp_buf(http->pool, http->buffer_size);
if (b == NULL) {
ngx_js_http_error(http, 0, "memory error");
return;
}
http->buffer = b;
}
for ( ;; ) {
b = http->buffer;
size = b->end - b->last;
n = ngx_recv(c, b->last, size);
if (n > 0) {
b->last += n;
rc = http->process(http);
if (rc == NGX_ERROR) {
return;
}
continue;
}
if (n == NGX_AGAIN) {
if (ngx_handle_read_event(rev, 0) != NGX_OK) {
ngx_js_http_error(http, 0, "read failed");
}
return;
}
if (n == NGX_ERROR) {
(void) ngx_js_http_next(http);
return;
}
break;
}
http->done = 1;
rc = http->process(http);
if (rc == NGX_DONE) {
/* handler was called */
return;
}
if (rc == NGX_AGAIN) {
ngx_js_http_error(http, 0, "prematurely closed connection");
}
}
static ngx_int_t
ngx_js_http_process_status_line(ngx_js_http_t *http)
{
ngx_int_t rc;
ngx_js_http_parse_t *hp;
hp = &http->http_parse;
rc = ngx_js_http_parse_status_line(hp, http->buffer);
if (rc == NGX_OK) {
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, http->log, 0, "js http status %ui",
hp->code);
http->process = ngx_js_http_process_headers;
return http->process(http);
}
if (rc == NGX_AGAIN) {
return NGX_AGAIN;
}
/* rc == NGX_ERROR */
ngx_js_http_error(http, 0, "invalid fetch status line");
return NGX_ERROR;
}
static ngx_int_t
ngx_js_http_process_headers(ngx_js_http_t *http)
{
ngx_int_t rc;
ngx_table_elt_t *h;
ngx_js_http_parse_t *hp;
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, http->log, 0,
"js http process headers");
hp = &http->http_parse;
if (http->headers.size == 0) {
rc = ngx_array_init(&http->headers, http->pool, 4,
sizeof(ngx_table_elt_t));
if (rc != NGX_OK) {
return NGX_ERROR;
}
}
for ( ;; ) {
rc = ngx_js_http_parse_header_line(hp, http->buffer);
if (rc == NGX_OK) {
h = ngx_array_push(&http->headers);
if (h == NULL) {
return NGX_ERROR;
}
h->hash = 1;
h->key.data = hp->header_name_start;
h->key.len = hp->header_name_end - hp->header_name_start;
h->value.data = hp->header_start;
h->value.len = hp->header_end - hp->header_start;
ngx_log_debug4(NGX_LOG_DEBUG_EVENT, http->log, 0,
"js http header \"%*s: %*s\"",
h->key.len, h->key.data, h->value.len,
h->value.data);
if (h->key.len == njs_strlen("Transfer-Encoding")
&& h->value.len == njs_strlen("chunked")
&& ngx_strncasecmp(h->key.data, (u_char *) "Transfer-Encoding",
h->key.len) == 0
&& ngx_strncasecmp(h->value.data, (u_char *) "chunked",
h->value.len) == 0)
{
hp->chunked = 1;
}
if (h->key.len == njs_strlen("Content-Length")
&& ngx_strncasecmp(h->key.data, (u_char *) "Content-Length",
h->key.len) == 0)
{
hp->content_length_n = ngx_atoof(h->value.data, h->value.len);
if (hp->content_length_n == NGX_ERROR) {
ngx_js_http_error(http, 0, "invalid fetch content length");
return NGX_ERROR;
}
if (hp->content_length_n
> (off_t) http->max_response_body_size)
{
ngx_js_http_error(http, 0,
"fetch content length is too large");
return NGX_ERROR;
}
}
continue;
}
if (rc == NGX_DONE) {
break;
}
if (rc == NGX_AGAIN) {
return NGX_AGAIN;
}
/* rc == NGX_ERROR */
ngx_js_http_error(http, 0, "invalid fetch header");
return NGX_ERROR;
}
njs_chb_destroy(&http->chain);
njs_chb_init(&http->chain, njs_vm_memory_pool(http->vm));
http->process = ngx_js_http_process_body;
return http->process(http);
}
static ngx_int_t
ngx_js_http_process_body(ngx_js_http_t *http)
{
ssize_t size, need;
ngx_int_t rc;
njs_int_t ret;
ngx_buf_t *b;
ngx_log_debug1(NGX_LOG_DEBUG_EVENT, http->log, 0,
"js http process body done:%ui", (ngx_uint_t) http->done);
if (http->done) {
size = njs_chb_size(&http->chain);
if (size < 0) {
ngx_js_http_error(http, 0, "memory error");
return NGX_ERROR;
}
if (size == http->http_parse.content_length_n) {
ret = njs_vm_external_create(http->vm, njs_value_arg(&http->reply),
NGX_JS_PROTO_RESPONSE, http, 0);
if (ret != NJS_OK) {
ngx_js_http_error(http, 0, "fetch object creation failed");
return NGX_ERROR;
}
ngx_js_http_fetch_done(http, &http->reply, NJS_OK);
return NGX_DONE;
}
if (http->http_parse.chunked
&& http->http_parse.content_length_n == 0)
{
ngx_js_http_error(http, 0, "invalid fetch chunked response");
return NGX_ERROR;
}
if (size < http->http_parse.content_length_n) {
return NGX_AGAIN;
}
ngx_js_http_error(http, 0, "fetch trailing data");
return NGX_ERROR;
}
b = http->buffer;
if (http->http_parse.chunked) {
rc = ngx_js_http_parse_chunked(&http->http_chunk_parse, b,
&http->chain);
if (rc == NGX_ERROR) {
ngx_js_http_error(http, 0, "invalid fetch chunked response");
return NGX_ERROR;
}
size = njs_chb_size(&http->chain);
if (rc == NGX_OK) {
http->http_parse.content_length_n = size;
}
if (size > http->max_response_body_size * 10) {
ngx_js_http_error(http, 0, "very large fetch chunked response");
return NGX_ERROR;
}
b->pos = http->http_chunk_parse.pos;
} else {
need = http->http_parse.content_length_n - njs_chb_size(&http->chain);
size = ngx_min(need, b->last - b->pos);
if (size > 0) {
njs_chb_append(&http->chain, b->pos, size);
b->pos += size;
rc = NGX_AGAIN;
} else {
rc = NGX_DONE;
}
}
if (b->pos == b->end) {
if (http->chunk == NULL) {
b = ngx_create_temp_buf(http->pool, http->buffer_size);
if (b == NULL) {
ngx_js_http_error(http, 0, "memory error");
return NGX_ERROR;
}
http->buffer = b;
http->chunk = b;
} else {
b->last = b->start;
b->pos = b->start;
}
}
return rc;
}
static ngx_int_t
ngx_js_http_parse_status_line(ngx_js_http_parse_t *hp, ngx_buf_t *b)
{
u_char ch;
u_char *p;
enum {
sw_start = 0,
sw_H,
sw_HT,
sw_HTT,
sw_HTTP,
sw_first_major_digit,
sw_major_digit,
sw_first_minor_digit,
sw_minor_digit,
sw_status,
sw_space_after_status,
sw_status_text,
sw_almost_done
} state;
state = hp->state;
for (p = b->pos; p < b->last; p++) {
ch = *p;
switch (state) {
/* "HTTP/" */
case sw_start:
switch (ch) {
case 'H':
state = sw_H;
break;
default:
return NGX_ERROR;
}
break;
case sw_H:
switch (ch) {
case 'T':
state = sw_HT;
break;
default:
return NGX_ERROR;
}
break;
case sw_HT:
switch (ch) {
case 'T':
state = sw_HTT;
break;
default:
return NGX_ERROR;
}
break;
case sw_HTT:
switch (ch) {
case 'P':
state = sw_HTTP;
break;
default:
return NGX_ERROR;
}
break;
case sw_HTTP:
switch (ch) {
case '/':
state = sw_first_major_digit;
break;
default:
return NGX_ERROR;
}
break;
/* the first digit of major HTTP version */
case sw_first_major_digit:
if (ch < '1' || ch > '9') {
return NGX_ERROR;
}
state = sw_major_digit;
break;
/* the major HTTP version or dot */
case sw_major_digit:
if (ch == '.') {
state = sw_first_minor_digit;
break;
}
if (ch < '0' || ch > '9') {
return NGX_ERROR;
}
break;
/* the first digit of minor HTTP version */
case sw_first_minor_digit:
if (ch < '0' || ch > '9') {
return NGX_ERROR;
}
state = sw_minor_digit;
break;
/* the minor HTTP version or the end of the request line */
case sw_minor_digit:
if (ch == ' ') {
state = sw_status;
break;
}
if (ch < '0' || ch > '9') {
return NGX_ERROR;
}
break;
/* HTTP status code */
case sw_status:
if (ch == ' ') {
break;
}
if (ch < '0' || ch > '9') {
return NGX_ERROR;
}
hp->code = hp->code * 10 + (ch - '0');
if (++hp->count == 3) {
state = sw_space_after_status;
}
break;
/* space or end of line */
case sw_space_after_status:
switch (ch) {
case ' ':
state = sw_status_text;
break;
case '.': /* IIS may send 403.1, 403.2, etc */
state = sw_status_text;
break;
case CR:
break;
case LF:
goto done;
default:
return NGX_ERROR;
}
break;
/* any text until end of line */
case sw_status_text:
switch (ch) {
case CR:
hp->status_text_end = p;
state = sw_almost_done;
break;
case LF:
hp->status_text_end = p;
goto done;
}
if (hp->status_text == NULL) {
hp->status_text = p;
}
break;
/* end of status line */
case sw_almost_done:
switch (ch) {
case LF:
goto done;
default:
return NGX_ERROR;
}
}
}
b->pos = p;
hp->state = state;
return NGX_AGAIN;
done:
b->pos = p + 1;
hp->state = sw_start;
return NGX_OK;
}
static ngx_int_t
ngx_js_http_parse_header_line(ngx_js_http_parse_t *hp, ngx_buf_t *b)
{
u_char c, ch, *p;
enum {
sw_start = 0,
sw_name,
sw_space_before_value,
sw_value,
sw_space_after_value,
sw_almost_done,
sw_header_almost_done
} state;
state = hp->state;
for (p = b->pos; p < b->last; p++) {
ch = *p;
switch (state) {
/* first char */
case sw_start:
switch (ch) {
case CR:
hp->header_end = p;
state = sw_header_almost_done;
break;
case LF:
hp->header_end = p;
goto header_done;
default:
state = sw_name;
hp->header_name_start = p;
c = (u_char) (ch | 0x20);
if (c >= 'a' && c <= 'z') {
break;
}
if (ch >= '0' && ch <= '9') {
break;
}
return NGX_ERROR;
}
break;
/* header name */
case sw_name:
c = (u_char) (ch | 0x20);
if (c >= 'a' && c <= 'z') {
break;
}
if (ch == ':') {
hp->header_name_end = p;
state = sw_space_before_value;
break;
}
if (ch == '-') {
break;
}
if (ch >= '0' && ch <= '9') {
break;
}
if (ch == CR) {
hp->header_name_end = p;
hp->header_start = p;
hp->header_end = p;
state = sw_almost_done;
break;
}
if (ch == LF) {
hp->header_name_end = p;
hp->header_start = p;
hp->header_end = p;
goto done;
}
return NGX_ERROR;
/* space* before header value */
case sw_space_before_value:
switch (ch) {
case ' ':
break;
case CR:
hp->header_start = p;
hp->header_end = p;
state = sw_almost_done;
break;
case LF:
hp->header_start = p;
hp->header_end = p;
goto done;
default:
hp->header_start = p;
state = sw_value;
break;
}
break;
/* header value */
case sw_value:
switch (ch) {
case ' ':
hp->header_end = p;
state = sw_space_after_value;
break;
case CR:
hp->header_end = p;
state = sw_almost_done;
break;
case LF:
hp->header_end = p;
goto done;
}
break;
/* space* before end of header line */
case sw_space_after_value:
switch (ch) {
case ' ':
break;
case CR:
state = sw_almost_done;
break;
case LF:
goto done;
default:
state = sw_value;
break;
}
break;
/* end of header line */
case sw_almost_done:
switch (ch) {
case LF:
goto done;
default:
return NGX_ERROR;
}
/* end of header */
case sw_header_almost_done:
switch (ch) {
case LF:
goto header_done;
default:
return NGX_ERROR;
}
}
}
b->pos = p;
hp->state = state;
return NGX_AGAIN;
done:
b->pos = p + 1;
hp->state = sw_start;
return NGX_OK;
header_done:
b->pos = p + 1;
hp->state = sw_start;
return NGX_DONE;
}
#define \
ngx_size_is_sufficient(cs) \
(cs < ((__typeof__(cs)) 1 << (sizeof(cs) * 8 - 4)))
#define NGX_JS_HTTP_CHUNK_MIDDLE 0
#define NGX_JS_HTTP_CHUNK_ON_BORDER 1
#define NGX_JS_HTTP_CHUNK_END 2
static ngx_int_t
ngx_js_http_chunk_buffer(ngx_js_http_chunk_parse_t *hcp, ngx_buf_t *b,
njs_chb_t *chain)
{
size_t size;
size = b->last - hcp->pos;
if (hcp->chunk_size < size) {
njs_chb_append(chain, hcp->pos, hcp->chunk_size);
hcp->pos += hcp->chunk_size;
return NGX_JS_HTTP_CHUNK_END;
}
njs_chb_append(chain, hcp->pos, size);
hcp->pos += size;
hcp->chunk_size -= size;
if (hcp->chunk_size == 0) {
return NGX_JS_HTTP_CHUNK_ON_BORDER;
}
return NGX_JS_HTTP_CHUNK_MIDDLE;
}
static ngx_int_t
ngx_js_http_parse_chunked(ngx_js_http_chunk_parse_t *hcp,
ngx_buf_t *b, njs_chb_t *chain)
{
u_char c, ch;
ngx_int_t rc;
enum {
sw_start = 0,
sw_chunk_size,
sw_chunk_size_linefeed,
sw_chunk_end_newline,
sw_chunk_end_linefeed,
sw_chunk,
} state;
state = hcp->state;
hcp->pos = b->pos;
while (hcp->pos < b->last) {
/*
* The sw_chunk state is tested outside the switch
* to preserve hcp->pos and to not touch memory.
*/
if (state == sw_chunk) {
rc = ngx_js_http_chunk_buffer(hcp, b, chain);
if (rc == NGX_ERROR) {
return rc;
}
if (rc == NGX_JS_HTTP_CHUNK_MIDDLE) {
break;
}
state = sw_chunk_end_newline;
if (rc == NGX_JS_HTTP_CHUNK_ON_BORDER) {
break;
}
/* rc == NGX_JS_HTTP_CHUNK_END */
}
ch = *hcp->pos++;
switch (state) {
case sw_start:
state = sw_chunk_size;
c = ch - '0';
if (c <= 9) {
hcp->chunk_size = c;
continue;
}
c = (ch | 0x20) - 'a';
if (c <= 5) {
hcp->chunk_size = 0x0A + c;
continue;
}
return NGX_ERROR;
case sw_chunk_size:
c = ch - '0';
if (c > 9) {
c = (ch | 0x20) - 'a';
if (c <= 5) {
c += 0x0A;
} else if (ch == '\r') {
state = sw_chunk_size_linefeed;
continue;
} else {
return NGX_ERROR;
}
}
if (ngx_size_is_sufficient(hcp->chunk_size)) {
hcp->chunk_size = (hcp->chunk_size << 4) + c;
continue;
}
return NGX_ERROR;
case sw_chunk_size_linefeed:
if (ch == '\n') {
if (hcp->chunk_size != 0) {
state = sw_chunk;
continue;
}
hcp->last = 1;
state = sw_chunk_end_newline;
continue;
}
return NGX_ERROR;
case sw_chunk_end_newline:
if (ch == '\r') {
state = sw_chunk_end_linefeed;
continue;
}
return NGX_ERROR;
case sw_chunk_end_linefeed:
if (ch == '\n') {
if (!hcp->last) {
state = sw_start;
continue;
}
return NGX_OK;
}
return NGX_ERROR;
case sw_chunk:
/*
* This state is processed before the switch.
* It added here just to suppress a warning.
*/
continue;
}
}
hcp->state = state;
return NGX_AGAIN;
}
static void
ngx_js_http_dummy_handler(ngx_event_t *ev)
{
ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, 0, "js http dummy handler");
}
static njs_int_t
ngx_response_js_ext_header_get(njs_vm_t *vm, njs_value_t *value,
njs_str_t *name, njs_value_t *retval, njs_bool_t as_array)
{
u_char *data, *p, *start, *end;
size_t len;
njs_int_t rc;
ngx_uint_t i;
ngx_js_http_t *http;
ngx_table_elt_t *header, *h;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_null_set(retval);
return NJS_DECLINED;
}
p = NULL;
start = NULL;
end = NULL;
if (as_array) {
rc = njs_vm_array_alloc(vm, retval, 2);
if (rc != NJS_OK) {
return NJS_ERROR;
}
}
header = http->headers.elts;
for (i = 0; i < http->headers.nelts; i++) {
h = &header[i];
if (h->hash == 0
|| h->key.len != name->length
|| ngx_strncasecmp(h->key.data, name->start, name->length) != 0)
{
continue;
}
if (as_array) {
value = njs_vm_array_push(vm, retval);
if (value == NULL) {
return NJS_ERROR;
}
rc = njs_vm_value_string_set(vm, value, h->value.data,
h->value.len);
if (rc != NJS_OK) {
return NJS_ERROR;
}
continue;
}
if (p == NULL) {
start = h->value.data;
end = h->value.data + h->value.len;
p = end;
continue;
}
if (p + h->value.len + 1 > end) {
len = njs_max(p + h->value.len + 1 - start, 2 * (end - start));
data = ngx_pnalloc(http->pool, len);
if (data == NULL) {
njs_vm_memory_error(vm);
return NJS_ERROR;
}
p = ngx_cpymem(data, start, p - start);
start = data;
end = data + len;
}
*p++ = ',';
p = ngx_cpymem(p, h->value.data, h->value.len);
}
if (as_array) {
return NJS_OK;
}
if (p == NULL) {
njs_value_null_set(retval);
return NJS_DECLINED;
}
return njs_vm_value_string_set(vm, retval, start, p - start);
}
static njs_int_t
ngx_response_js_ext_headers_get(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t as_array)
{
njs_int_t ret;
njs_str_t name;
ret = ngx_js_string(vm, njs_arg(args, nargs, 1), &name);
if (ret != NJS_OK) {
return NJS_ERROR;
}
ret = ngx_response_js_ext_header_get(vm, njs_argument(args, 0),
&name, njs_vm_retval(vm), as_array);
return (ret != NJS_ERROR) ? NJS_OK : NJS_ERROR;
}
static njs_int_t
ngx_response_js_ext_headers_has(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
njs_int_t ret;
njs_str_t name;
ret = ngx_js_string(vm, njs_arg(args, nargs, 1), &name);
if (ret != NJS_OK) {
return NJS_ERROR;
}
ret = ngx_response_js_ext_header_get(vm, njs_argument(args, 0),
&name, njs_vm_retval(vm), 0);
if (ret == NJS_ERROR) {
return NJS_ERROR;
}
njs_value_boolean_set(njs_vm_retval(vm), ret == NJS_OK);
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_header(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
njs_int_t ret;
njs_str_t name;
ret = njs_vm_prop_name(vm, prop, &name);
if (ret != NJS_OK) {
return NJS_ERROR;
}
return ngx_response_js_ext_header_get(vm, value, &name, njs_vm_retval(vm),
0);
}
static njs_int_t
ngx_response_js_ext_keys(njs_vm_t *vm, njs_value_t *value, njs_value_t *keys)
{
njs_int_t rc;
njs_str_t hdr;
ngx_uint_t i, k, length;
njs_value_t *start;
ngx_js_http_t *http;
ngx_table_elt_t *h, *headers;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(keys);
return NJS_DECLINED;
}
rc = njs_vm_array_alloc(vm, keys, 8);
if (rc != NJS_OK) {
return NJS_ERROR;
}
length = 0;
headers = http->headers.elts;
start = njs_vm_array_start(vm, keys);
for (i = 0; i < http->headers.nelts; i++) {
h = &headers[i];
for (k = 0; k < length; k++) {
njs_value_string_get(njs_argument(start, k), &hdr);
if (h->key.len == hdr.length
&& ngx_strncasecmp(h->key.data, hdr.start, hdr.length) == 0)
{
break;
}
}
}
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_body(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t type)
{
njs_int_t ret;
njs_str_t string;
ngx_js_http_t *http;
njs_opaque_value_t retval;
http = njs_vm_external(vm, njs_argument(args, 0));
if (http == NULL) {
njs_value_undefined_set(njs_vm_retval(vm));
return NJS_DECLINED;
}
if (http->body_used) {
njs_vm_error(vm, "body stream already read");
return NJS_ERROR;
}
http->body_used = 1;
ret = njs_chb_join(&http->chain, &string);
if (ret != NJS_OK) {
njs_vm_memory_error(http->vm);
return NJS_ERROR;
}
switch (type) {
case NGX_JS_BODY_ARRAY_BUFFER:
ret = njs_vm_value_array_buffer_set(http->vm, njs_value_arg(&retval),
string.start, string.length);
if (ret != NJS_OK) {
njs_vm_memory_error(http->vm);
return NJS_ERROR;
}
break;
case NGX_JS_BODY_JSON:
case NGX_JS_BODY_TEXT:
default:
ret = njs_vm_value_string_set(http->vm, njs_value_arg(&retval),
string.start, string.length);
if (ret != NJS_OK) {
njs_vm_memory_error(http->vm);
return NJS_ERROR;
}
if (type == NGX_JS_BODY_JSON) {
ret = njs_vm_json_parse(vm, njs_value_arg(&retval), 1);
njs_value_assign(&retval, njs_vm_retval(vm));
}
}
return ngx_js_fetch_promissified_result(http->vm, njs_value_arg(&retval),
ret);
}
static njs_int_t
ngx_response_js_ext_body_used(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
ngx_js_http_t *http;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(retval);
return NJS_DECLINED;
}
njs_value_boolean_set(retval, http->body_used);
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_ok(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
ngx_uint_t code;
ngx_js_http_t *http;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(retval);
return NJS_DECLINED;
}
code = http->http_parse.code;
njs_value_boolean_set(retval, code >= 200 && code < 300);
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_status(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
ngx_js_http_t *http;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(retval);
return NJS_DECLINED;
}
njs_value_number_set(retval, http->http_parse.code);
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_status_text(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
ngx_js_http_t *http;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(retval);
return NJS_DECLINED;
}
njs_vm_value_string_set(vm, retval, http->http_parse.status_text,
http->http_parse.status_text_end
- http->http_parse.status_text);
return NJS_OK;
}
static njs_int_t
ngx_response_js_ext_type(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
ngx_js_http_t *http;
http = njs_vm_external(vm, value);
if (http == NULL) {
njs_value_undefined_set(retval);
return NJS_DECLINED;
}
return njs_vm_value_string_set(vm, retval, (u_char *) "basic",
njs_length("basic"));
}
ngx_int_t
ngx_js_fetch_init(njs_vm_t *vm, ngx_log_t *log)
{
njs_int_t proto_id;
proto_id = njs_vm_external_prototype(vm, ngx_js_ext_http_response,
njs_nitems(ngx_js_ext_http_response));
if (proto_id != NGX_JS_PROTO_RESPONSE) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
"failed to add js http.response proto");
return NGX_ERROR;
}
return NGX_OK;
}