nxt_http_request.c

/*
 * Copyright (C) Igor Sysoev
 * Copyright (C) NGINX, Inc.
 */

#include<nxt_router.h>
#include<nxt_http.h>
#include<nxt_otel.h>


staticnxt_int_tnxt_http_validate_host(nxt_str_t*host, nxt_mp_t*mp);
staticvoidnxt_http_request_start(nxt_task_t*task, void*obj, void*data);
staticnxt_int_tnxt_http_request_forward(nxt_task_t*task,
nxt_http_request_t*r, nxt_http_forward_t*forward);
staticvoidnxt_http_request_forward_client_ip(nxt_http_request_t*r,
nxt_http_forward_t*forward, nxt_array_t*fields);
staticnxt_sockaddr_t*nxt_http_request_client_ip_sockaddr(
nxt_http_request_t*r, u_char*start, size_tlen);
staticvoidnxt_http_request_forward_protocol(nxt_http_request_t*r,
nxt_http_field_t*field);
staticvoidnxt_http_request_ready(nxt_task_t*task, void*obj, void*data);
staticvoidnxt_http_request_proto_info(nxt_task_t*task,
nxt_http_request_t*r);
staticvoidnxt_http_request_mem_buf_completion(nxt_task_t*task, void*obj,
void*data);
staticvoidnxt_http_request_done(nxt_task_t*task, void*obj, void*data);

staticu_char*nxt_http_date_cache_handler(u_char*buf, nxt_realtime_t*now,
structtm*tm, size_tsize, constchar*format);

staticnxt_http_name_value_t*nxt_http_argument(nxt_array_t*array,
u_char*name, size_tname_length, uint32_thash, u_char*start,
constu_char*end);
staticnxt_int_tnxt_http_cookie_parse(nxt_array_t*cookies, u_char*start,
constu_char*end);
staticnxt_http_name_value_t*nxt_http_cookie(nxt_array_t*array, u_char*name,
size_tname_length, u_char*start, constu_char*end);


#defineNXT_HTTP_COOKIE_HASH \
 (nxt_http_field_hash_end( \
 nxt_http_field_hash_char( \
 nxt_http_field_hash_char( \
 nxt_http_field_hash_char( \
 nxt_http_field_hash_char( \
 nxt_http_field_hash_char( \
 nxt_http_field_hash_char(NXT_HTTP_FIELD_HASH_INIT, \
 'c'), 'o'), 'o'), 'k'), 'i'), 'e')) & 0xFFFF)


staticconstnxt_http_request_state_tnxt_http_request_init_state;
staticconstnxt_http_request_state_tnxt_http_request_body_state;


nxt_time_string_tnxt_http_date_cache= {
 (nxt_atomic_uint_t) -1,
nxt_http_date_cache_handler,
NULL,
NXT_HTTP_DATE_LEN,
NXT_THREAD_TIME_GMT,
NXT_THREAD_TIME_SEC,
};


nxt_int_t
nxt_http_init(nxt_task_t*task)
{
nxt_int_tret;

ret=nxt_h1p_init(task);

if (ret!=NXT_OK) {
returnret;
 }

returnnxt_http_response_hash_init(task);
}


nxt_int_t
nxt_http_request_host(void*ctx, nxt_http_field_t*field, uintptr_tdata)
{
nxt_int_tret;
nxt_str_thost;
nxt_http_request_t*r;

r=ctx;

if (nxt_slow_path(r->host.start!=NULL)) {
returnNXT_HTTP_BAD_REQUEST;
 }

host.length=field->value_length;
host.start=field->value;

ret=nxt_http_validate_host(&host, r->mem_pool);

if (nxt_fast_path(ret==NXT_OK)) {
r->host=host;
 }

returnret;
}


