technocloud-public/nginx-unit
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Removed unnecessary abstraction layer.

Browse Source
This commit is contained in:
Alexander Borisov
2019-03-06 15:26:45 +03:00
parent e1c4568680
commit dccb4cf354
6 changed files with 126 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/nxt_application.c
View File

@@ -36,8 +36,6 @@ static nxt_app_module_t *nxt_app_module_load(nxt_task_t *task,
const char *name); const char *name);
static nxt_int_t nxt_app_set_environment(nxt_conf_value_t *environment); static nxt_int_t nxt_app_set_environment(nxt_conf_value_t *environment);
static void nxt_app_http_release(nxt_task_t *task, void *obj, void *data);
static uint32_t compat[] = { static uint32_t compat[] = {
NXT_VERNUM, NXT_DEBUG, NXT_VERNUM, NXT_DEBUG,
@@ -431,32 +429,6 @@ nxt_app_set_environment(nxt_conf_value_t *environment)
} }
nxt_int_t
nxt_app_http_req_done(nxt_task_t *task, nxt_app_parse_ctx_t *ar)
{
ar->timer.handler = nxt_app_http_release;
nxt_timer_add(task->thread->engine, &ar->timer, 0);
return NXT_OK;
}
static void
nxt_app_http_release(nxt_task_t *task, void *obj, void *data)
{
nxt_timer_t *timer;
nxt_app_parse_ctx_t *ar;
timer = obj;
nxt_debug(task, "http app release");
ar = nxt_timer_data(timer, nxt_app_parse_ctx_t, timer);
nxt_mp_release(ar->request->mem_pool);
}
nxt_app_lang_module_t * nxt_app_lang_module_t *
nxt_app_lang_module(nxt_runtime_t *rt, nxt_str_t *name) nxt_app_lang_module(nxt_runtime_t *rt, nxt_str_t *name)
{ {

56
src/nxt_application.h
View File

@@ -99,62 +99,6 @@ struct nxt_common_app_conf_s {
}; };
typedef struct {
nxt_str_t method;
nxt_str_t target;
nxt_str_t version;
nxt_str_t path;
nxt_str_t query;
nxt_str_t server_name;
nxt_list_t *fields;
nxt_str_t cookie;
nxt_str_t content_length;
nxt_str_t content_type;
off_t parsed_content_length;
nxt_bool_t done;
size_t bufs;
nxt_buf_t *buf;
} nxt_app_request_header_t;
typedef struct {
size_t preread_size;
nxt_bool_t done;
nxt_buf_t *buf;
} nxt_app_request_body_t;
typedef struct {
nxt_app_request_header_t header;
nxt_app_request_body_t body;
nxt_str_t remote;
nxt_str_t local;
} nxt_app_request_t;
typedef struct nxt_app_parse_ctx_s nxt_app_parse_ctx_t;
struct nxt_app_parse_ctx_s {
nxt_app_request_t r;
nxt_http_request_t *request;
nxt_timer_t timer;
void *timer_data;
nxt_http_request_parse_t parser;
nxt_http_request_parse_t resp_parser;
nxt_mp_t *mem_pool;
};
nxt_int_t nxt_app_http_req_done(nxt_task_t *task, nxt_app_parse_ctx_t *ctx);
struct nxt_app_module_s { struct nxt_app_module_s {
size_t compat_length; size_t compat_length;
uint32_t *compat; uint32_t *compat;

4
src/nxt_http.h
View File

@@ -114,6 +114,7 @@ struct nxt_http_request_s {
const nxt_http_request_state_t *state; const nxt_http_request_state_t *state;
nxt_str_t host; nxt_str_t host;
nxt_str_t server_name;
nxt_str_t target; nxt_str_t target;
nxt_str_t version; nxt_str_t version;
nxt_str_t *method; nxt_str_t *method;
@@ -131,6 +132,9 @@ struct nxt_http_request_s {
nxt_sockaddr_t *remote; nxt_sockaddr_t *remote;
nxt_sockaddr_t *local; nxt_sockaddr_t *local;
nxt_timer_t timer;
void *timer_data;
nxt_buf_t *last; nxt_buf_t *last;
nxt_http_response_t resp; nxt_http_response_t resp;

82
src/nxt_http_request.c
View File

@@ -322,31 +322,17 @@ nxt_http_pass_t *
nxt_http_request_application(nxt_task_t *task, nxt_http_request_t *r, nxt_http_request_application(nxt_task_t *task, nxt_http_request_t *r,
nxt_http_pass_t *pass) nxt_http_pass_t *pass)
{ {
nxt_int_t ret; nxt_event_engine_t *engine;
nxt_event_engine_t *engine;
nxt_app_parse_ctx_t *ar;
nxt_debug(task, "http request application"); nxt_debug(task, "http request application");
ar = nxt_mp_zget(r->mem_pool, sizeof(nxt_app_parse_ctx_t));
if (nxt_slow_path(ar == NULL)) {
nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
return NULL;
}
ar->request = r;
ar->mem_pool = r->mem_pool;
nxt_mp_retain(r->mem_pool); nxt_mp_retain(r->mem_pool);
// STUB
engine = task->thread->engine; engine = task->thread->engine;
ar->timer.task = &engine->task; r->timer.task = &engine->task;
ar->timer.work_queue = &engine->fast_work_queue; r->timer.work_queue = &engine->fast_work_queue;
ar->timer.log = engine->task.log; r->timer.log = engine->task.log;
ar->timer.bias = NXT_TIMER_DEFAULT_BIAS; r->timer.bias = NXT_TIMER_DEFAULT_BIAS;
ar->r.remote.start = nxt_sockaddr_address(r->remote);
ar->r.remote.length = r->remote->address_length;
/* /*
* TODO: need an application flag to get local address * TODO: need an application flag to get local address
@@ -354,66 +340,14 @@ nxt_http_request_application(nxt_task_t *task, nxt_http_request_t *r,
*/ */
nxt_http_request_local_addr(task, r); nxt_http_request_local_addr(task, r);
if (nxt_fast_path(r->local != NULL)) {
ar->r.local.start = nxt_sockaddr_address(r->local);
ar->r.local.length = r->local->address_length;
}
ar->r.header.fields = r->fields;
ar->r.header.done = 1;
ar->r.header.version = r->version;
if (r->method != NULL) {
ar->r.header.method = *r->method;
}
if (r->host.length != 0) { if (r->host.length != 0) {
ar->r.header.server_name = r->host; r->server_name = r->host;
} else { } else {
nxt_str_set(&ar->r.header.server_name, "localhost"); nxt_str_set(&r->server_name, "localhost");
} }
ar->r.header.target = r->target; nxt_router_process_http_request(task, r, pass->u.application);
if (r->path != NULL) {
ar->r.header.path = *r->path;
}
if (r->args != NULL) {
ar->r.header.query = *r->args;
}
if (r->content_type != NULL) {
ar->r.header.content_type.length = r->content_type->value_length;
ar->r.header.content_type.start = r->content_type->value;
}
if (r->content_length != NULL) {
ar->r.header.content_length.length = r->content_length->value_length;
ar->r.header.content_length.start = r->content_length->value;
}
if (r->cookie != NULL) {
ar->r.header.cookie.length = r->cookie->value_length;
ar->r.header.cookie.start = r->cookie->value;
}
if (r->body != NULL) {
ar->r.body.buf = r->body;
ar->r.body.preread_size = r->content_length_n;
ar->r.header.parsed_content_length = r->content_length_n;
}
ar->r.body.done = 1;
ret = nxt_http_parse_request_init(&ar->resp_parser, r->mem_pool);
if (nxt_slow_path(ret != NXT_OK)) {
nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
return NULL;
}
nxt_router_process_http_request(task, ar, pass->u.application);
return NULL; return NULL;
} }

213
src/nxt_router.c
View File

@@ -62,7 +62,7 @@ typedef struct {
uint32_t stream; uint32_t stream;
nxt_app_t *app; nxt_app_t *app;
nxt_port_t *app_port; nxt_port_t *app_port;
nxt_app_parse_ctx_t *ap; nxt_http_request_t *request;
nxt_msg_info_t msg_info; nxt_msg_info_t msg_info;
nxt_req_app_link_t *ra; nxt_req_app_link_t *ra;
@@ -75,7 +75,7 @@ struct nxt_req_app_link_s {
nxt_atomic_t use_count; nxt_atomic_t use_count;
nxt_port_t *app_port; nxt_port_t *app_port;
nxt_port_t *reply_port; nxt_port_t *reply_port;
nxt_app_parse_ctx_t *ap; nxt_http_request_t *request;
nxt_msg_info_t msg_info; nxt_msg_info_t msg_info;
nxt_req_conn_link_t *rc; nxt_req_conn_link_t *rc;
@@ -264,8 +264,8 @@ static nxt_int_t nxt_router_app_port(nxt_task_t *task, nxt_app_t *app,
static void nxt_router_app_prepare_request(nxt_task_t *task, static void nxt_router_app_prepare_request(nxt_task_t *task,
nxt_req_app_link_t *ra); nxt_req_app_link_t *ra);
static nxt_buf_t *nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r, static nxt_buf_t *nxt_router_prepare_msg(nxt_task_t *task,
nxt_port_t *port, const nxt_str_t *prefix); nxt_http_request_t *r, nxt_port_t *port, const nxt_str_t *prefix);
static void nxt_router_app_timeout(nxt_task_t *task, void *obj, void *data); static void nxt_router_app_timeout(nxt_task_t *task, void *obj, void *data);
static void nxt_router_adjust_idle_timer(nxt_task_t *task, void *obj, static void nxt_router_adjust_idle_timer(nxt_task_t *task, void *obj,
@@ -282,6 +282,11 @@ static void nxt_http_request_send_body(nxt_task_t *task, void *obj, void *data);
static void nxt_router_app_joint_use(nxt_task_t *task, static void nxt_router_app_joint_use(nxt_task_t *task,
nxt_app_joint_t *app_joint, int i); nxt_app_joint_t *app_joint, int i);
static nxt_int_t nxt_router_http_request_done(nxt_task_t *task,
nxt_http_request_t *r);
static void nxt_router_http_request_release(nxt_task_t *task, void *obj,
void *data);
static nxt_router_t *nxt_router; static nxt_router_t *nxt_router;
static const nxt_str_t http_prefix = nxt_string("HTTP_"); static const nxt_str_t http_prefix = nxt_string("HTTP_");
@@ -502,7 +507,7 @@ nxt_router_ra_init(nxt_task_t *task, nxt_req_app_link_t *ra,
ra->rc = rc; ra->rc = rc;
rc->ra = ra; rc->ra = ra;
ra->reply_port = engine->port; ra->reply_port = engine->port;
ra->ap = rc->ap; ra->request = rc->request;
ra->work.handler = NULL; ra->work.handler = NULL;
ra->work.task = &engine->task; ra->work.task = &engine->task;
@@ -521,7 +526,7 @@ nxt_router_ra_create(nxt_task_t *task, nxt_req_app_link_t *ra_src)
return ra_src; return ra_src;
} }
mp = ra_src->ap->mem_pool; mp = ra_src->request->mem_pool;
ra = nxt_mp_alloc(mp, sizeof(nxt_req_app_link_t)); ra = nxt_mp_alloc(mp, sizeof(nxt_req_app_link_t));
@@ -645,16 +650,16 @@ nxt_router_ra_release(nxt_task_t *task, nxt_req_app_link_t *ra)
if (rc != NULL) { if (rc != NULL) {
if (nxt_slow_path(ra->err_code != 0)) { if (nxt_slow_path(ra->err_code != 0)) {
nxt_http_request_error(task, rc->ap->request, ra->err_code); nxt_http_request_error(task, rc->request, ra->err_code);
} else { } else {
rc->app_port = ra->app_port; rc->app_port = ra->app_port;
rc->msg_info = ra->msg_info; rc->msg_info = ra->msg_info;
if (rc->app->timeout != 0) { if (rc->app->timeout != 0) {
rc->ap->timer.handler = nxt_router_app_timeout; rc->request->timer.handler = nxt_router_app_timeout;
rc->ap->timer_data = rc; rc->request->timer_data = rc;
nxt_timer_add(task->thread->engine, &rc->ap->timer, nxt_timer_add(task->thread->engine, &rc->request->timer,
rc->app->timeout); rc->app->timeout);
} }
@@ -817,12 +822,12 @@ nxt_router_rc_unlink(nxt_task_t *task, nxt_req_conn_link_t *rc)
rc->app = NULL; rc->app = NULL;
} }
if (rc->ap != NULL) { if (rc->request != NULL) {
rc->ap->timer_data = NULL; rc->request->timer_data = NULL;
nxt_app_http_req_done(task, rc->ap); nxt_router_http_request_done(task, rc->request);
rc->ap = NULL; rc->request = NULL;
} }
} }
@@ -3380,9 +3385,10 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
size_t dump_size; size_t dump_size;
nxt_int_t ret; nxt_int_t ret;
nxt_buf_t *b; nxt_buf_t *b;
nxt_unit_field_t *f;
nxt_http_field_t *field;
nxt_http_request_t *r; nxt_http_request_t *r;
nxt_req_conn_link_t *rc; nxt_req_conn_link_t *rc;
nxt_app_parse_ctx_t *ar;
nxt_unit_response_t *resp; nxt_unit_response_t *resp;
b = msg->buf; b = msg->buf;
@@ -3398,12 +3404,12 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
b = NULL; b = NULL;
} }
ar = rc->ap; r = rc->request;
if (nxt_slow_path(ar == NULL)) { if (nxt_slow_path(r == NULL)) {
return; return;
} }
if (ar->request->error) { if (r->error) {
nxt_router_rc_unlink(task, rc); nxt_router_rc_unlink(task, rc);
return; return;
} }
@@ -3411,15 +3417,15 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
if (msg->port_msg.last != 0) { if (msg->port_msg.last != 0) {
nxt_debug(task, "router data create last buf"); nxt_debug(task, "router data create last buf");
nxt_buf_chain_add(&b, nxt_http_buf_last(ar->request)); nxt_buf_chain_add(&b, nxt_http_buf_last(r));
nxt_router_rc_unlink(task, rc); nxt_router_rc_unlink(task, rc);
} else { } else {
if (rc->app != NULL && rc->app->timeout != 0) { if (rc->app != NULL && rc->app->timeout != 0) {
ar->timer.handler = nxt_router_app_timeout; r->timer.handler = nxt_router_app_timeout;
ar->timer_data = rc; r->timer_data = rc;
nxt_timer_add(task->thread->engine, &ar->timer, rc->app->timeout); nxt_timer_add(task->thread->engine, &r->timer, rc->app->timeout);
} }
} }
@@ -3432,8 +3438,6 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
msg->buf = NULL; msg->buf = NULL;
} }
r = ar->request;
if (r->header_sent) { if (r->header_sent) {
nxt_buf_chain_add(&r->out, b); nxt_buf_chain_add(&r->out, b);
nxt_http_request_send_body(task, r, NULL); nxt_http_request_send_body(task, r, NULL);
@@ -3451,11 +3455,8 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
goto fail; goto fail;
} }
nxt_unit_field_t *f;
nxt_http_field_t *field;
for (f = resp->fields; f < resp->fields + resp->fields_count; f++) { for (f = resp->fields; f < resp->fields + resp->fields_count; f++) {
field = nxt_list_add(ar->resp_parser.fields); field = nxt_list_add(r->resp.fields);
if (nxt_slow_path(field == NULL)) { if (nxt_slow_path(field == NULL)) {
goto fail; goto fail;
@@ -3473,15 +3474,8 @@ nxt_router_response_ready_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
(size_t) field->name_length, field->name, (size_t) field->name_length, field->name,
(size_t) field->value_length, field->value); (size_t) field->value_length, field->value);
} }
r->status = resp->status;
/* r->status = resp->status;
ret = nxt_http_parse_fields(&ar->resp_parser, &b->mem);
if (nxt_slow_path(ret != NXT_DONE)) {
goto fail;
}
*/
r->resp.fields = ar->resp_parser.fields;
ret = nxt_http_fields_process(r->resp.fields, ret = nxt_http_fields_process(r->resp.fields,
&nxt_response_fields_hash, r); &nxt_response_fields_hash, r);
@@ -3590,8 +3584,8 @@ nxt_router_response_error_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg,
} }
} }
if (rc->ap != NULL) { if (rc->request != NULL) {
nxt_http_request_error(task, rc->ap->request, nxt_http_request_error(task, rc->request,
NXT_HTTP_SERVICE_UNAVAILABLE); NXT_HTTP_SERVICE_UNAVAILABLE);
} }
@@ -4452,17 +4446,15 @@ nxt_router_app_port(nxt_task_t *task, nxt_app_t *app, nxt_req_app_link_t *ra)
void void
nxt_router_process_http_request(nxt_task_t *task, nxt_app_parse_ctx_t *ar, nxt_router_process_http_request(nxt_task_t *task, nxt_http_request_t *r,
nxt_app_t *app) nxt_app_t *app)
{ {
nxt_int_t res; nxt_int_t res;
nxt_port_t *port; nxt_port_t *port;
nxt_event_engine_t *engine; nxt_event_engine_t *engine;
nxt_http_request_t *r;
nxt_req_app_link_t ra_local, *ra; nxt_req_app_link_t ra_local, *ra;
nxt_req_conn_link_t *rc; nxt_req_conn_link_t *rc;
r = ar->request;
engine = task->thread->engine; engine = task->thread->engine;
rc = nxt_port_rpc_register_handler_ex(task, engine->port, rc = nxt_port_rpc_register_handler_ex(task, engine->port,
@@ -4480,7 +4472,7 @@ nxt_router_process_http_request(nxt_task_t *task, nxt_app_parse_ctx_t *ar,
nxt_router_app_use(task, app, 1); nxt_router_app_use(task, app, 1);
rc->ap = ar; rc->request = r;
ra = &ra_local; ra = &ra_local;
nxt_router_ra_init(task, ra, rc); nxt_router_ra_init(task, ra, rc);
@@ -4511,17 +4503,15 @@ nxt_router_dummy_buf_completion(nxt_task_t *task, void *obj, void *data)
static void static void
nxt_router_app_prepare_request(nxt_task_t *task, nxt_req_app_link_t *ra) nxt_router_app_prepare_request(nxt_task_t *task, nxt_req_app_link_t *ra)
{ {
uint32_t request_failed; uint32_t request_failed;
nxt_buf_t *buf; nxt_buf_t *buf;
nxt_int_t res; nxt_int_t res;
nxt_port_t *port, *c_port, *reply_port; nxt_port_t *port, *c_port, *reply_port;
nxt_app_parse_ctx_t *ap;
nxt_assert(ra->app_port != NULL); nxt_assert(ra->app_port != NULL);
port = ra->app_port; port = ra->app_port;
reply_port = ra->reply_port; reply_port = ra->reply_port;
ap = ra->ap;
request_failed = 1; request_failed = 1;
@@ -4539,7 +4529,7 @@ nxt_router_app_prepare_request(nxt_task_t *task, nxt_req_app_link_t *ra)
nxt_process_connected_port_add(port->process, reply_port); nxt_process_connected_port_add(port->process, reply_port);
} }
buf = nxt_router_prepare_msg(task, &ap->r, port, buf = nxt_router_prepare_msg(task, ra->request, port,
nxt_app_msg_prefix[port->app->type]); nxt_app_msg_prefix[port->app->type]);
if (nxt_slow_path(buf == NULL)) { if (nxt_slow_path(buf == NULL)) {
@@ -4642,34 +4632,33 @@ nxt_fields_next(nxt_fields_iter_t *i)
static nxt_buf_t * static nxt_buf_t *
nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r, nxt_router_prepare_msg(nxt_task_t *task, nxt_http_request_t *r,
nxt_port_t *port, const nxt_str_t *prefix) nxt_port_t *port, const nxt_str_t *prefix)
{ {
void *target_pos, *query_pos; void *target_pos, *query_pos;
u_char *pos, *end, *p, c; u_char *pos, *end, *p, c;
size_t fields_count, req_size, size, free_size; size_t fields_count, req_size, size, free_size;
size_t copy_size; size_t copy_size;
nxt_buf_t *b, *buf, *out, **tail; nxt_off_t content_length;
nxt_http_field_t *field, *dup; nxt_buf_t *b, *buf, *out, **tail;
nxt_unit_field_t *dst_field; nxt_http_field_t *field, *dup;
nxt_fields_iter_t iter, dup_iter; nxt_unit_field_t *dst_field;
nxt_unit_request_t *req; nxt_fields_iter_t iter, dup_iter;
nxt_app_request_header_t *h; nxt_unit_request_t *req;
h = &r->header;
req_size = sizeof(nxt_unit_request_t) req_size = sizeof(nxt_unit_request_t)
+ h->method.length + 1 + r->method->length + 1
+ h->version.length + 1 + r->version.length + 1
+ r->remote.length + 1 + r->remote->length + 1
+ r->local.length + 1 + r->local->length + 1
+ h->server_name.length + 1 + r->server_name.length + 1
+ h->target.length + 1 + r->target.length + 1
+ (h->path.start != h->target.start ? h->path.length + 1 : 0); + (r->path->start != r->target.start ? r->path->length + 1 : 0);
content_length = r->content_length_n < 0 ? 0 : r->content_length_n;
fields_count = 0; fields_count = 0;
nxt_list_each(field, h->fields) { nxt_list_each(field, r->fields) {
fields_count++; fields_count++;
req_size += field->name_length + prefix->length + 1 req_size += field->name_length + prefix->length + 1
@@ -4686,7 +4675,7 @@ nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r,
} }
out = nxt_port_mmap_get_buf(task, port, out = nxt_port_mmap_get_buf(task, port,
nxt_min(req_size + r->body.preread_size, PORT_MMAP_DATA_SIZE)); nxt_min(req_size + content_length, PORT_MMAP_DATA_SIZE));
if (nxt_slow_path(out == NULL)) { if (nxt_slow_path(out == NULL)) {
return NULL; return NULL;
} }
@@ -4694,57 +4683,58 @@ nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r,
req = (nxt_unit_request_t *) out->mem.free; req = (nxt_unit_request_t *) out->mem.free;
out->mem.free += req_size; out->mem.free += req_size;
req->content_length = h->parsed_content_length; req->content_length = content_length;
p = (u_char *) (req->fields + fields_count); p = (u_char *) (req->fields + fields_count);
nxt_debug(task, "fields_count=%d", (int) fields_count); nxt_debug(task, "fields_count=%d", (int) fields_count);
req->method_length = h->method.length; req->method_length = r->method->length;
nxt_unit_sptr_set(&req->method, p); nxt_unit_sptr_set(&req->method, p);
p = nxt_cpymem(p, h->method.start, h->method.length); p = nxt_cpymem(p, r->method->start, r->method->length);
*p++ = '\0'; *p++ = '\0';
req->version_length = h->version.length; req->version_length = r->version.length;
nxt_unit_sptr_set(&req->version, p); nxt_unit_sptr_set(&req->version, p);
p = nxt_cpymem(p, h->version.start, h->version.length); p = nxt_cpymem(p, r->version.start, r->version.length);
*p++ = '\0'; *p++ = '\0';
req->remote_length = r->remote.length; req->remote_length = r->remote->address_length;
nxt_unit_sptr_set(&req->remote, p); nxt_unit_sptr_set(&req->remote, p);
p = nxt_cpymem(p, r->remote.start, r->remote.length); p = nxt_cpymem(p, nxt_sockaddr_address(r->remote),
r->remote->address_length);
*p++ = '\0'; *p++ = '\0';
req->local_length = r->local.length; req->local_length = r->local->address_length;
nxt_unit_sptr_set(&req->local, p); nxt_unit_sptr_set(&req->local, p);
p = nxt_cpymem(p, r->local.start, r->local.length); p = nxt_cpymem(p, nxt_sockaddr_address(r->local), r->local->address_length);
*p++ = '\0'; *p++ = '\0';
req->server_name_length = h->server_name.length; req->server_name_length = r->server_name.length;
nxt_unit_sptr_set(&req->server_name, p); nxt_unit_sptr_set(&req->server_name, p);
p = nxt_cpymem(p, h->server_name.start, h->server_name.length); p = nxt_cpymem(p, r->server_name.start, r->server_name.length);
*p++ = '\0'; *p++ = '\0';
target_pos = p; target_pos = p;
req->target_length = h->target.length; req->target_length = (uint32_t) r->target.length;
nxt_unit_sptr_set(&req->target, p); nxt_unit_sptr_set(&req->target, p);
p = nxt_cpymem(p, h->target.start, h->target.length); p = nxt_cpymem(p, r->target.start, r->target.length);
*p++ = '\0'; *p++ = '\0';
req->path_length = h->path.length; req->path_length = (uint32_t) r->path->length;
if (h->path.start == h->target.start) { if (r->path->start == r->target.start) {
nxt_unit_sptr_set(&req->path, target_pos); nxt_unit_sptr_set(&req->path, target_pos);
} else { } else {
nxt_unit_sptr_set(&req->path, p); nxt_unit_sptr_set(&req->path, p);
p = nxt_cpymem(p, h->path.start, h->path.length); p = nxt_cpymem(p, r->path->start, r->path->length);
*p++ = '\0'; *p++ = '\0';
} }
req->query_length = h->query.length; req->query_length = r->args != NULL ? (uint32_t) r->args->length : 0;
if (h->query.start != NULL) { if (r->args != NULL && r->args->start != NULL) {
query_pos = nxt_pointer_to(target_pos, query_pos = nxt_pointer_to(target_pos,
h->query.start - h->target.start); r->args->start - r->target.start);
nxt_unit_sptr_set(&req->query, query_pos); nxt_unit_sptr_set(&req->query, query_pos);
@@ -4758,7 +4748,7 @@ nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r,
dst_field = req->fields; dst_field = req->fields;
for (field = nxt_fields_first(h->fields, &iter); for (field = nxt_fields_first(r->fields, &iter);
field != NULL; field != NULL;
field = nxt_fields_next(&iter)) field = nxt_fields_next(&iter))
{ {
@@ -4771,13 +4761,13 @@ nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r,
dst_field->name_length = field->name_length + prefix->length; dst_field->name_length = field->name_length + prefix->length;
dst_field->value_length = field->value_length; dst_field->value_length = field->value_length;
if (field->value == h->content_length.start) { if (field == r->content_length) {
req->content_length_field = dst_field - req->fields; req->content_length_field = dst_field - req->fields;
} else if (field->value == h->content_type.start) { } else if (field == r->content_type) {
req->content_type_field = dst_field - req->fields; req->content_type_field = dst_field - req->fields;
} else if (field->value == h->cookie.start) { } else if (field == r->cookie) {
req->cookie_field = dst_field - req->fields; req->cookie_field = dst_field - req->fields;
} }
@@ -4846,14 +4836,14 @@ nxt_router_prepare_msg(nxt_task_t *task, nxt_app_request_t *r,
dst_field++; dst_field++;
} }
req->fields_count = dst_field - req->fields; req->fields_count = (uint32_t) (dst_field - req->fields);
nxt_unit_sptr_set(&req->preread_content, out->mem.free); nxt_unit_sptr_set(&req->preread_content, out->mem.free);
buf = out; buf = out;
tail = &buf->next; tail = &buf->next;
for (b = r->body.buf; b != NULL; b = b->next) { for (b = r->body; b != NULL; b = b->next) {
size = nxt_buf_mem_used_size(&b->mem); size = nxt_buf_mem_used_size(&b->mem);
pos = b->mem.pos; pos = b->mem.pos;
@@ -4913,8 +4903,8 @@ nxt_router_app_timeout(nxt_task_t *task, void *obj, void *data)
nxt_port_t *port; nxt_port_t *port;
nxt_timer_t *timer; nxt_timer_t *timer;
nxt_queue_link_t *lnk; nxt_queue_link_t *lnk;
nxt_http_request_t *r;
nxt_req_app_link_t *pending_ra; nxt_req_app_link_t *pending_ra;
nxt_app_parse_ctx_t *ar;
nxt_req_conn_link_t *rc; nxt_req_conn_link_t *rc;
nxt_port_select_state_t state; nxt_port_select_state_t state;
@@ -4922,8 +4912,8 @@ nxt_router_app_timeout(nxt_task_t *task, void *obj, void *data)
nxt_debug(task, "router app timeout"); nxt_debug(task, "router app timeout");
ar = nxt_timer_data(timer, nxt_app_parse_ctx_t, timer); r = nxt_timer_data(timer, nxt_http_request_t, timer);
rc = ar->timer_data; rc = r->timer_data;
app = rc->app; app = rc->app;
if (app == NULL) { if (app == NULL) {
@@ -4994,7 +4984,30 @@ nxt_router_app_timeout(nxt_task_t *task, void *obj, void *data)
generate_error: generate_error:
nxt_http_request_error(task, ar->request, NXT_HTTP_SERVICE_UNAVAILABLE); nxt_http_request_error(task, r, NXT_HTTP_SERVICE_UNAVAILABLE);
nxt_router_rc_unlink(task, rc); nxt_router_rc_unlink(task, rc);
} }
static nxt_int_t
nxt_router_http_request_done(nxt_task_t *task, nxt_http_request_t *r)
{
r->timer.handler = nxt_router_http_request_release;
nxt_timer_add(task->thread->engine, &r->timer, 0);
return NXT_OK;
}
static void
nxt_router_http_request_release(nxt_task_t *task, void *obj, void *data)
{
nxt_http_request_t *r;
nxt_debug(task, "http app release");
r = nxt_timer_data(obj, nxt_http_request_t, timer);
nxt_mp_release(r->mem_pool);
}

2
src/nxt_router.h
View File

@@ -192,7 +192,7 @@ void nxt_router_remove_pid_handler(nxt_task_t *task, nxt_port_recv_msg_t *msg);
void nxt_router_access_log_reopen_handler(nxt_task_t *task, void nxt_router_access_log_reopen_handler(nxt_task_t *task,
nxt_port_recv_msg_t *msg); nxt_port_recv_msg_t *msg);
void nxt_router_process_http_request(nxt_task_t *task, nxt_app_parse_ctx_t *ar, void nxt_router_process_http_request(nxt_task_t *task, nxt_http_request_t *r,
nxt_app_t *app); nxt_app_t *app);
void nxt_router_app_port_close(nxt_task_t *task, nxt_port_t *port); void nxt_router_app_port_close(nxt_task_t *task, nxt_port_t *port);
nxt_app_t *nxt_router_listener_application(nxt_router_temp_conf_t *tmcf, nxt_app_t *nxt_router_listener_application(nxt_router_temp_conf_t *tmcf,