mirror/nginx
1
0
Fork 0
mirror of https://github.com/nginx/nginx.git synced 2025-08-06 14:56:15 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

nginx-0.0.1-2004-01-06-19:49:34 import

Browse Source
This commit is contained in:
Igor Sysoev 2004-01-06 16:49:34 +00:00
parent 3c3ca17358
commit a9030ebcca
6 changed files with 91 additions and 544 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

491
src/core/nginx.c
View File

@ -6,6 +6,7 @@
static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data); static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data);
static ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle, char **envp);
static void ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv); static void ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv);
static ngx_int_t ngx_core_module_init(ngx_cycle_t *cycle); static ngx_int_t ngx_core_module_init(ngx_cycle_t *cycle);
@ -126,7 +127,7 @@ int main(int argc, char *const *argv, char **envp)
return 1; return 1;
} }
if (ngx_set_inherited_sockets(&init_cycle, envp) == NGX_ERROR) { if (ngx_add_inherited_sockets(&init_cycle, envp) == NGX_ERROR) {
return 1; return 1;
} }
@ -327,450 +328,6 @@ int main(int argc, char *const *argv, char **envp)
} }
} }
#if 0
static ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)
{
ngx_int_t i, n, failed;
ngx_str_t conf_file;
ngx_log_t *log;
ngx_conf_t conf;
ngx_pool_t *pool;
ngx_cycle_t *cycle, **old;
ngx_socket_t fd;
ngx_core_conf_t *ccf;
ngx_open_file_t *file;
ngx_listening_t *ls, *nls;
log = old_cycle->log;
if (!(pool = ngx_create_pool(16 * 1024, log))) {
return NULL;
}
if (!(cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t)))) {
ngx_destroy_pool(pool);
return NULL;
}
cycle->pool = pool;
cycle->old_cycle = old_cycle;
n = old_cycle->pathes.nelts ? old_cycle->pathes.nelts : 10;
if (!(cycle->pathes.elts = ngx_pcalloc(pool, n * sizeof(ngx_path_t *)))) {
ngx_destroy_pool(pool);
return NULL;
}
cycle->pathes.nelts = 0;
cycle->pathes.size = sizeof(ngx_path_t *);
cycle->pathes.nalloc = n;
cycle->pathes.pool = pool;
n = old_cycle->open_files.nelts ? old_cycle->open_files.nelts : 20;
cycle->open_files.elts = ngx_pcalloc(pool, n * sizeof(ngx_open_file_t));
if (cycle->open_files.elts == NULL) {
ngx_destroy_pool(pool);
return NULL;
}
cycle->open_files.nelts = 0;
cycle->open_files.size = sizeof(ngx_open_file_t);
cycle->open_files.nalloc = n;
cycle->open_files.pool = pool;
if (!(cycle->log = ngx_log_create_errlog(cycle, NULL))) {
ngx_destroy_pool(pool);
return NULL;
}
n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;
cycle->listening.elts = ngx_pcalloc(pool, n * sizeof(ngx_listening_t));
if (cycle->listening.elts == NULL) {
ngx_destroy_pool(pool);
return NULL;
}
cycle->listening.nelts = 0;
cycle->listening.size = sizeof(ngx_listening_t);
cycle->listening.nalloc = n;
cycle->listening.pool = pool;
cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));
if (cycle->conf_ctx == NULL) {
ngx_destroy_pool(pool);
return NULL;
}
if (!(ccf = ngx_pcalloc(pool, sizeof(ngx_core_conf_t)))) {
ngx_destroy_pool(pool);
return NULL;
}
/* set by pcalloc()
*
* ccf->pid = NULL;
*/
ccf->daemon = -1;
ccf->single = -1;
((void **)(cycle->conf_ctx))[ngx_core_module.index] = ccf;
ngx_memzero(&conf, sizeof(ngx_conf_t));
/* STUB: init array ? */
conf.args = ngx_create_array(pool, 10, sizeof(ngx_str_t));
if (conf.args == NULL) {
ngx_destroy_pool(pool);
return NULL;
}
conf.ctx = cycle->conf_ctx;
conf.cycle = cycle;
/* STUB */ conf.pool = cycle->pool;
conf.log = log;
conf.module_type = NGX_CORE_MODULE;
conf.cmd_type = NGX_MAIN_CONF;
conf_file.len = sizeof(NGINX_CONF) - 1;
conf_file.data = NGINX_CONF;
if (ngx_conf_parse(&conf, &conf_file) != NGX_CONF_OK) {
ngx_destroy_pool(pool);
return NULL;
}
failed = 0;
file = cycle->open_files.elts;
for (i = 0; i < cycle->open_files.nelts; i++) {
if (file[i].name.data == NULL) {
continue;
}
file[i].fd = ngx_open_file(file[i].name.data,
NGX_FILE_RDWR,
NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);
ngx_log_debug(log, "OPEN: %d:%s" _ file[i].fd _ file[i].name.data);
if (file[i].fd == NGX_INVALID_FILE) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
ngx_open_file_n " \"%s\" failed",
file[i].name.data);
failed = 1;
break;
}
#if (WIN32)
if (ngx_file_append_mode(file[i].fd) == NGX_ERROR) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
ngx_file_append_mode_n " \"%s\" failed",
file[i].name.data);
failed = 1;
break;
}
#endif
}
if (!failed) {
if (old_cycle->listening.nelts) {
ls = old_cycle->listening.elts;
for (i = 0; i < old_cycle->listening.nelts; i++) {
ls[i].remain = 0;
}
nls = cycle->listening.elts;
for (n = 0; n < cycle->listening.nelts; n++) {
for (i = 0; i < old_cycle->listening.nelts; i++) {
if (ls[i].ignore) {
continue;
}
ngx_log_error(NGX_LOG_INFO, log, 0,
"%X, %X",
*(int *) ls[i].sockaddr,
*(int *) nls[n].sockaddr);
if (ngx_memcmp(nls[n].sockaddr,
ls[i].sockaddr, ls[i].socklen) == 0)
{
fd = ls[i].fd;
#if (WIN32)
/*
* Winsock assignes a socket number divisible by 4 so
* to find a connection we divide a socket number by 4.
*/
fd /= 4;
#endif
if (fd >= (ngx_socket_t) cycle->connection_n) {
ngx_log_error(NGX_LOG_EMERG, log, 0,
"%d connections is not enough to hold "
"an open listening socket on %s, "
"required at least %d connections",
cycle->connection_n,
ls[i].addr_text.data, fd);
failed = 1;
break;
}
nls[n].fd = ls[i].fd;
nls[i].remain = 1;
ls[i].remain = 1;
break;
}
}
if (nls[n].fd == -1) {
nls[n].new = 1;
}
}
} else {
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++) {
ls[i].new = 1;
}
}
if (!failed) {
if (ngx_open_listening_sockets(cycle) == NGX_ERROR) {
failed = 1;
}
}
}
if (failed) {
/* rollback the new cycle configuration */
file = cycle->open_files.elts;
for (i = 0; i < cycle->open_files.nelts; i++) {
if (file[i].fd == NGX_INVALID_FILE) {
continue;
}
if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
ngx_close_file_n " \"%s\" failed",
file[i].name.data);
}
}
ls = cycle->listening.elts;
for (i = 0; i < cycle->listening.nelts; i++) {
if (ls[i].new && ls[i].fd == -1) {
continue;
}
if (ngx_close_socket(ls[i].fd) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %s failed",
ls[i].addr_text.data);
}
}
ngx_destroy_pool(pool);
return NULL;
}
/* commit the new cycle configuration */
pool->log = cycle->log;
for (i = 0; ngx_modules[i]; i++) {
if (ngx_modules[i]->init_module) {
if (ngx_modules[i]->init_module(cycle) == NGX_ERROR) {
/* fatal */
exit(1);
}
}
}
/* close and delete stuff that lefts from an old cycle */
/* close the unneeded listening sockets */
ls = old_cycle->listening.elts;
for (i = 0; i < old_cycle->listening.nelts; i++) {
if (ls[i].remain) {
continue;
}
if (ngx_close_socket(ls[i].fd) == -1) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
ngx_close_socket_n " %s failed",
ls[i].addr_text.data);
}
}
/* close the unneeded open files */
file = old_cycle->open_files.elts;
for (i = 0; i < old_cycle->open_files.nelts; i++) {
if (file[i].fd == NGX_INVALID_FILE) {
continue;
}
if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
ngx_close_file_n " \"%s\" failed",
file[i].name.data);
}
}
if (old_cycle->connections == NULL) {
/* an old cycle is an init cycle */
ngx_destroy_pool(old_cycle->pool);
return cycle;
}
if (master) {
ngx_destroy_pool(old_cycle->pool);
return cycle;
}
if (ngx_temp_pool == NULL) {
ngx_temp_pool = ngx_create_pool(128, cycle->log);
if (ngx_temp_pool == NULL) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"can not create ngx_temp_pool");
exit(1);
}
n = 10;
ngx_old_cycles.elts = ngx_pcalloc(ngx_temp_pool,
n * sizeof(ngx_cycle_t *));
if (ngx_old_cycles.elts == NULL) {
exit(1);
}
ngx_old_cycles.nelts = 0;
ngx_old_cycles.size = sizeof(ngx_cycle_t *);
ngx_old_cycles.nalloc = n;
ngx_old_cycles.pool = ngx_temp_pool;
ngx_cleaner_event.event_handler = ngx_clean_old_cycles;
ngx_cleaner_event.log = cycle->log;
ngx_cleaner_event.data = &dumb;
dumb.fd = (ngx_socket_t) -1;
}
ngx_temp_pool->log = cycle->log;
old = ngx_push_array(&ngx_old_cycles);
if (old == NULL) {
exit(1);
}
*old = old_cycle;
if (!ngx_cleaner_event.timer_set) {
ngx_add_timer(&ngx_cleaner_event, 30000);
ngx_cleaner_event.timer_set = 1;
}
return cycle;
}
#endif
#if 0
static ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle, char **envp)
{
char *p, *v;
ngx_socket_t s;
ngx_listening_t *ls;
struct sockaddr_in *addr_in;
for ( /* void */ ; *envp; envp++) {
if (ngx_strncmp(*envp, NGINX_VAR, NGINX_VAR_LEN) != 0) {
continue;
}
ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
"using inherited sockets from \"%s\"", *envp);
ngx_init_array(cycle->listening, cycle->pool,
10, sizeof(ngx_listening_t), NGX_ERROR);
for (p = *envp + NGINX_VAR_LEN, v = p; *p; p++) {
if (*p == ':' || *p == ';') {
s = ngx_atoi(v, p - v);
if (s == NGX_ERROR) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"invalid socket number \"%s\" "
"in NGINX enviroment variable, "
"ignoring the rest of the variable", v);
break;
}
v = p + 1;
if (!(ls = ngx_push_array(&cycle->listening))) {
return NGX_ERROR;
}
ls->fd = s;
/* AF_INET only */
ls->sockaddr = ngx_palloc(cycle->pool,
sizeof(struct sockaddr_in));
if (ls->sockaddr == NULL) {
return NGX_ERROR;
}
ls->socklen = sizeof(struct sockaddr_in);
if (getsockname(s, ls->sockaddr, &ls->socklen) == -1) {
ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"getsockname() of the inherited "
"socket #%d failed", s);
ls->ignore = 1;
continue;
}
addr_in = (struct sockaddr_in *) ls->sockaddr;
if (addr_in->sin_family != AF_INET) {
ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"the inherited socket #%d has "
"unsupported family", s);
ls->ignore = 1;
continue;
}
ls->addr_text_max_len = INET_ADDRSTRLEN;
ls->addr_text.data = ngx_palloc(cycle->pool,
ls->addr_text_max_len);
if (ls->addr_text.data == NULL) {
return NGX_ERROR;
}
addr_in->sin_len = 0;
ls->family = addr_in->sin_family;
ls->addr_text.len = ngx_sock_ntop(ls->family, ls->sockaddr,
ls->addr_text.data,
ls->addr_text_max_len);
if (ls->addr_text.len == 0) {
return NGX_ERROR;
}
}
}
break;
}
return NGX_OK;
}
#endif
static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data) static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
{ {
@ -846,6 +403,50 @@ static void ngx_worker_process_cycle(ngx_cycle_t *cycle, void *data)
} }
static ngx_int_t ngx_add_inherited_sockets(ngx_cycle_t *cycle, char **envp)
{
char *p, *v;
ngx_socket_t s;
ngx_listening_t *ls;
for ( /* void */ ; *envp; envp++) {
if (ngx_strncmp(*envp, NGINX_VAR, NGINX_VAR_LEN) != 0) {
continue;
}
ngx_log_error(NGX_LOG_INFO, cycle->log, 0,
"using inherited sockets from \"%s\"", *envp);
ngx_init_array(cycle->listening, cycle->pool,
10, sizeof(ngx_listening_t), NGX_ERROR);
for (p = *envp + NGINX_VAR_LEN, v = p; *p; p++) {
if (*p == ':' || *p == ';') {
s = ngx_atoi(v, p - v);
if (s == NGX_ERROR) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"invalid socket number \"%s\" "
"in NGINX enviroment variable, "
"ignoring the rest of the variable", v);
break;
}
v = p + 1;
if (!(ls = ngx_push_array(&cycle->listening))) {
return NGX_ERROR;
}
ls->fd = s;
}
}
return ngx_set_inherited_sockets(cycle);
}
return NGX_OK;
}
static void ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv) static void ngx_exec_new_binary(ngx_cycle_t *cycle, char *const *argv)
{ {
char *env[2], *var, *p; char *env[2], *var, *p;

113
src/core/ngx_connection.c
View File

@ -2,96 +2,61 @@
#include <ngx_config.h> #include <ngx_config.h>
#include <ngx_core.h> #include <ngx_core.h>
#include <ngx_event.h> #include <ngx_event.h>
/* STUB */
#include <nginx.h>
ngx_os_io_t ngx_io; ngx_os_io_t ngx_io;
ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle, char **envp) ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle)
{ {
char *p, *v; ngx_int_t i;
ngx_socket_t s;
ngx_listening_t *ls; ngx_listening_t *ls;
struct sockaddr_in *addr_in; struct sockaddr_in *addr_in;
for ( /* void */ ; *envp; envp++) { ls = cycle->listening.elts;
if (ngx_strncmp(*envp, NGINX_VAR, NGINX_VAR_LEN) != 0) { for (i = 0; i < cycle->listening.nelts; i++) {
/* AF_INET only */
ls[i].sockaddr = ngx_palloc(cycle->pool, sizeof(struct sockaddr_in));
if (ls[i].sockaddr == NULL) {
return NGX_ERROR;
}
ls[i].socklen = sizeof(struct sockaddr_in);
if (getsockname(ls[i].fd, ls[i].sockaddr, &ls[i].socklen) == -1) {
ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"getsockname() of the inherited "
"socket #%d failed", ls[i].fd);
ls[i].ignore = 1;
continue; continue;
} }
ngx_log_error(NGX_LOG_INFO, cycle->log, 0, addr_in = (struct sockaddr_in *) ls[i].sockaddr;
"using inherited sockets from \"%s\"", *envp);
ngx_init_array(cycle->listening, cycle->pool, if (addr_in->sin_family != AF_INET) {
10, sizeof(ngx_listening_t), NGX_ERROR); ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"the inherited socket #%d has "
"unsupported family", ls[i].fd);
ls[i].ignore = 1;
continue;
}
ls[i].addr_text_max_len = INET_ADDRSTRLEN;
for (p = *envp + NGINX_VAR_LEN, v = p; *p; p++) { ls[i].addr_text.data = ngx_palloc(cycle->pool, ls[i].addr_text_max_len);
if (*p == ':' || *p == ';') { if (ls[i].addr_text.data == NULL) {
s = ngx_atoi(v, p - v); return NGX_ERROR;
if (s == NGX_ERROR) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"invalid socket number \"%s\" "
"in NGINX enviroment variable, "
"ignoring the rest of the variable", v);
break;
}
v = p + 1;
if (!(ls = ngx_push_array(&cycle->listening))) {
return NGX_ERROR;
}
ls->fd = s;
/* AF_INET only */
ls->sockaddr = ngx_palloc(cycle->pool,
sizeof(struct sockaddr_in));
if (ls->sockaddr == NULL) {
return NGX_ERROR;
}
ls->socklen = sizeof(struct sockaddr_in);
if (getsockname(s, ls->sockaddr, &ls->socklen) == -1) {
ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"getsockname() of the inherited "
"socket #%d failed", s);
ls->ignore = 1;
continue;
}
addr_in = (struct sockaddr_in *) ls->sockaddr;
if (addr_in->sin_family != AF_INET) {
ngx_log_error(NGX_LOG_CRIT, cycle->log, ngx_socket_errno,
"the inherited socket #%d has "
"unsupported family", s);
ls->ignore = 1;
continue;
}
ls->addr_text_max_len = INET_ADDRSTRLEN;
ls->addr_text.data = ngx_palloc(cycle->pool,
ls->addr_text_max_len);
if (ls->addr_text.data == NULL) {
return NGX_ERROR;
}
addr_in->sin_len = 0;
ls->family = addr_in->sin_family;
ls->addr_text.len = ngx_sock_ntop(ls->family, ls->sockaddr,
ls->addr_text.data,
ls->addr_text_max_len);
if (ls->addr_text.len == 0) {
return NGX_ERROR;
}
}
} }
break; addr_in->sin_len = 0;
ls[i].family = addr_in->sin_family;
ls[i].addr_text.len = ngx_sock_ntop(ls[i].family, ls[i].sockaddr,
ls[i].addr_text.data,
ls[i].addr_text_max_len);
if (ls[i].addr_text.len == 0) {
return NGX_ERROR;
}
} }
return NGX_OK; return NGX_OK;