staticnxt_int_t
nxt_http_validate_host(nxt_str_t*host, nxt_mp_t*mp)
{
u_char*h, ch;
size_ti, dot_pos, host_length;
nxt_bool_tlowcase;

enum {
sw_usual,
sw_literal,
sw_rest
 } state;

dot_pos=host->length;
host_length=host->length;

h=host->start;

lowcase=0;
state=sw_usual;

for (i=0; i<host->length; i++) {
ch=h[i];

if (ch>']') {
/* Short path. */
continue;
 }

switch (ch) {

case'.':
if (dot_pos==i-1) {
returnNXT_HTTP_BAD_REQUEST;
 }

dot_pos=i;
break;

case':':
if (state==sw_usual) {
host_length=i;
state=sw_rest;
 }

break;

case'[':
if (i==0) {
state=sw_literal;
 }

break;

case']':
if (state==sw_literal) {
host_length=i+1;
state=sw_rest;
 }

break;

case'/':
returnNXT_HTTP_BAD_REQUEST;

default:
if (ch >= 'A'&&ch <= 'Z') {
lowcase=1;
 }

break;
 }
 }

if (dot_pos==host_length-1) {
host_length--;
 }

host->length=host_length;

if (lowcase) {
host->start=nxt_mp_nget(mp, host_length);
if (nxt_slow_path(host->start==NULL)) {
returnNXT_HTTP_INTERNAL_SERVER_ERROR;
 }

nxt_memcpy_lowcase(host->start, h, host_length);
 }

returnNXT_OK;
}


nxt_int_t
nxt_http_request_field(void*ctx, nxt_http_field_t*field, uintptr_toffset)
{
nxt_http_request_t*r;

r=ctx;

nxt_value_at(nxt_http_field_t*, r, offset) =field;

returnNXT_OK;
}


nxt_int_t
nxt_http_request_content_length(void*ctx, nxt_http_field_t*field,
uintptr_tdata)
{
nxt_off_tn, max_body_size;
nxt_http_request_t*r;

r=ctx;

if (nxt_fast_path(r->content_length==NULL)) {
r->content_length=field;

n=nxt_off_t_parse(field->value, field->value_length);

if (nxt_fast_path(n >= 0)) {
r->content_length_n=n;

max_body_size=r->conf->socket_conf->max_body_size;

if (nxt_slow_path(n>max_body_size)) {
returnNXT_HTTP_PAYLOAD_TOO_LARGE;
 }

returnNXT_OK;
 }
 }

returnNXT_HTTP_BAD_REQUEST;
}


nxt_http_request_t*
nxt_http_request_create(nxt_task_t*task)
{
nxt_mp_t*mp;
nxt_buf_t*last;
nxt_http_request_t*r;

mp=nxt_mp_create(4096, 128, 512, 32);
if (nxt_slow_path(mp==NULL)) {
returnNULL;
 }

r=nxt_mp_zget(mp, sizeof(nxt_http_request_t));
if (nxt_slow_path(r==NULL)) {
 goto fail;
 }

r->resp.fields=nxt_list_create(mp, 8, sizeof(nxt_http_field_t));
if (nxt_slow_path(r->resp.fields==NULL)) {
 goto fail;
 }

last=nxt_mp_zget(mp, NXT_BUF_SYNC_SIZE);
if (nxt_slow_path(last==NULL)) {
 goto fail;
 }

nxt_buf_set_sync(last);
nxt_buf_set_last(last);
last->completion_handler=nxt_http_request_done;
last->parent=r;
r->last=last;

r->mem_pool=mp;
r->content_length_n=-1;
r->resp.content_length_n=-1;
r->state=&nxt_http_request_init_state;

r->start_time=nxt_thread_monotonic_time(task->thread);

task->thread->engine->requests_cnt++;

r->tstr_cache.var.pool=mp;

#if (NXT_HAVE_OTEL)
if (nxt_otel_rs_is_init()) {
r->otel=nxt_mp_zget(r->mem_pool, sizeof(nxt_otel_state_t));
if (nxt_slow_path(r->otel==NULL)) {
 goto fail;
 }
r->otel->status=NXT_OTEL_INIT_STATE;
 }
#endif

returnr;

fail:

nxt_mp_release(mp);

returnNULL;
}


staticconstnxt_http_request_state_tnxt_http_request_init_state
nxt_aligned(64) =
{
 .ready_handler=nxt_http_request_start,
 .error_handler=nxt_http_request_close_handler,
};


