Welcome to mirror list, hosted at ThFree Co, Russian Federation.

github.com/nginx/nginx.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/src/http/ngx_http.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/http/ngx_http.c')
-rw-r--r--src/http/ngx_http.c340
1 files changed, 335 insertions, 5 deletions
diff --git a/src/http/ngx_http.c b/src/http/ngx_http.c
index 80936c85e..6e3c676a1 100644
--- a/src/http/ngx_http.c
+++ b/src/http/ngx_http.c
@@ -5,15 +5,343 @@
#include <ngx_listen.h>
#include <ngx_http.h>
#include <ngx_http_config.h>
+#include <ngx_http_core_module.h>
-extern ngx_array_t *ngx_listening_sockets;
+static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, char *dummy);
+
+
+int ngx_http_max_module;
+
+ngx_array_t ngx_http_servers; /* array of ngx_http_core_srv_conf_t */
+
+int ngx_http_post_accept_timeout = 10000;
+int ngx_http_connection_pool_size = 16384;
+int ngx_http_request_pool_size = 16384;
+int ngx_http_client_header_timeout = 20000;
+int ngx_http_client_header_buffer_size = 1024;
+
+/* STUB: per location */
+int ngx_http_lingering_timeout = 5000;
+int ngx_http_lingering_time = 30;
+/**/
+
+int (*ngx_http_top_header_filter) (ngx_http_request_t *r);
+
+
+static ngx_str_t http_name = ngx_string("http");
+
+
+static ngx_command_t ngx_http_commands[] = {
+
+ {ngx_string("http"),
+ NGX_CONF_BLOCK|NGX_CONF_NOARGS,
+ ngx_http_block,
+ 0,
+ 0},
+
+ {ngx_string(""), 0, NULL, 0, 0}
+};
+
+
+ngx_module_t ngx_http_module = {
+ 0, /* module index */
+ &http_name, /* module context */
+ ngx_http_commands, /* module directives */
+ NGX_CORE_MODULE_TYPE, /* module type */
+ NULL /* init module */
+};
+
+
+static char *ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, char *dummy)
+{
+ int i, s, l, p, a, n, start;
+ int port_found, addr_found, virtual_names;
+ char *rv;
+ struct sockaddr_in *addr_in;
+ ngx_array_t in_ports;
+ ngx_listen_t *ls;
+ ngx_http_module_t *module;
+ ngx_http_conf_ctx_t *ctx, *prev;
+ ngx_http_in_port_t *in_port;
+ ngx_http_in_addr_t *in_addr, *inaddr;
+ ngx_http_core_srv_conf_t **cscf;
+ ngx_http_listen_t *lscf;
+ ngx_http_server_name_t *s_name, *name;;
+
+ ngx_init_array(ngx_http_servers, cf->pool, 10,
+ sizeof(ngx_http_core_srv_conf_t *), NGX_CONF_ERROR);
+
+ ngx_test_null(ctx,
+ ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t)),
+ NGX_CONF_ERROR);
+
+ for (i = 0; ngx_modules[i]; i++) {
+ if (ngx_modules[i]->type != NGX_HTTP_MODULE_TYPE) {
+ continue;
+ }
+
+ /* STUB */
+ module = (ngx_http_module_t *) ngx_modules[i]->ctx;
+ module->index = ngx_http_max_module;
+
+ ngx_modules[i]->index = ngx_http_max_module++;
+ }
+
+ /* null loc_conf */
+ ngx_test_null(ctx->loc_conf,
+ ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module),
+ NGX_CONF_ERROR);
+
+ for (i = 0; ngx_modules[i]; i++) {
+ if (ngx_modules[i]->type != NGX_HTTP_MODULE_TYPE) {
+ continue;
+ }
+
+ module = (ngx_http_module_t *) ngx_modules[i]->ctx;
+
+ if (module->create_loc_conf) {
+ ngx_test_null(ctx->loc_conf[module->index],
+ module->create_loc_conf(cf->pool),
+ NGX_CONF_ERROR);
+ }
+ }
+
+ prev = cf->ctx;
+ cf->ctx = ctx;
+ cf->type = NGX_HTTP_MODULE_TYPE;
+
+ rv = ngx_conf_parse(cf, NULL);
+ cf->ctx = prev;
+
+ if (rv != NGX_CONF_OK)
+ return rv;
+
+ ngx_http_init_filters(cf->pool, ngx_modules);
+
+#if 1
+ ngx_init_array(in_ports, cf->pool, 10, sizeof(ngx_http_in_port_t),
+ NGX_CONF_ERROR);
+
+ cscf = (ngx_http_core_srv_conf_t **) ngx_http_servers.elts;
+ for (s = 0; s < ngx_http_servers.nelts; s++) {
+
+ lscf = (ngx_http_listen_t *) cscf[s]->listen.elts;
+ for (l = 0; l < cscf[s]->listen.nelts; l++) {
+
+ port_found = 0;
+
+ /* AF_INET only */
+
+ in_port = (ngx_http_in_port_t *) in_ports.elts;
+ for (p = 0; p < in_ports.nelts; p++) {
+
+ if (lscf[l].port == in_port[p].port) {
+
+ port_found = 1;
+ addr_found = 0;
+
+ in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
+ for (a = 0; a < in_port[p].addr.nelts; a++) {
+
+ if (lscf[l].addr == in_addr[a].addr) {
+ s_name = (ngx_http_server_name_t *)
+ cscf[s]->server_names.elts;
+ for (n = 0; n < cscf[s]->server_names.nelts; n++) {
+ 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;
+ }
+
+ if (lscf[l].flags & NGX_HTTP_DEFAULT_SERVER) {
+ if (in_addr[a].flags
+ & NGX_HTTP_DEFAULT_SERVER) {
+
+ ngx_log_error(NGX_LOG_ERR, cf->log, 0,
+ "duplicate default server in %s:%d",
+ lscf[l].conf_file->file.name.data,
+ lscf[l].line);
+
+ return NGX_CONF_ERROR;
+ }
+
+ in_addr[a].flags |= NGX_HTTP_DEFAULT_SERVER;
+ in_addr[a].core_srv_conf = cscf[s];
+ }
+
+ addr_found = 1;
+
+ break;
+
+ /* "*:XX" is the last resort */
+ } else if (in_addr[p].addr == INADDR_ANY) {
+ ngx_test_null(inaddr,
+ ngx_push_array(&in_port[p].addr),
+ NGX_CONF_ERROR);
+
+ ngx_memcpy(inaddr, &in_addr[a],
+ sizeof(ngx_http_in_addr_t));
+
+ inaddr->addr = lscf[l].addr;
+ inaddr->flags = lscf[l].flags;
+ inaddr->core_srv_conf = cscf[s];
+
+ ngx_init_array(inaddr->names, cf->pool, 10,
+ sizeof(ngx_http_server_name_t),
+ NGX_CONF_ERROR);
+
+ addr_found = 1;
+
+ break;
+ }
+ }
+
+ if (!addr_found) {
+ ngx_test_null(inaddr,
+ ngx_push_array(&in_port[p].addr),
+ NGX_CONF_ERROR);
+
+ inaddr->addr = lscf[l].addr;
+ inaddr->flags = lscf[l].flags;
+ inaddr->core_srv_conf = cscf[s];
+
+ ngx_init_array(inaddr->names, cf->pool, 10,
+ sizeof(ngx_http_server_name_t),
+ NGX_CONF_ERROR);
+ }
+ }
+ }
+
+ if (!port_found) {
+ ngx_test_null(in_port,
+ ngx_push_array(&in_ports),
+ NGX_CONF_ERROR);
+
+ in_port->port = lscf[l].port;
+
+ ngx_init_array(in_port->addr, cf->pool, 10,
+ sizeof(ngx_http_in_addr_t),
+ NGX_CONF_ERROR);
+
+ ngx_test_null(inaddr, ngx_push_array(&in_port[p].addr),
+ NGX_CONF_ERROR);
+
+ inaddr->addr = lscf[l].addr;
+ inaddr->flags = lscf[l].flags;
+ inaddr->core_srv_conf = cscf[s];
+
+ ngx_init_array(inaddr->names, cf->pool, 10,
+ sizeof(ngx_http_server_name_t),
+ NGX_CONF_ERROR);
+ }
+ }
+ }
+
+ /* AF_INET only */
+
+ in_port = (ngx_http_in_port_t *) in_ports.elts;
+ for (p = 0; p < in_ports.nelts; p++) {
+
+ in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
+ for (a = 0; a < in_port[p].addr.nelts; a++) {
+
+ virtual_names = 0;
+
+ name = (ngx_http_server_name_t *) 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 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 is binding to "*:XX" then we need to bind to "*:XX" only
+ and ignore other binding */
+ if (in_addr[a - 1].addr == INADDR_ANY) {
+ start = a - 1;
+
+ } else {
+ start = 0;
+ }
+
+ in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
+ for (a = start; a < in_port[p].addr.nelts; a++) {
+
+ ngx_test_null(ls, ngx_push_array(&ngx_listening_sockets),
+ NGX_CONF_ERROR);
+ ngx_memzero(ls, sizeof(ngx_listen_t));
+
+ ngx_test_null(addr_in,
+ ngx_pcalloc(cf->pool, sizeof(struct sockaddr_in)),
+ NGX_CONF_ERROR);
+
+ addr_in->sin_family = AF_INET;
+ addr_in->sin_addr.s_addr = in_addr[a].addr;
+ addr_in->sin_port = htons(in_port[p].port);
+
+ ngx_test_null(ls->addr_text.data,
+ ngx_palloc(cf->pool, INET_ADDRSTRLEN + 6),
+ NGX_CONF_ERROR);
+
+ ls->addr_text.len =
+ ngx_snprintf(ls->addr_text.data
+ + ngx_inet_ntop(AF_INET,
+ &in_addr[a].addr,
+ ls->addr_text.data,
+ INET_ADDRSTRLEN),
+ 6, ":%d", in_port[p].port);
+
+ ls->family = AF_INET;
+ ls->type = SOCK_STREAM;
+ ls->protocol = IPPROTO_IP;
+#if (NGX_OVERLAPPED)
+ ls->flags = WSA_FLAG_OVERLAPPED;
+#endif
+ ls->sockaddr = (struct sockaddr *) addr_in;
+ ls->socklen = sizeof(struct sockaddr_in);
+ ls->addr = offsetof(struct sockaddr_in, sin_addr);
+ ls->addr_text_max_len = INET_ADDRSTRLEN;
+ ls->backlog = -1;
+ ls->post_accept_timeout = ngx_http_post_accept_timeout;
+ ls->nonblocking = 1;
+
+ ls->handler = ngx_http_init_connection;
+ ls->log = cf->log;
+ ls->ctx = ctx;
+ ls->servers = &in_port[p].addr;
+
+ if (in_port[p].addr.nelts == 1) {
+ in_addr = (ngx_http_in_addr_t *) in_port[p].addr.elts;
+
+ if (in_addr[a].names.nelts == 0) {
+ ls->ctx = in_addr->core_srv_conf->ctx;
+ ls->servers = NULL;
+ }
+ }
+ }
+ }
+#endif
+
+ return NGX_CONF_OK;
+}
+
+
+#if 0
/* STUB */
static struct sockaddr_in addr;
static char addr_text[22];
-static ngx_http_server_t ngx_http_server;
int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
{
@@ -40,8 +368,8 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
ngx_http_config_modules(pool, ngx_modules);
-#if 0
+#if 0
/* STUB */
ngx_http_output_filter_set_stub(pool, ngx_http_modules);
ngx_http_write_filter_set_stub(pool, ngx_http_modules);
@@ -49,9 +377,10 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
ngx_http_init_modules(pool, ngx_http_modules);
#endif
+
ngx_http_init_filters(pool, ngx_modules);
- ls = ngx_push_array(ngx_listening_sockets);
+ ls = ngx_push_array(&ngx_listening_sockets);
ngx_memzero(ls, sizeof(ngx_listen_t));
addr.sin_family = AF_INET;
@@ -84,4 +413,5 @@ int ngx_http_init(ngx_pool_t *pool, ngx_log_t *log)
return 1;
}
-/* */
+/**/
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-03 22:26:02 +0300