nginx-0.0.1-2003-06-26-19:35:36 import

src/core/nginx.c

@@ -1,5 +1,4 @@
 
-
 #include <ngx_config.h>
 #include <ngx_core.h>
 #include <ngx_event.h>
@@ -10,9 +9,7 @@
 static int ngx_open_listening_sockets(ngx_log_t *log);
 
 
-ngx_log_t       ngx_log;
+void  ****ngx_conf_ctx;
-ngx_pool_t     *ngx_pool;
-void        ****ngx_conf_ctx;
 
 
 ngx_os_io_t  ngx_io;
@@ -28,53 +25,103 @@ ngx_array_t  ngx_listening_sockets;
 
 int main(int argc, char *const *argv)
 {
-    int         i;
+    int          i;
     ngx_str_t    conf_file;
     ngx_log_t   *log;
+    ngx_pool_t  *pool, *old_pool;
     ngx_conf_t   conf;
 
     ngx_max_sockets = -1;
 
-#if 0
-    ngx_log.fd = STDERR_FILENO;
-    ngx_log.log_level = NGX_LOG_INFO;
-
-    /* STUB */ ngx_log.log_level = NGX_LOG_DEBUG;
-#endif
-
     log = ngx_log_init_errlog();
 
     if (ngx_os_init(log) == NGX_ERROR) {
         return 1;
     }
 
-    ngx_pool = ngx_create_pool(16 * 1024, log);
-    /* */
-
     ngx_max_module = 0;
     for (i = 0; ngx_modules[i]; i++) {
         ngx_modules[i]->index = ngx_max_module++;
     }
 
+#if 0
+
+    ngx_test_null(cycle->pool, ngx_create_pool(16 * 1024, log), 1);
+
+    if (ngx_init_conf(cycle) == NGX_ERROR) {
+        ngx_destroy_pool(cycle->pool);
+        return 1;
+    }
+
+    /* daemon */
+
     /* life cycle */
 
     {
+
+        /* forks */
+
+        /* threads */
+
+        for ( ;; ) {
+            worker;
+
+            new_cycle = ngx_calloc(sizeof(ngx_cycle_t), cycle->log);
+
+            if (new_cycle == NULL) {
+                continue;
+            }
+
+            new_cycle->pool = ngx_create_pool(16 * 1024, cycle->log);
+
+            if (new_cycle->pool == NULL) {
+                ngx_free(new_cycle);
+                continue;
+            }
+
+            if (ngx_init_conf(new_cycle) == NGX_ERROR) {
+                ngx_destroy_pool(new_cycle->pool);
+                ngx_free(new_cycle);
+                continue;
+            }
+
+            /* update bound listening */
+
+            ngx_destroy_pool(cycle->pool);
+            ngx_free(cycle);
+
+            cycle = new_cycle;
+            break;
+        }
+    }
+
+    return 0;
+
+#endif
+
+    /* life cycle */
+
+    {
+        old_pool = pool;
+
+        pool = ngx_create_pool(16 * 1024, log);
+
         ngx_init_array(ngx_listening_sockets,
-                       ngx_pool, 10, sizeof(ngx_listening_t),
+                       pool, 10, sizeof(ngx_listening_t),
                        1);
 
         ngx_memzero(&conf, sizeof(ngx_conf_t));
 
         ngx_test_null(conf.args,
-                      ngx_create_array(ngx_pool, 10, sizeof(ngx_str_t)),
+                      ngx_create_array(pool, 10, sizeof(ngx_str_t)),
                       1);
 
         ngx_test_null(ngx_conf_ctx,
-                      ngx_pcalloc(ngx_pool, ngx_max_module * sizeof(void *)),
+                      ngx_pcalloc(pool, ngx_max_module * sizeof(void *)),
                       1);
 
         conf.ctx = ngx_conf_ctx;
-        conf.pool = ngx_pool;
+        conf.pool = pool;
         conf.log = log;
         conf.module_type = NGX_CORE_MODULE;
         conf.cmd_type = NGX_MAIN_CONF;
@@ -97,7 +144,7 @@ int main(int argc, char *const *argv)
 
         for (i = 0; ngx_modules[i]; i++) {
             if (ngx_modules[i]->init_module) {
-                if (ngx_modules[i]->init_module(ngx_pool) == NGX_ERROR) {
+                if (ngx_modules[i]->init_module(pool) == NGX_ERROR) {
                     return 1;
                 }
             }
@@ -111,7 +158,7 @@ int main(int argc, char *const *argv)
 
         /* TODO: fork */
 
-        ngx_pre_thread(&ngx_listening_sockets, ngx_pool, log);
+        ngx_pre_thread(&ngx_listening_sockets, pool, log);
 
         /* TODO: threads */
 
@@ -122,6 +169,43 @@ int main(int argc, char *const *argv)
     return 0;
 }
 
+#if 0
+
+static int ngx_init_conf(ngx_cycle_t *cycle)
+{
+    ngx_conf_t   conf;
+
+    ngx_init_array(cycle->listening, cycle->pool, 10, sizeof(ngx_listening_t),
+                   NGX_ERROR);
+
+    ngx_memzero(&conf, sizeof(ngx_conf_t));
+
+    ngx_test_null(conf.args,
+                  ngx_create_array(cycle->pool, 10, sizeof(ngx_str_t)),
+                  NGX_ERROR);
+
+    ngx_test_null(ngx_conf_ctx,
+                  ngx_pcalloc(cycle->pool, ngx_max_module * sizeof(void *)),
+                  NGX_ERROR);
+
+    conf.ctx = ngx_conf_ctx;
+    conf.pool = cycle->pool;
+    conf.log = cycle->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) {
+        return NGX_ERROR;
+    }
+
+    return NGX_OK;
+}
+
+
+#endif
 
 static int ngx_open_listening_sockets(ngx_log_t *log)
 {

src/core/ngx_conf_file.h

@@ -73,6 +73,20 @@ typedef struct {
 } ngx_conf_file_t;
 
 
+struct ngx_open_file_s {
+    ngx_fd_t   fd;
+    ngx_str_t  name;
+};
+
+
+typedef struct {
+    ngx_pool_t   *pool;
+    ngx_log_t    *log;
+    ngx_array_t   listening;
+    ngx_array_t   files;
+} ngx_cycle_t;
+
+
 typedef char *(*ngx_conf_handler_pt)(ngx_conf_t *cf,
                                      ngx_command_t *dummy, void *conf);
 

src/core/ngx_core.h

@@ -10,6 +10,7 @@
 
 typedef struct ngx_module_s      ngx_module_t;
 typedef struct ngx_conf_s        ngx_conf_t;
+typedef struct ngx_open_file_s   ngx_open_file_t;;
 typedef struct ngx_command_s     ngx_command_t;
 
 typedef struct ngx_file_s        ngx_file_t;

src/core/ngx_log.c

@@ -41,7 +41,8 @@ ngx_module_t  ngx_errlog_module = {
 };
 
 
-static ngx_log_t  ngx_log;
+static ngx_open_file_t  ngx_stderr;
+static ngx_log_t        ngx_log;
 
 
 static const char *err_levels[] = {
@@ -121,12 +122,12 @@ void ngx_log_error_core(int level, ngx_log_t *log, ngx_err_t err,
 #if (WIN32)
     errstr[len++] = '\r';
     errstr[len++] = '\n';
-    if (log->fd) {
+    if (log->file->fd) {
-        WriteFile(log->fd, errstr, len, &written, NULL);
+        WriteFile(log->file->fd, errstr, len, &written, NULL);
     }
 #else
     errstr[len++] = '\n';
-    write(log->fd, errstr, len);
+    write(log->file->fd, errstr, len);
 #endif
 
 
@@ -220,23 +221,24 @@ ngx_log_t *ngx_log_init_errlog()
 {
 #if (WIN32)
 
-    ngx_log.fd = GetStdHandle(STD_ERROR_HANDLE);
+    ngx_stderr.fd = GetStdHandle(STD_ERROR_HANDLE);
 
-    if (ngx_log.fd == NGX_INVALID_FILE) {
+    if (ngx_stderr.fd == NGX_INVALID_FILE) {
         /* TODO: where we can log error ? */
         return NULL;
 
-    } else if (ngx_log.fd == NULL) {
+    } else if (ngx_stderr.fd == NULL) {
         /* there are no associated standard handles */
         /* TODO: where we can log possible errors ? */
     }
 
 #else
 
-    ngx_log.fd = STDERR_FILENO;
+    ngx_stderr.fd = STDERR_FILENO;
 
 #endif
 
+    ngx_log.file = &ngx_stderr;
     ngx_log.log_level = NGX_LOG_INFO;
     /* STUB */ ngx_log.log_level = NGX_LOG_DEBUG;
 
@@ -252,11 +254,11 @@ char *ngx_log_set_errlog(ngx_conf_t *cf, ngx_command_t *cmd, ngx_log_t *log)
 
     value = cf->args->elts;
 
-    log->fd = ngx_open_file(value[1].data,
+    log->file->fd = ngx_open_file(value[1].data,
                             NGX_FILE_RDWR,
                             NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);
 
-    if (log->fd == NGX_INVALID_FILE) {
+    if (log->file->fd == NGX_INVALID_FILE) {
         err = ngx_errno;
         len = ngx_snprintf(ngx_conf_errstr, sizeof(ngx_conf_errstr) - 1,
                           ngx_open_file_n " \"%s\" failed (%d: ",
@@ -269,7 +271,7 @@ char *ngx_log_set_errlog(ngx_conf_t *cf, ngx_command_t *cmd, ngx_log_t *log)
     }
 
 #if (WIN32)
-    if (ngx_file_append_mode(log->fd) == NGX_ERROR) {
+    if (ngx_file_append_mode(log->file->fd) == NGX_ERROR) {
         err = ngx_errno;
         len = ngx_snprintf(ngx_conf_errstr, sizeof(ngx_conf_errstr) - 1,
                           ngx_file_append_mode_n " \"%s\" failed (%d: ",

src/core/ngx_log.h

@@ -64,10 +64,11 @@ typedef enum {
 
 
 typedef struct {
-    int       log_level;
+    int               log_level;
-    ngx_fd_t  fd;
+    ngx_open_file_t  *file;
-    void     *data;
+    void             *data;
-    size_t   (*handler)(void *ctx, char *buf, size_t len);
+    size_t           (*handler)(void *ctx, char *buf, size_t len);
+
 #if 0
 /* STUB */
     char     *action;