staticvoid
nxt_http_request_start(nxt_task_t*task, void*obj, void*data)
{
nxt_int_tret;
nxt_socket_conf_t*skcf;
nxt_http_request_t*r;

r=obj;

NXT_OTEL_TRACE();

r->state=&nxt_http_request_body_state;

skcf=r->conf->socket_conf;

if (skcf->forwarded!=NULL) {
ret=nxt_http_request_forward(task, r, skcf->forwarded);
if (nxt_slow_path(ret!=NXT_OK)) {
 goto fail;
 }
 }

if (skcf->client_ip!=NULL) {
ret=nxt_http_request_forward(task, r, skcf->client_ip);
if (nxt_slow_path(ret!=NXT_OK)) {
 goto fail;
 }
 }

nxt_http_request_read_body(task, r);

return;

fail:
nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
}


staticnxt_int_t
nxt_http_request_forward(nxt_task_t*task, nxt_http_request_t*r,
nxt_http_forward_t*forward)
{
nxt_int_tret;
nxt_array_t*client_ip_fields;
nxt_http_field_t*f, **fields, *protocol_field;
nxt_http_forward_header_t*client_ip, *protocol;

ret=nxt_http_route_addr_rule(r, forward->source, r->remote);
if (ret <= 0) {
returnNXT_OK;
 }

client_ip=&forward->client_ip;
protocol=&forward->protocol;

if (client_ip->header!=NULL) {
client_ip_fields=nxt_array_create(r->mem_pool, 1,
sizeof(nxt_http_field_t*));
if (nxt_slow_path(client_ip_fields==NULL)) {
returnNXT_ERROR;
 }

 } else {
client_ip_fields=NULL;
 }

protocol_field=NULL;

nxt_list_each(f, r->fields) {
if (client_ip_fields!=NULL
&&f->hash==client_ip->header_hash
&&f->value_length>0
&&f->name_length==client_ip->header->length
&&nxt_memcasecmp(f->name, client_ip->header->start,
client_ip->header->length) ==0)
 {
fields=nxt_array_add(client_ip_fields);
if (nxt_slow_path(fields==NULL)) {
returnNXT_ERROR;
 }

*fields=f;
 }

if (protocol->header!=NULL
&&protocol_field==NULL
&&f->hash==protocol->header_hash
&&f->value_length>0
&&f->name_length==protocol->header->length
&&nxt_memcasecmp(f->name, protocol->header->start,
protocol->header->length) ==0)
 {
protocol_field=f;
 }
 } nxt_list_loop;

if (client_ip_fields!=NULL) {
nxt_http_request_forward_client_ip(r, forward, client_ip_fields);
 }

if (protocol_field!=NULL) {
nxt_http_request_forward_protocol(r, protocol_field);
 }

returnNXT_OK;
}


staticvoid
nxt_http_request_forward_client_ip(nxt_http_request_t*r,
nxt_http_forward_t*forward, nxt_array_t*fields)
{
u_char*start, *p;
nxt_int_tret, i, len;
nxt_sockaddr_t*sa, *prev_sa;
nxt_http_field_t**f;

prev_sa=r->remote;
f= (nxt_http_field_t**) fields->elts;

i=fields->nelts;

while (i-->0) {
start=f[i]->value;
len=f[i]->value_length;

do {
for (p=start+len-1; p>start; p--, len--) {
if (*p!=' '&&*p!=',') {
break;
 }
 }

for (/* void */; p>start; p--) {
if (*p==' '||*p==',') {
p++;
break;
 }
 }

sa=nxt_http_request_client_ip_sockaddr(r, p, len- (p-start));
if (nxt_slow_path(sa==NULL)) {
if (prev_sa!=NULL) {
r->remote=prev_sa;
 }

return;
 }

if (!forward->recursive) {
r->remote=sa;
return;
 }

ret=nxt_http_route_addr_rule(r, forward->source, sa);
if (ret <= 0|| (i==0&&p==start)) {
r->remote=sa;
return;
 }

prev_sa=sa;
len=p-1-start;

 } while (len>0);
 }
}