2
src/core/ngx_connection.h
View File

@ -93,7 +93,7 @@ struct ngx_connection_s {
}; };
ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle, char **envp); ngx_int_t ngx_set_inherited_sockets(ngx_cycle_t *cycle);
ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle); ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle);
void ngx_close_listening_sockets(ngx_cycle_t *cycle); void ngx_close_listening_sockets(ngx_cycle_t *cycle);

5
src/core/ngx_cycle.c
View File

@ -173,11 +173,6 @@ ngx_log_debug(log, "OPEN: %d:%s" _ file[i].fd _ file[i].name.data);
continue; continue;
} }
ngx_log_error(NGX_LOG_INFO, log, 0,
"%X, %X",
*(int *) ls[i].sockaddr,
*(int *) nls[n].sockaddr);
if (ngx_memcmp(nls[n].sockaddr, if (ngx_memcmp(nls[n].sockaddr,
ls[i].sockaddr, ls[i].socklen) == 0) ls[i].sockaddr, ls[i].socklen) == 0)
{ {

5
src/os/unix/ngx_posix_init.c
View File

@ -99,8 +99,11 @@ int ngx_posix_init(ngx_log_t *log)
void ngx_signal_handler(int signo) void ngx_signal_handler(int signo)
{ {
struct timeval tv; struct timeval tv;
ngx_err_t err;
ngx_signal_t *sig; ngx_signal_t *sig;
err = ngx_errno;
for (sig = signals; sig->signo != 0; sig++) { for (sig = signals; sig->signo != 0; sig++) {
if (sig->signo == signo) { if (sig->signo == signo) {
break; break;
@ -141,6 +144,8 @@ void ngx_signal_handler(int signo)
ngx_change_binary = 1; ngx_change_binary = 1;
break; break;
} }
ngx_set_errno(err);
} }

19
src/os/unix/ngx_process.c
View File

@ -211,25 +211,6 @@ void ngx_respawn_processes(ngx_cycle_t *cycle)
} }
#if 0
void ngx_sigchld_handler(int signo)
{
int status;
char *process;
ngx_pid_t pid;
ngx_err_t err;
ngx_uint_t i, one;
struct timeval tv;
ngx_gettimeofday(&tv);
ngx_time_update(tv.tv_sec);
ngx_log_error(NGX_LOG_INFO, ngx_cycle->log, 0,
"signal #%d (SIGCHLD) received", signo);
}
#endif
void ngx_process_get_status() void ngx_process_get_status()
{ {
int status; int status;