diff options
Diffstat (limited to 'src/http/ngx_http.c')
| -rw-r--r-- | src/http/ngx_http.c | 642 |
1 files changed, 642 insertions, 0 deletions
diff --git a/src/http/ngx_http.c b/src/http/ngx_http.c new file mode 100644 index 000000000..a37ffc6eb --- /dev/null +++ b/src/http/ngx_http.c @@ -0,0 +1,642 @@ + +/* + * Copyright (C) Igor Sysoev + */ + + +#include <ngx_config.h> +#include <ngx_core.h> +#include <ngx_event.h> +#include <ngx_http.h> + + +static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf); +static char *ngx_http_merge_locations(ngx_conf_t *cf, + ngx_array_t *locations, + void **loc_conf, + ngx_http_module_t *module, + ngx_uint_t ctx_index); + +int ngx_http_max_module; + +ngx_uint_t ngx_http_total_requests; +uint64_t ngx_http_total_sent; + + +ngx_int_t (*ngx_http_top_header_filter) (ngx_http_request_t *r); +ngx_int_t (*ngx_http_top_body_filter) (ngx_http_request_t *r, ngx_chain_t *ch); + + +static ngx_command_t ngx_http_commands[] = { + + {ngx_string("http"), + NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS, + ngx_http_block, + 0, + 0, + NULL}, + + ngx_null_command +}; + + +static ngx_core_module_t ngx_http_module_ctx = { + ngx_string("http"), + NULL, + NULL +}; + + +ngx_module_t ngx_http_module = { + NGX_MODULE, + &ngx_http_module_ctx, /* module context */ + ngx_http_commands, /* module directives */ + NGX_CORE_MODULE, /* module type */ + NULL, /* init module */ + NULL /* init child */ +}; + + +static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) +{ + char *rv; + ngx_uint_t mi, m, s, l, p, a, n; + ngx_uint_t port_found, addr_found, virtual_names; + ngx_conf_t pcf; + ngx_array_t in_ports; + ngx_listening_t *ls; + ngx_http_listen_t *lscf; + ngx_http_module_t *module; + ngx_http_handler_pt *h; + ngx_http_conf_ctx_t *ctx; + ngx_http_in_port_t *in_port, *inport; + ngx_http_in_addr_t *in_addr, *inaddr; + ngx_http_server_name_t *s_name, *name; + ngx_http_core_srv_conf_t **cscfp, *cscf; + ngx_http_core_loc_conf_t *clcf; + ngx_http_core_main_conf_t *cmcf; +#if (WIN32) + ngx_iocp_conf_t *iocpcf; +#endif + + /* the main http context */ + ngx_test_null(ctx, + ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)), + NGX_CONF_ERROR); + + *(ngx_http_conf_ctx_t **) conf = ctx; + + /* count the number of the http modules and set up their indices */ + + ngx_http_max_module = 0; + for (m = 0; ngx_modules[m]; m++) { + if (ngx_modules[m]->type != NGX_HTTP_MODULE) { + continue; + } + + ngx_modules[m]->ctx_index = ngx_http_max_module++; + } + + /* the main http main_conf, it's the same in the all http contexts */ + ngx_test_null(ctx->main_conf, + ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module), + NGX_CONF_ERROR); + + /* the http null srv_conf, it's used to merge the server{}s' srv_conf's */ + ngx_test_null(ctx->srv_conf, + ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module), + NGX_CONF_ERROR); + + /* the http null loc_conf, it's used to merge the server{}s' loc_conf's */ + ngx_test_null(ctx->loc_conf, + ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module), + NGX_CONF_ERROR); + + + /* create the main_conf, srv_conf and loc_conf in all http modules */ + + for (m = 0; ngx_modules[m]; m++) { + if (ngx_modules[m]->type != NGX_HTTP_MODULE) { + continue; + } + + module = ngx_modules[m]->ctx; + mi = ngx_modules[m]->ctx_index; + + if (module->pre_conf) { + if (module->pre_conf(cf) != NGX_OK) { + return NGX_CONF_ERROR; + } + } + + if (module->create_main_conf) { + ngx_test_null(ctx->main_conf[mi], module->create_main_conf(cf), + NGX_CONF_ERROR); + } + + if (module->create_srv_conf) { + ngx_test_null(ctx->srv_conf[mi], module->create_srv_conf(cf), + NGX_CONF_ERROR); + } + + if (module->create_loc_conf) { + ngx_test_null(ctx->loc_conf[mi], module->create_loc_conf(cf), + NGX_CONF_ERROR); + } + } + + /* parse inside the http{} block */ + + pcf = *cf; + cf->ctx = ctx; + cf->module_type = NGX_HTTP_MODULE; + cf->cmd_type = NGX_HTTP_MAIN_CONF; + rv = ngx_conf_parse(cf, NULL); + + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + + /* + * init http{} main_conf's, merge the server{}s' srv_conf's + * and its location{}s' loc_conf's + */ + + cmcf = ctx->main_conf[ngx_http_core_module.ctx_index]; + cscfp = cmcf->servers.elts; + + for (m = 0; ngx_modules[m]; m++) { + if (ngx_modules[m]->type != NGX_HTTP_MODULE) { + continue; + } + + module = ngx_modules[m]->ctx; + mi = ngx_modules[m]->ctx_index; + + /* init http{} main_conf's */ + + if (module->init_main_conf) { + rv = module->init_main_conf(cf, ctx->main_conf[mi]); + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + } + + for (s = 0; s < cmcf->servers.nelts; s++) { + + /* merge the server{}s' srv_conf's */ + + if (module->merge_srv_conf) { + rv = module->merge_srv_conf(cf, + ctx->srv_conf[mi], + cscfp[s]->ctx->srv_conf[mi]); + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + } + + if (module->merge_loc_conf) { + + /* merge the server{}'s loc_conf */ + + rv = module->merge_loc_conf(cf, + ctx->loc_conf[mi], + cscfp[s]->ctx->loc_conf[mi]); + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + + /* merge the locations{}' loc_conf's */ + + rv = ngx_http_merge_locations(cf, &cscfp[s]->locations, + cscfp[s]->ctx->loc_conf, + module, mi); + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + +#if 0 + clcfp = (ngx_http_core_loc_conf_t **) cscfp[s]->locations.elts; + + for (l = 0; l < cscfp[s]->locations.nelts; l++) { + rv = module->merge_loc_conf(cf, + cscfp[s]->ctx->loc_conf[mi], + clcfp[l]->loc_conf[mi]); + if (rv != NGX_CONF_OK) { + *cf = pcf; + return rv; + } + } +#endif + } + } + } + + /* we needed "http"'s cf->ctx while merging configuration */ + *cf = pcf; + + /* init lists of the handlers */ + + ngx_init_array(cmcf->phases[NGX_HTTP_REWRITE_PHASE].handlers, + cf->cycle->pool, 10, sizeof(ngx_http_handler_pt), + NGX_CONF_ERROR); + cmcf->phases[NGX_HTTP_REWRITE_PHASE].type = NGX_OK; + + + /* the special find config phase for single handler */ + + ngx_init_array(cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers, + cf->cycle->pool, 1, sizeof(ngx_http_handler_pt), + NGX_CONF_ERROR); + cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].type = NGX_OK; + + ngx_test_null(h, ngx_push_array( + &cmcf->phases[NGX_HTTP_FIND_CONFIG_PHASE].handlers), + NGX_CONF_ERROR); + *h = ngx_http_find_location_config; + + + ngx_init_array(cmcf->phases[NGX_HTTP_ACCESS_PHASE].handlers, + cf->cycle->pool, 10, sizeof(ngx_http_handler_pt), + NGX_CONF_ERROR); + cmcf->phases[NGX_HTTP_ACCESS_PHASE].type = NGX_DECLINED; + + + ngx_init_array(cmcf->phases[NGX_HTTP_CONTENT_PHASE].handlers, + cf->cycle->pool, 10, sizeof(ngx_http_handler_pt), + NGX_CONF_ERROR); + cmcf->phases[NGX_HTTP_CONTENT_PHASE].type = NGX_OK; + + + /* + * create the lists of the ports, the addresses and the server names + * to allow quickly find the server core module configuration at run-time + */ + + ngx_init_array(in_ports, cf->pool, 10, sizeof(ngx_http_in_port_t), + NGX_CONF_ERROR); + + /* "server" directives */ + cscfp = cmcf->servers.elts; + for (s = 0; s < cmcf->servers.nelts; s++) { + + /* "listen" directives */ + lscf = cscfp[s]->listen.elts; + for (l = 0; l < cscfp[s]->listen.nelts; l++) { + + port_found = 0; + + /* AF_INET only */ + + in_port = in_ports.elts; + for (p = 0; p < in_ports.nelts; p++) { + + if (lscf[l].port == in_port[p].port) { + + /* the port is already in the port list */ + + port_found = 1; + addr_found = 0; + + in_addr = in_port[p].addrs.elts; + for (a = 0; a < in_port[p].addrs.nelts; a++) { + + if (lscf[l].addr == in_addr[a].addr) { + + /* the address is already bound to this port */ + + /* "server_name" directives */ + s_name = cscfp[s]->server_names.elts; + for (n = 0; n < cscfp[s]->server_names.nelts; n++) { + + /* + * add the server name and server core module + * configuration to the address:port + */ + + /* TODO: duplicate names can be checked here */ + + ngx_test_null(name, + ngx_push_array(&in_addr[a].names), + NGX_CONF_ERROR); + + name->name = s_name[n].name; + name->core_srv_conf = s_name[n].core_srv_conf; + } + + /* + * check duplicate "default" server that + * serves this address:port + */ + + if (lscf[l].default_server) { + if (in_addr[a].default_server) { + ngx_log_error(NGX_LOG_ERR, cf->log, 0, + "duplicate default server in %s:%d", + lscf[l].file_name.data, + lscf[l].line); + + return NGX_CONF_ERROR; + } + + in_addr[a].core_srv_conf = cscfp[s]; + in_addr[a].default_server = 1; + } + + addr_found = 1; + + break; + + } else if (in_addr[a].addr == INADDR_ANY) { + + /* + * "*:port" must be the last resort so move it + * to the end of the address list and add + * the new address at its place + */ + + ngx_test_null(inaddr, + ngx_push_array(&in_port[p].addrs), + NGX_CONF_ERROR); + + ngx_memcpy(inaddr, &in_addr[a], + sizeof(ngx_http_in_addr_t)); + + in_addr[a].addr = lscf[l].addr; + in_addr[a].default_server = lscf[l].default_server; + in_addr[a].core_srv_conf = cscfp[s]; + + /* + * create the empty list of the server names that + * can be served on this address:port + */ + + ngx_init_array(inaddr->names, cf->pool, 10, + sizeof(ngx_http_server_name_t), + NGX_CONF_ERROR); + + addr_found = 1; + + break; + } + } + + if (!addr_found) { + + /* + * add the address to the addresses list that + * bound to this port + */ + + ngx_test_null(inaddr, + ngx_push_array(&in_port[p].addrs), + NGX_CONF_ERROR); + + inaddr->addr = lscf[l].addr; + inaddr->default_server = lscf[l].default_server; + inaddr->core_srv_conf = cscfp[s]; + + /* + * create the empty list of the server names that + * can be served on this address:port + */ + + ngx_init_array(inaddr->names, cf->pool, 10, + sizeof(ngx_http_server_name_t), + NGX_CONF_ERROR); + } + } + } + + if (!port_found) { + + /* add the port to the in_port list */ + + ngx_test_null(in_port, + ngx_push_array(&in_ports), + NGX_CONF_ERROR); + + in_port->port = lscf[l].port; + + ngx_test_null(in_port->port_text.data, ngx_palloc(cf->pool, 7), + NGX_CONF_ERROR); + in_port->port_text.len = ngx_snprintf((char *) + in_port->port_text.data, + 7, ":%d", + in_port->port); + + /* create list of the addresses that bound to this port ... */ + + ngx_init_array(in_port->addrs, cf->pool, 10, + sizeof(ngx_http_in_addr_t), + NGX_CONF_ERROR); + + ngx_test_null(inaddr, ngx_push_array(&in_port->addrs), + NGX_CONF_ERROR); + + /* ... and add the address to this list */ + + inaddr->addr = lscf[l].addr; + inaddr->default_server = lscf[l].default_server; + inaddr->core_srv_conf = cscfp[s]; + + /* + * create the empty list of the server names that + * can be served on this address:port + */ + + ngx_init_array(inaddr->names, cf->pool, 10, + sizeof(ngx_http_server_name_t), + NGX_CONF_ERROR); + } + } + } + + /* optimize the lists of the ports, the addresses and the server names */ + + /* AF_INET only */ + + in_port = in_ports.elts; + for (p = 0; p < in_ports.nelts; p++) { + + /* check whether the all server names point to the same server */ + + in_addr = in_port[p].addrs.elts; + for (a = 0; a < in_port[p].addrs.nelts; a++) { + + virtual_names = 0; + + name = in_addr[a].names.elts; + for (n = 0; n < in_addr[a].names.nelts; n++) { + if (in_addr[a].core_srv_conf != name[n].core_srv_conf) { + virtual_names = 1; + break; + } + } + + /* + * if the all server names point to the same server + * then we do not need to check them at run-time + */ + + if (!virtual_names) { + in_addr[a].names.nelts = 0; + } + } + + /* + * if there's the binding to "*:port" then we need to bind() + * to "*:port" only and ignore the other bindings + */ + + if (in_addr[a - 1].addr == INADDR_ANY) { + a--; + + } else { + a = 0; + } + + in_addr = in_port[p].addrs.elts; + while (a < in_port[p].addrs.nelts) { + + ls = ngx_listening_inet_stream_socket(cf, in_addr[a].addr, + in_port[p].port); + if (ls == NULL) { + return NGX_CONF_ERROR; + } + + ls->backlog = -1; +#if 0 +#if 0 + ls->nonblocking = 1; +#else + ls->nonblocking = 0; +#endif +#endif + ls->addr_ntop = 1; + + ls->handler = ngx_http_init_connection; + + cscf = in_addr[a].core_srv_conf; + ls->pool_size = cscf->connection_pool_size; + ls->post_accept_timeout = cscf->post_accept_timeout; + + clcf = cscf->ctx->loc_conf[ngx_http_core_module.ctx_index]; + ls->log = clcf->err_log; + +#if (WIN32) + iocpcf = ngx_event_get_conf(cf->cycle->conf_ctx, ngx_iocp_module); + if (iocpcf->acceptex_read) { + ls->post_accept_buffer_size = cscf->client_header_buffer_size; + } +#endif + + ls->ctx = ctx; + + if (in_port[p].addrs.nelts > 1) { + + in_addr = in_port[p].addrs.elts; + if (in_addr[in_port[p].addrs.nelts - 1].addr != INADDR_ANY) { + + /* + * if this port has not the "*:port" binding then create + * the separate ngx_http_in_port_t for the all bindings + */ + + ngx_test_null(inport, + ngx_palloc(cf->pool, + sizeof(ngx_http_in_port_t)), + NGX_CONF_ERROR); + + inport->port = in_port[p].port; + inport->port_text = in_port[p].port_text; + + /* init list of the addresses ... */ + + ngx_init_array(inport->addrs, cf->pool, 1, + sizeof(ngx_http_in_addr_t), + NGX_CONF_ERROR); + + /* ... and set up it with the first address */ + + inport->addrs.nelts = 1; + inport->addrs.elts = in_port[p].addrs.elts; + + ls->servers = inport; + + /* prepare for the next cycle */ + + in_port[p].addrs.elts = (char *) in_port[p].addrs.elts + + in_port[p].addrs.size; + in_port[p].addrs.nelts--; + + in_addr = (ngx_http_in_addr_t *) in_port[p].addrs.elts; + a = 0; + + continue; + } + } + + ls->servers = &in_port[p]; + a++; + } + } + +#if (NGX_DEBUG) + in_port = in_ports.elts; + for (p = 0; p < in_ports.nelts; p++) { + ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0, + "port: %d %08x", in_port[p].port, &in_port[p]); + in_addr = in_port[p].addrs.elts; + for (a = 0; a < in_port[p].addrs.nelts; a++) { + u_char ip[20]; + ngx_inet_ntop(AF_INET, &in_addr[a].addr, ip, 20); + ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0, + "%s %08x", ip, in_addr[a].core_srv_conf); + s_name = in_addr[a].names.elts; + for (n = 0; n < in_addr[a].names.nelts; n++) { + ngx_log_debug2(NGX_LOG_DEBUG_HTTP, cf->log, 0, + "%s %08x", s_name[n].name.data, + s_name[n].core_srv_conf); + } + } + } +#endif + + return NGX_CONF_OK; +} + + +static char *ngx_http_merge_locations(ngx_conf_t *cf, + ngx_array_t *locations, + void **loc_conf, + ngx_http_module_t *module, + ngx_uint_t ctx_index) +{ + char *rv; + ngx_uint_t i; + ngx_http_core_loc_conf_t **clcfp; + + clcfp = /* (ngx_http_core_loc_conf_t **) */ locations->elts; + + for (i = 0; i < locations->nelts; i++) { + rv = module->merge_loc_conf(cf, loc_conf[ctx_index], + clcfp[i]->loc_conf[ctx_index]); + if (rv != NGX_CONF_OK) { + return rv; + } + + rv = ngx_http_merge_locations(cf, &clcfp[i]->locations, + clcfp[i]->loc_conf, module, ctx_index); + if (rv != NGX_CONF_OK) { + return rv; + } + } + + return NGX_CONF_OK; +} |