staticnxt_sockaddr_t*
nxt_http_request_client_ip_sockaddr(nxt_http_request_t*r, u_char*start,
size_tlen)
{
nxt_str_taddr;
nxt_sockaddr_t*sa;

addr.start=start;
addr.length=len;

sa=nxt_sockaddr_parse_optport(r->mem_pool, &addr);
if (nxt_slow_path(sa==NULL)) {
returnNULL;
 }

switch (sa->u.sockaddr.sa_family) {
caseAF_INET:
if (sa->u.sockaddr_in.sin_addr.s_addr==INADDR_ANY) {
returnNULL;
 }

break;

#if (NXT_INET6)
caseAF_INET6:
if (IN6_IS_ADDR_UNSPECIFIED(&sa->u.sockaddr_in6.sin6_addr)) {
returnNULL;
 }

break;
#endif/* NXT_INET6 */

default:
returnNULL;
 }

returnsa;
}


staticvoid
nxt_http_request_forward_protocol(nxt_http_request_t*r,
nxt_http_field_t*field)
{
if (field->value_length==4) {
if (nxt_memcasecmp(field->value, "http", 4) ==0) {
r->tls=0;
 }

 } elseif (field->value_length==5) {
if (nxt_memcasecmp(field->value, "https", 5) ==0) {
r->tls=1;
 }

 } elseif (field->value_length==2) {
if (nxt_memcasecmp(field->value, "on", 2) ==0) {
r->tls=1;
 }
 }
}


staticconstnxt_http_request_state_tnxt_http_request_body_state
nxt_aligned(64) =
{
 .ready_handler=nxt_http_request_ready,
 .error_handler=nxt_http_request_close_handler,
};


staticnxt_int_t
nxt_http_request_chunked_transform(nxt_http_request_t*r)
{
size_tsize;
u_char*p, *end;
nxt_http_field_t*f;

r->chunked_field->skip=1;

size=r->body->file_end;

f=nxt_list_zero_add(r->fields);
if (nxt_slow_path(f==NULL)) {
returnNXT_ERROR;
 }

nxt_http_field_name_set(f, "Content-Length");

p=nxt_mp_nget(r->mem_pool, NXT_OFF_T_LEN);
if (nxt_slow_path(p==NULL)) {
returnNXT_ERROR;
 }

f->value=p;
end=nxt_sprintf(p, p+NXT_OFF_T_LEN, "%uz", size);
f->value_length=end-p;

r->content_length=f;
r->content_length_n=size;

returnNXT_OK;
}


staticvoid
nxt_http_request_ready(nxt_task_t*task, void*obj, void*data)
{
nxt_int_tret;
nxt_http_action_t*action;
nxt_http_request_t*r;

r=obj;
action=r->conf->socket_conf->action;

NXT_OTEL_TRACE();

if (r->chunked) {
ret=nxt_http_request_chunked_transform(r);
if (nxt_slow_path(ret!=NXT_OK)) {
nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
return;
 }
 }

nxt_http_request_action(task, r, action);
}


void
nxt_http_request_action(nxt_task_t*task, nxt_http_request_t*r,
nxt_http_action_t*action)
{
nxt_int_tret;

if (nxt_fast_path(action!=NULL)) {

do {
ret=nxt_http_rewrite(task, r);
if (nxt_slow_path(ret!=NXT_OK)) {
break;
 }

action=action->handler(task, r, action);

if (action==NULL) {
return;
 }

if (action==NXT_HTTP_ACTION_ERROR) {
break;
 }

 } while (r->pass_count++<255);
 }

nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
}


nxt_http_action_t*
nxt_http_application_handler(nxt_task_t*task, nxt_http_request_t*r,
nxt_http_action_t*action)
{
nxt_debug(task, "http application handler");

/*
 * TODO: need an application flag to get local address
 * required by "SERVER_ADDR" in Pyhton and PHP. Not used in Go.
 */
nxt_http_request_proto_info(task, r);

if (r->host.length!=0) {
r->server_name=r->host;

 } else {
nxt_str_set(&r->server_name, "localhost");
 }

nxt_router_process_http_request(task, r, action);

returnNULL;
}


