nginxtra 1.8.1.12 → 1.10.1.12

data/vendor/nginx/src/core/ngx_file.c

@@ -124,6 +124,15 @@ ngx_write_chain_to_temp_file(ngx_temp_file_t *tf, ngx_chain_t *chain)
         }
     }
 
+#if (NGX_THREADS && NGX_HAVE_PWRITEV)
+
+    if (tf->thread_write) {
+        return ngx_thread_write_chain_to_file(&tf->file, chain, tf->offset,
+                                              tf->pool);
+    }
+
+#endif
+
     return ngx_write_chain_to_file(&tf->file, chain, tf->offset, tf->pool);
 }
 
@@ -146,7 +155,7 @@ ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
 
 #if 0
     for (i = 0; i < file->name.len; i++) {
-         file->name.data[i] = 'X';
+        file->name.data[i] = 'X';
     }
 #endif
 
@@ -187,7 +196,7 @@ ngx_create_temp_file(ngx_file_t *file, ngx_path_t *path, ngx_pool_t *pool,
 
         err = ngx_errno;
 
-        if (err == NGX_EEXIST) {
+        if (err == NGX_EEXIST_FILE) {
             n = (uint32_t) ngx_next_temp_number(1);
             continue;
         }
@@ -683,7 +692,7 @@ ngx_ext_rename_file(ngx_str_t *src, ngx_str_t *to, ngx_ext_rename_file_t *ext)
 
 #if (NGX_WIN32)
 
-    if (err == NGX_EEXIST) {
+    if (err == NGX_EEXIST || err == NGX_EEXIST_FILE) {
         err = ngx_win32_rename_file(src, to, ext->log);
 
         if (err == 0) {
@@ -832,7 +841,7 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
 
         if ((size_t) n != len) {
             ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
-                          ngx_read_fd_n " has read only %z of %uz from %s",
+                          ngx_read_fd_n " has read only %z of %O from %s",
                           n, size, from);
             goto failed;
         }
@@ -847,7 +856,7 @@ ngx_copy_file(u_char *from, u_char *to, ngx_copy_file_t *cf)
 
         if ((size_t) n != len) {
             ngx_log_error(NGX_LOG_ALERT, cf->log, 0,
-                          ngx_write_fd_n " has written only %z of %uz to %s",
+                          ngx_write_fd_n " has written only %z of %O to %s",
                           n, size, to);
             goto failed;
         }

data/vendor/nginx/src/core/ngx_file.h

@@ -27,6 +27,7 @@ struct ngx_file_s {
     ngx_int_t                (*thread_handler)(ngx_thread_task_t *task,
                                                ngx_file_t *file);
     void                      *thread_ctx;
+    ngx_thread_task_t         *thread_task;
 #endif
 
 #if (NGX_HAVE_FILE_AIO)
@@ -77,6 +78,7 @@ typedef struct {
     unsigned                   log_level:8;
     unsigned                   persistent:1;
     unsigned                   clean:1;
+    unsigned                   thread_write:1;
 } ngx_temp_file_t;
 
 

data/vendor/nginx/src/core/ngx_hash.c

@@ -257,11 +257,19 @@ ngx_hash_init(ngx_hash_init_t *hinit, ngx_hash_key_t *names, ngx_uint_t nelts)
     ngx_uint_t       i, n, key, size, start, bucket_size;
     ngx_hash_elt_t  *elt, **buckets;
 
+    if (hinit->max_size == 0) {
+        ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
+                      "could not build %s, you should "
+                      "increase %s_max_size: %i",
+                      hinit->name, hinit->name, hinit->max_size);
+        return NGX_ERROR;
+    }
+
     for (n = 0; n < nelts; n++) {
         if (hinit->bucket_size < NGX_HASH_ELT_SIZE(&names[n]) + sizeof(void *))
         {
             ngx_log_error(NGX_LOG_EMERG, hinit->pool->log, 0,
-                          "could not build the %s, you should "
+                          "could not build %s, you should "
                           "increase %s_bucket_size: %i",
                           hinit->name, hinit->name, hinit->bucket_size);
             return NGX_ERROR;
@@ -735,6 +743,10 @@ ngx_hash_add_key(ngx_hash_keys_arrays_t *ha, ngx_str_t *key, void *value,
             if (key->data[i] == '.' && key->data[i + 1] == '.') {
                 return NGX_DECLINED;
             }
+
+            if (key->data[i] == '\0') {
+                return NGX_DECLINED;
+            }
         }
 
         if (key->len > 1 && key->data[0] == '.') {

data/vendor/nginx/src/core/ngx_inet.c

@@ -26,15 +26,15 @@ ngx_inet_addr(u_char *text, size_t len)
     n = 0;
 
     for (p = text; p < text + len; p++) {
-
-        if (octet > 255) {
-            return INADDR_NONE;
-        }
-
         c = *p;
 
         if (c >= '0' && c <= '9') {
             octet = octet * 10 + (c - '0');
+
+            if (octet > 255) {
+                return INADDR_NONE;
+            }
+
             continue;
         }
 
@@ -348,7 +348,7 @@ ngx_inet6_ntop(u_char *p, u_char *text, size_t len)
             continue;
         }
 
-        dst = ngx_sprintf(dst, "%uxi", p[i] * 256 + p[i + 1]);
+        dst = ngx_sprintf(dst, "%xd", p[i] * 256 + p[i + 1]);
 
         if (i < 14) {
             *dst++ = ':';
@@ -529,14 +529,16 @@ ngx_int_t
 ngx_parse_url(ngx_pool_t *pool, ngx_url_t *u)
 {
     u_char  *p;
+    size_t   len;
 
     p = u->url.data;
+    len = u->url.len;
 
-    if (ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
+    if (len >= 5 && ngx_strncasecmp(p, (u_char *) "unix:", 5) == 0) {
         return ngx_parse_unix_domain_url(pool, u);
     }
 
-    if (p[0] == '[') {
+    if (len && p[0] == '[') {
         return ngx_parse_inet6_url(pool, u);
     }
 
@@ -1240,19 +1242,19 @@ ngx_cmp_sockaddr(struct sockaddr *sa1, socklen_t slen1,
 #if (NGX_HAVE_UNIX_DOMAIN)
     case AF_UNIX:
 
-       /* TODO length */
+        /* TODO length */
 
-       saun1 = (struct sockaddr_un *) sa1;
-       saun2 = (struct sockaddr_un *) sa2;
+        saun1 = (struct sockaddr_un *) sa1;
+        saun2 = (struct sockaddr_un *) sa2;
 
-       if (ngx_memcmp(&saun1->sun_path, &saun2->sun_path,
-                      sizeof(saun1->sun_path))
-           != 0)
-       {
-           return NGX_DECLINED;
-       }
+        if (ngx_memcmp(&saun1->sun_path, &saun2->sun_path,
+                       sizeof(saun1->sun_path))
+            != 0)
+        {
+            return NGX_DECLINED;
+        }
 
-       break;
+        break;
 #endif
 
     default: /* AF_INET */

data/vendor/nginx/src/core/ngx_log.c

@@ -33,14 +33,14 @@ typedef struct {
 
 static ngx_command_t  ngx_errlog_commands[] = {
 
-    {ngx_string("error_log"),
-     NGX_MAIN_CONF|NGX_CONF_1MORE,
-     ngx_error_log,
-     0,
-     0,
-     NULL},
-
-    ngx_null_command
+    { ngx_string("error_log"),
+      NGX_MAIN_CONF|NGX_CONF_1MORE,
+      ngx_error_log,
+      0,
+      0,
+      NULL },
+
+      ngx_null_command
 };
 
 
@@ -86,7 +86,7 @@ static ngx_str_t err_levels[] = {
 
 static const char *debug_levels[] = {
     "debug_core", "debug_alloc", "debug_mutex", "debug_event",
-    "debug_http", "debug_mail", "debug_mysql"
+    "debug_http", "debug_mail", "debug_stream"
 };
 
 
@@ -585,7 +585,7 @@ ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head)
             return NGX_CONF_ERROR;
         }
 
-     } else if (ngx_strncmp(value[1].data, "memory:", 7) == 0) {
+    } else if (ngx_strncmp(value[1].data, "memory:", 7) == 0) {
 
 #if (NGX_DEBUG)
         size_t                 size, needed;
@@ -609,7 +609,7 @@ ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head)
             return NGX_CONF_ERROR;
         }
 
-        buf = ngx_palloc(cf->pool, sizeof(ngx_log_memory_buf_t));
+        buf = ngx_pcalloc(cf->pool, sizeof(ngx_log_memory_buf_t));
         if (buf == NULL) {
             return NGX_CONF_ERROR;
         }
@@ -644,7 +644,7 @@ ngx_log_set_log(ngx_conf_t *cf, ngx_log_t **head)
         return NGX_CONF_ERROR;
 #endif
 
-     } else if (ngx_strncmp(value[1].data, "syslog:", 7) == 0) {
+    } else if (ngx_strncmp(value[1].data, "syslog:", 7) == 0) {
         peer = ngx_pcalloc(cf->pool, sizeof(ngx_syslog_peer_t));
         if (peer == NULL) {
             return NGX_CONF_ERROR;

data/vendor/nginx/src/core/ngx_log.h

@@ -29,7 +29,7 @@
 #define NGX_LOG_DEBUG_EVENT       0x080
 #define NGX_LOG_DEBUG_HTTP        0x100
 #define NGX_LOG_DEBUG_MAIL        0x200
-#define NGX_LOG_DEBUG_MYSQL       0x400
+#define NGX_LOG_DEBUG_STREAM      0x400
 
 /*
  * do not forget to update debug_levels[] in src/core/ngx_log.c
@@ -37,7 +37,7 @@
  */
 
 #define NGX_LOG_DEBUG_FIRST       NGX_LOG_DEBUG_CORE
-#define NGX_LOG_DEBUG_LAST        NGX_LOG_DEBUG_MYSQL
+#define NGX_LOG_DEBUG_LAST        NGX_LOG_DEBUG_STREAM
 #define NGX_LOG_DEBUG_CONNECTION  0x80000000
 #define NGX_LOG_DEBUG_ALL         0x7ffffff0
 
@@ -110,7 +110,7 @@ void ngx_log_error_core(ngx_uint_t level, ngx_log_t *log, ngx_err_t err,
 
 /*********************************/
 
-#else /* NO VARIADIC MACROS */
+#else /* no variadic macros */
 
 #define NGX_HAVE_VARIADIC_MACROS  0
 
@@ -122,7 +122,7 @@ void ngx_cdecl ngx_log_debug_core(ngx_log_t *log, ngx_err_t err,
     const char *fmt, ...);
 
 
-#endif /* VARIADIC MACROS */
+#endif /* variadic macros */
 
 
 /*********************************/
@@ -165,7 +165,7 @@ void ngx_cdecl ngx_log_debug_core(ngx_log_t *log, ngx_err_t err,
                        arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 
 
-#else /* NO VARIADIC MACROS */
+#else /* no variadic macros */
 
 #define ngx_log_debug0(level, log, err, fmt)                                  \
     if ((log)->log_level & level)                                             \
@@ -210,7 +210,7 @@ void ngx_cdecl ngx_log_debug_core(ngx_log_t *log, ngx_err_t err,
 
 #endif
 
-#else /* NO NGX_DEBUG */
+#else /* !NGX_DEBUG */
 
 #define ngx_log_debug0(level, log, err, fmt)
 #define ngx_log_debug1(level, log, err, fmt, arg1)
@@ -254,6 +254,13 @@ ngx_write_stderr(char *text)
 }
 
 
+static ngx_inline void
+ngx_write_stdout(char *text)
+{
+    (void) ngx_write_fd(ngx_stdout, text, ngx_strlen(text));
+}
+
+
 extern ngx_module_t  ngx_errlog_module;
 extern ngx_uint_t    ngx_use_stderr;
 

data/vendor/nginx/src/core/ngx_module.c

@@ -0,0 +1,360 @@
+
+/*
+ * Copyright (C) Igor Sysoev
+ * Copyright (C) Maxim Dounin
+ * Copyright (C) Nginx, Inc.
+ */
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+#define NGX_MAX_DYNAMIC_MODULES  128
+
+
+static ngx_uint_t ngx_module_index(ngx_cycle_t *cycle);
+static ngx_uint_t ngx_module_ctx_index(ngx_cycle_t *cycle, ngx_uint_t type,
+    ngx_uint_t index);
+
+
+ngx_uint_t         ngx_max_module;
+static ngx_uint_t  ngx_modules_n;
+
+
+ngx_int_t
+ngx_preinit_modules(void)
+{
+    ngx_uint_t  i;
+
+    for (i = 0; ngx_modules[i]; i++) {
+        ngx_modules[i]->index = i;
+        ngx_modules[i]->name = ngx_module_names[i];
+    }
+
+    ngx_modules_n = i;
+    ngx_max_module = ngx_modules_n + NGX_MAX_DYNAMIC_MODULES;
+
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_cycle_modules(ngx_cycle_t *cycle)
+{
+    /*
+     * create a list of modules to be used for this cycle,
+     * copy static modules to it
+     */
+
+    cycle->modules = ngx_pcalloc(cycle->pool, (ngx_max_module + 1)
+                                              * sizeof(ngx_module_t *));
+    if (cycle->modules == NULL) {
+        return NGX_ERROR;
+    }
+
+    ngx_memcpy(cycle->modules, ngx_modules,
+               ngx_modules_n * sizeof(ngx_module_t *));
+
+    cycle->modules_n = ngx_modules_n;
+
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_init_modules(ngx_cycle_t *cycle)
+{
+    ngx_uint_t  i;
+
+    for (i = 0; cycle->modules[i]; i++) {
+        if (cycle->modules[i]->init_module) {
+            if (cycle->modules[i]->init_module(cycle) != NGX_OK) {
+                return NGX_ERROR;
+            }
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+ngx_int_t
+ngx_count_modules(ngx_cycle_t *cycle, ngx_uint_t type)
+{
+    ngx_uint_t     i, next, max;
+    ngx_module_t  *module;
+
+    next = 0;
+    max = 0;
+
+    /* count appropriate modules, set up their indices */
+
+    for (i = 0; cycle->modules[i]; i++) {
+        module = cycle->modules[i];
+
+        if (module->type != type) {
+            continue;
+        }
+
+        if (module->ctx_index != NGX_MODULE_UNSET_INDEX) {
+
+            /* if ctx_index was assigned, preserve it */
+
+            if (module->ctx_index > max) {
+                max = module->ctx_index;
+            }
+
+            if (module->ctx_index == next) {
+                next++;
+            }
+
+            continue;
+        }
+
+        /* search for some free index */
+
+        module->ctx_index = ngx_module_ctx_index(cycle, type, next);
+
+        if (module->ctx_index > max) {
+            max = module->ctx_index;
+        }
+
+        next = module->ctx_index + 1;
+    }
+
+    /*
+     * make sure the number returned is big enough for previous
+     * cycle as well, else there will be problems if the number
+     * will be stored in a global variable (as it's used to be)
+     * and we'll have to roll back to the previous cycle
+     */
+
+    if (cycle->old_cycle && cycle->old_cycle->modules) {
+
+        for (i = 0; cycle->old_cycle->modules[i]; i++) {
+            module = cycle->old_cycle->modules[i];
+
+            if (module->type != type) {
+                continue;
+            }
+
+            if (module->ctx_index > max) {
+                max = module->ctx_index;
+            }
+        }
+    }
+
+    /* prevent loading of additional modules */
+
+    cycle->modules_used = 1;
+
+    return max + 1;
+}
+
+
+ngx_int_t
+ngx_add_module(ngx_conf_t *cf, ngx_str_t *file, ngx_module_t *module,
+    char **order)
+{
+    void               *rv;
+    ngx_uint_t          i, m, before;
+    ngx_core_module_t  *core_module;
+
+    if (cf->cycle->modules_n >= ngx_max_module) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "too many modules loaded");
+        return NGX_ERROR;
+    }
+
+    if (module->version != nginx_version) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "module \"%V\" version %ui instead of %ui",
+                           file, module->version, (ngx_uint_t) nginx_version);
+        return NGX_ERROR;
+    }
+
+    if (ngx_strcmp(module->signature, NGX_MODULE_SIGNATURE) != 0) {
+        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                           "module \"%V\" is not binary compatible",
+                           file);
+        return NGX_ERROR;
+    }
+
+    for (m = 0; cf->cycle->modules[m]; m++) {
+        if (ngx_strcmp(cf->cycle->modules[m]->name, module->name) == 0) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "module \"%s\" is already loaded",
+                               module->name);
+            return NGX_ERROR;
+        }
+    }
+
+    /*
+     * if the module wasn't previously loaded, assign an index
+     */
+
+    if (module->index == NGX_MODULE_UNSET_INDEX) {
+        module->index = ngx_module_index(cf->cycle);
+
+        if (module->index >= ngx_max_module) {
+            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
+                               "too many modules loaded");
+            return NGX_ERROR;
+        }
+    }
+
+    /*
+     * put the module into the cycle->modules array
+     */
+
+    before = cf->cycle->modules_n;
+
+    if (order) {
+        for (i = 0; order[i]; i++) {
+            if (ngx_strcmp(order[i], module->name) == 0) {
+                i++;
+                break;
+            }
+        }
+
+        for ( /* void */ ; order[i]; i++) {
+
+#if 0
+            ngx_log_debug2(NGX_LOG_DEBUG_CORE, cf->log, 0,
+                           "module: %s before %s",
+                           module->name, order[i]);
+#endif
+
+            for (m = 0; m < before; m++) {
+                if (ngx_strcmp(cf->cycle->modules[m]->name, order[i]) == 0) {
+
+                    ngx_log_debug3(NGX_LOG_DEBUG_CORE, cf->log, 0,
+                                   "module: %s before %s:%i",
+                                   module->name, order[i], m);
+
+                    before = m;
+                    break;
+                }
+            }
+        }
+    }
+
+    /* put the module before modules[before] */
+
+    if (before != cf->cycle->modules_n) {
+        ngx_memmove(&cf->cycle->modules[before + 1],
+                    &cf->cycle->modules[before],
+                    (cf->cycle->modules_n - before) * sizeof(ngx_module_t *));
+    }
+
+    cf->cycle->modules[before] = module;
+    cf->cycle->modules_n++;
+
+    if (module->type == NGX_CORE_MODULE) {
+
+        /*
+         * we are smart enough to initialize core modules;
+         * other modules are expected to be loaded before
+         * initialization - e.g., http modules must be loaded
+         * before http{} block
+         */
+
+        core_module = module->ctx;
+
+        if (core_module->create_conf) {
+            rv = core_module->create_conf(cf->cycle);
+            if (rv == NULL) {
+                return NGX_ERROR;
+            }
+
+            cf->cycle->conf_ctx[module->index] = rv;
+        }
+    }
+
+    return NGX_OK;
+}
+
+
+static ngx_uint_t
+ngx_module_index(ngx_cycle_t *cycle)
+{
+    ngx_uint_t     i, index;
+    ngx_module_t  *module;
+
+    index = 0;
+
+again:
+
+    /* find an unused index */
+
+    for (i = 0; cycle->modules[i]; i++) {
+        module = cycle->modules[i];
+
+        if (module->index == index) {
+            index++;
+            goto again;
+        }
+    }
+
+    /* check previous cycle */
+
+    if (cycle->old_cycle && cycle->old_cycle->modules) {
+
+        for (i = 0; cycle->old_cycle->modules[i]; i++) {
+            module = cycle->old_cycle->modules[i];
+
+            if (module->index == index) {
+                index++;
+                goto again;
+            }
+        }
+    }
+
+    return index;
+}
+
+
+static ngx_uint_t
+ngx_module_ctx_index(ngx_cycle_t *cycle, ngx_uint_t type, ngx_uint_t index)
+{
+    ngx_uint_t     i;
+    ngx_module_t  *module;
+
+again:
+
+    /* find an unused ctx_index */
+
+    for (i = 0; cycle->modules[i]; i++) {
+        module = cycle->modules[i];
+
+        if (module->type != type) {
+            continue;
+        }
+
+        if (module->ctx_index == index) {
+            index++;
+            goto again;
+        }
+    }
+
+    /* check previous cycle */
+
+    if (cycle->old_cycle && cycle->old_cycle->modules) {
+
+        for (i = 0; cycle->old_cycle->modules[i]; i++) {
+            module = cycle->old_cycle->modules[i];
+
+            if (module->type != type) {
+                continue;
+            }
+
+            if (module->ctx_index == index) {
+                index++;
+                goto again;
+            }
+        }
+    }
+
+    return index;
+}