staticvoid
nxt_http_request_proto_info(nxt_task_t*task, nxt_http_request_t*r)
{
if (nxt_fast_path(r->proto.any!=NULL)) {
nxt_http_proto[r->protocol].local_addr(task, r);
 }
}


void
nxt_http_request_read_body(nxt_task_t*task, nxt_http_request_t*r)
{
if (nxt_fast_path(r->proto.any!=NULL)) {
nxt_http_proto[r->protocol].body_read(task, r);
 }
}


void
nxt_http_request_header_send(nxt_task_t*task, nxt_http_request_t*r,
nxt_work_handler_tbody_handler, void*data)
{
u_char*p, *end, *server_string;
nxt_int_tret;
nxt_http_field_t*server, *date, *content_length;
nxt_socket_conf_t*skcf;

ret=nxt_http_set_headers(r);
if (nxt_slow_path(ret!=NXT_OK)) {
 goto fail;
 }

/*
 * TODO: "Server", "Date", and "Content-Length" processing should be moved
 * to the last header filter.
 */

server=nxt_list_zero_add(r->resp.fields);
if (nxt_slow_path(server==NULL)) {
 goto fail;
 }

skcf=r->conf->socket_conf;
server_string= (u_char*) (skcf->server_version ? NXT_SERVER : NXT_NAME);

nxt_http_field_name_set(server, "Server");
server->value=server_string;
server->value_length=nxt_strlen(server_string);

if (r->resp.date==NULL) {
date=nxt_list_zero_add(r->resp.fields);
if (nxt_slow_path(date==NULL)) {
 goto fail;
 }

nxt_http_field_name_set(date, "Date");

p=nxt_mp_nget(r->mem_pool, nxt_http_date_cache.size);
if (nxt_slow_path(p==NULL)) {
 goto fail;
 }

 (void) nxt_thread_time_string(task->thread, &nxt_http_date_cache, p);

date->value=p;
date->value_length=nxt_http_date_cache.size;

r->resp.date=date;
 }

if (r->resp.content_length_n!=-1
&& (r->resp.content_length==NULL||r->resp.content_length->skip))
 {
content_length=nxt_list_zero_add(r->resp.fields);
if (nxt_slow_path(content_length==NULL)) {
 goto fail;
 }

nxt_http_field_name_set(content_length, "Content-Length");

p=nxt_mp_nget(r->mem_pool, NXT_OFF_T_LEN);
if (nxt_slow_path(p==NULL)) {
 goto fail;
 }

content_length->value=p;
end=nxt_sprintf(p, p+NXT_OFF_T_LEN, "%O", r->resp.content_length_n);
content_length->value_length=end-p;

r->resp.content_length=content_length;
 }

if (nxt_fast_path(r->proto.any!=NULL)) {
nxt_http_proto[r->protocol].header_send(task, r, body_handler, data);
 }

return;

fail:

nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
}


void
nxt_http_request_ws_frame_start(nxt_task_t*task, nxt_http_request_t*r,
nxt_buf_t*ws_frame)
{
if (r->proto.any!=NULL) {
nxt_http_proto[r->protocol].ws_frame_start(task, r, ws_frame);
 }
}


void
nxt_http_request_send(nxt_task_t*task, nxt_http_request_t*r, nxt_buf_t*out)
{
if (nxt_fast_path(r->proto.any!=NULL)) {
nxt_http_proto[r->protocol].send(task, r, out);
 }
}


nxt_buf_t*
nxt_http_buf_mem(nxt_task_t*task, nxt_http_request_t*r, size_tsize)
{
nxt_buf_t*b;

b=nxt_buf_mem_alloc(r->mem_pool, size, 0);
if (nxt_fast_path(b!=NULL)) {
b->completion_handler=nxt_http_request_mem_buf_completion;
b->parent=r;
nxt_mp_retain(r->mem_pool);

 } else {
nxt_http_request_error(task, r, NXT_HTTP_INTERNAL_SERVER_ERROR);
 }

returnb;
}


staticvoid
nxt_http_request_mem_buf_completion(nxt_task_t*task, void*obj, void*data)
{
nxt_buf_t*b, *next;
nxt_http_request_t*r;

b=obj;
r=data;

do {
next=b->next;

nxt_mp_free(r->mem_pool, b);
nxt_mp_release(r->mem_pool);

b=next;
 } while (b!=NULL);
}


nxt_buf_t*
nxt_http_buf_last(nxt_http_request_t*r)
{
nxt_buf_t*last;

last=r->last;
r->last=NULL;

returnlast;
}


staticvoid
nxt_http_request_done(nxt_task_t*task, void*obj, void*data)
{
nxt_http_request_t*r;

r=data;

nxt_debug(task, "http request done");

nxt_http_request_close_handler(task, r, r->proto.any);
}


void
nxt_http_request_error_handler(nxt_task_t*task, void*obj, void*data)
{
nxt_http_proto_tproto;
nxt_http_request_t*r;

r=obj;
proto.any=data;

nxt_debug(task, "http request error handler");

r->error=1;

if (nxt_fast_path(proto.any!=NULL)) {
nxt_http_proto[r->protocol].discard(task, r, nxt_http_buf_last(r));
 }
}


void
nxt_http_request_close_handler(nxt_task_t*task, void*obj, void*data)
{
nxt_http_proto_tproto;
nxt_router_conf_t*rtcf;
nxt_http_request_t*r;
nxt_http_protocol_tprotocol;
nxt_socket_conf_joint_t*conf;
nxt_router_access_log_t*access_log;

r=obj;
proto.any=data;

conf=r->conf;
rtcf=conf->socket_conf->router_conf;

if (!r->logged) {
r->logged=1;

if (rtcf->access_log!=NULL) {
access_log=rtcf->access_log;

if (nxt_http_cond_value(task, r, &rtcf->log_cond)) {
access_log->handler(task, r, access_log, rtcf->log_format);
return;
 }
 }
 }

nxt_debug(task, "http request close handler");

r->proto.any=NULL;

if (r->body!=NULL&&nxt_buf_is_file(r->body)
&&r->body->file->fd!=-1)
 {
nxt_fd_close(r->body->file->fd);

r->body->file->fd=-1;
 }

if (r->tstr_query!=NULL) {
nxt_tstr_query_release(r->tstr_query);
 }

if (nxt_fast_path(proto.any!=NULL)) {
protocol=r->protocol;

nxt_http_proto[protocol].close(task, proto, conf);

nxt_mp_release(r->mem_pool);
 }
}


staticu_char*
nxt_http_date_cache_handler(u_char*buf, nxt_realtime_t*now, structtm*tm,
size_tsize, constchar*format)
{
returnnxt_http_date(buf, tm);
}


nxt_array_t*
nxt_http_arguments_parse(nxt_http_request_t*r)
{
size_tname_length;
u_char*p, *dst, *dst_start, *start, *end, *name;
uint8_td0, d1;
uint32_thash;
nxt_array_t*args;
nxt_http_name_value_t*nv;

if (r->arguments!=NULL) {
returnr->arguments;
 }

args=nxt_array_create(r->mem_pool, 2, sizeof(nxt_http_name_value_t));
if (nxt_slow_path(args==NULL)) {
returnNULL;
 }

if (nxt_slow_path(r->args->start==NULL)) {
 goto end;
 }

hash=NXT_HTTP_FIELD_HASH_INIT;
name=NULL;
name_length=0;

dst_start=nxt_mp_nget(r->mem_pool, r->args->length);
if (nxt_slow_path(dst_start==NULL)) {
returnNULL;
 }

r->args_decoded.start=dst_start;

start=r->args->start;
end=start+r->args->length;

for (p=start, dst=dst_start; p<end; p++, dst++) {
*dst=*p;

switch (*p) {
case'=':
if (name==NULL) {
name_length=dst-dst_start;
name=dst_start;
dst_start=dst+1;
 }

continue;

case'&':
if (name_length!=0||dst!=dst_start) {
nv=nxt_http_argument(args, name, name_length, hash, dst_start,
dst);
if (nxt_slow_path(nv==NULL)) {
returnNULL;
 }
 }

hash=NXT_HTTP_FIELD_HASH_INIT;
name_length=0;
name=NULL;
dst_start=dst+1;