passenger 4.0.59 → 4.0.60

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_buf.c

@@ -0,0 +1,43 @@
+
+ngx_int_t
+ndk_copy_chain_to_str (ngx_pool_t *pool, ngx_chain_t *in, ngx_str_t *str)
+{
+    ngx_chain_t     *cl;
+    size_t           len;
+    u_char          *p;
+    ngx_buf_t       *b;
+    
+    len = 0;
+    for (cl = in; cl; cl = cl->next)
+        len += ngx_buf_size (cl->buf);
+    
+    ndk_palloc_re (p, pool, len + 1);
+    
+    str->data = p;
+    str->len = len;
+    
+    for (cl = in; cl; cl = cl->next) {
+        
+        b = cl->buf;
+        
+        if (ngx_buf_in_memory (b)) {
+            p = ngx_cpymem (p, b->pos, b->last - b->pos);
+        }
+    }
+    
+    *p = '\0';
+    
+    return  NGX_OK;
+}
+
+
+char *
+ndk_copy_chain_to_charp (ngx_pool_t *pool, ngx_chain_t *in)
+{
+    ngx_str_t   str;
+    
+    if (ndk_copy_chain_to_str (pool, in, &str) != NGX_OK)
+        return  NULL;
+    
+    return  (char *) str.data;
+}

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_buf.h

@@ -0,0 +1,5 @@
+
+
+ngx_int_t   ndk_copy_chain_to_str   (ngx_pool_t *pool, ngx_chain_t *in, ngx_str_t *str);
+char *      ndk_copy_chain_to_charp (ngx_pool_t *pool, ngx_chain_t *in);
+

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_complex_path.c

@@ -0,0 +1,129 @@
+
+
+ndk_http_complex_path_value_t     ndk_empty_http_complex_path_value = {{0,NULL},0};
+
+
+ngx_int_t
+ndk_http_complex_path_value_compile (ngx_conf_t *cf, ngx_http_complex_value_t *cv, ngx_str_t *value, ngx_uint_t prefix)
+{
+    ngx_http_compile_complex_value_t   ccv;
+
+    ngx_memzero (&ccv, sizeof(ngx_http_compile_complex_value_t));
+
+    ccv.cf = cf;
+    ccv.value = value;
+    ccv.complex_value = cv;
+
+    switch (prefix) {
+
+    case    1 :
+        ccv.root_prefix = 1;
+        break;
+
+    case    2 :
+        ccv.conf_prefix = 1;
+        break;
+    }
+
+    ndk_path_to_dir_safe (value, 1, 0);
+
+    if (!value->len)
+        return  NGX_OK;
+
+    return  ngx_http_compile_complex_value (&ccv);
+}
+
+
+
+ngx_array_t *
+ndk_http_complex_path_create_compile (ngx_conf_t *cf, ngx_str_t *path, ngx_uint_t prefix)
+{
+    ndk_http_complex_path_elt_t     *cpe;
+    ngx_array_t                     *a;
+    ngx_int_t                        n;
+    u_char                          *m, *s, *e;
+    ngx_str_t                        value;
+
+    n = ndk_strcntc (path, ':') + 1;
+
+    a = ngx_array_create (cf->pool, n, sizeof (ndk_http_complex_path_elt_t));
+    if (a == NULL) {
+        return  NULL;
+    }
+
+    s = path->data;
+    e = s + path->len;
+
+
+    while (s < e) {
+
+        m = s;
+
+        while (m < e && *m != ':') m++;
+
+        if (m == s) {
+            s = m+1;
+            continue;
+        }
+
+        cpe = ngx_array_push (a);
+        if (cpe == NULL) {
+            return  NULL;
+        }
+
+        if (*s == '#') {
+            s++;
+            cpe->dynamic = 1;
+        } else {
+            cpe->dynamic = 0;
+        }
+
+        value.data = s;
+        value.len = m - s;
+
+        if (ndk_http_complex_path_value_compile (cf, &cpe->val, &value, prefix) == NGX_ERROR)
+            return  NULL;
+
+        s = m+1;
+    }
+
+    return  a;
+}
+
+
+
+
+char *
+ndk_conf_set_http_complex_path_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_str_t                   *path;
+    ngx_array_t                 *a;
+    ngx_conf_post_t             *post;
+    ndk_http_complex_path_t     *cp;
+
+    cp = (ndk_http_complex_path_t *) (p + cmd->offset);
+
+    if (cp->a != NGX_CONF_UNSET_PTR) {
+        return  "is duplicate";
+    }
+
+    path = cf->args->elts;
+    path++;
+
+    cp->a = ndk_http_complex_path_create_compile (cf, path, cp->prefix);
+    if (cp->a == NULL)
+        /* TODO : log */
+        return  NGX_CONF_ERROR;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, a);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_complex_path.h

@@ -0,0 +1,30 @@
+
+
+typedef struct {
+    ngx_array_t                    *a;
+    ngx_uint_t                      prefix;
+} ndk_http_complex_path_t;
+
+typedef struct {
+    ngx_http_complex_value_t        val;
+    ngx_flag_t                      dynamic;
+} ndk_http_complex_path_elt_t;
+
+typedef struct {
+    ngx_str_t                       val;
+    ngx_flag_t                      dynamic;
+} ndk_http_complex_path_value_t;
+
+typedef struct {
+    ndk_http_complex_path_value_t  *elts;
+    ngx_uint_t                      nelts;
+} ndk_http_complex_path_values_t;
+
+
+extern  ndk_http_complex_path_value_t     ndk_empty_http_complex_path_value;
+
+
+ngx_array_t *   ndk_http_complex_path_create_compile     (ngx_conf_t *cf, ngx_str_t *path, ngx_uint_t prefix);
+ngx_int_t       ndk_http_complex_path_value_compile      (ngx_conf_t *cf, ngx_http_complex_value_t *cv, 
+                                                                    ngx_str_t *value, ngx_uint_t prefix);
+char *          ndk_conf_set_http_complex_path_slot      (ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_complex_value.c

@@ -0,0 +1,192 @@
+
+
+
+ngx_int_t
+ndk_http_complex_value_compile (ngx_conf_t *cf, ngx_http_complex_value_t *cv, ngx_str_t *value)
+{
+    ngx_http_compile_complex_value_t   ccv;
+
+    ngx_memzero (&ccv, sizeof(ngx_http_compile_complex_value_t));
+
+    ccv.cf = cf;
+    ccv.value = value;
+    ccv.complex_value = cv;
+
+    return  ngx_http_compile_complex_value (&ccv);
+}
+
+
+
+
+ngx_array_t *
+ndk_http_complex_value_array_create (ngx_conf_t *cf, char **s, ngx_int_t n)
+{
+    ngx_int_t                    i;
+    ngx_http_complex_value_t    *cv;
+    ngx_array_t                 *a;
+    ngx_str_t                    value;
+
+    a = ngx_array_create (cf->pool, n, sizeof (ngx_http_complex_value_t));
+    if (a == NULL)
+        return  NULL;
+
+
+    for (i=0; i<n; i++, s++) {
+
+        cv = ngx_array_push (a);
+
+        value.data = (u_char *) *s;
+        value.len = strlen (*s);
+
+        if (ndk_http_complex_value_compile (cf, cv, &value))
+            return  NULL;
+    }
+
+    return  a;
+}
+
+
+
+ngx_int_t
+ndk_http_complex_value_array_compile (ngx_conf_t *cf, ngx_array_t *a)
+{
+    ngx_int_t                   i;
+    ngx_http_complex_value_t   *cv;
+
+    if (a == NULL || a == NGX_CONF_UNSET_PTR) {
+        return  NGX_ERROR;
+    }
+
+    cv = a->elts;
+
+    for (i=0; i<a->nelts; i++, cv++) {
+
+        if (ndk_http_complex_value_compile (cf, cv, &cv->value))
+            return  NGX_ERROR;
+    }
+
+    return  NGX_OK;
+}
+
+
+
+char *
+ndk_conf_set_http_complex_value_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_http_complex_value_t    *cv;
+    ngx_str_t                   *value;
+    ngx_conf_post_t             *post;
+
+    cv = (ngx_http_complex_value_t *) (p + cmd->offset);
+
+    if (cv->value.data) {
+        return "is duplicate";
+    }
+
+    value = cf->args->elts;
+
+    if (ndk_http_complex_value_compile (cf, cv, value + 1))
+        return  NGX_CONF_ERROR;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, cv);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_http_complex_value_array_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char *p = conf;
+
+    ngx_str_t                   *value;
+    ngx_http_complex_value_t    *cv;
+    ngx_array_t                **a;
+    ngx_conf_post_t             *post;
+    ngx_int_t                    i, alloc;
+
+    a = (ngx_array_t **) (p + cmd->offset);
+
+    if (*a == NULL || *a == NGX_CONF_UNSET_PTR) {
+
+        alloc = cf->args->nelts > 4 ? cf->args->nelts : 4;
+
+        *a = ngx_array_create (cf->pool, alloc, sizeof (ngx_http_complex_value_t));
+        if (*a == NULL) {
+            return  NGX_CONF_ERROR;
+        }
+    }
+
+    value = cf->args->elts;
+
+    for (i=1; i<cf->args->nelts; i++) {
+
+        cv = ngx_array_push (*a);
+        if (cv == NULL) {
+            return  NGX_CONF_ERROR;
+        }
+
+        if (ndk_http_complex_value_compile (cf, cv, &value[i]) == NGX_ERROR)
+            return  NGX_CONF_ERROR;
+    }
+
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, a);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+char *
+ndk_conf_set_http_complex_keyval_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char *p = conf;
+
+    ngx_str_t                   *value;
+    ndk_http_complex_keyval_t   *ckv;
+    ngx_array_t                **a;
+    ngx_conf_post_t             *post;
+    ngx_int_t                    alloc;
+
+    a = (ngx_array_t **) (p + cmd->offset);
+
+    if (*a == NULL || *a == NGX_CONF_UNSET_PTR) {
+
+        alloc = cf->args->nelts > 4 ? cf->args->nelts : 4;
+
+        *a = ngx_array_create (cf->pool, alloc, sizeof (ndk_http_complex_keyval_t));
+        if (*a == NULL) {
+            return  NGX_CONF_ERROR;
+        }
+    }
+
+    ckv = ngx_array_push (*a);
+    if (ckv == NULL) {
+        return  NGX_CONF_ERROR;
+    }
+
+    value = cf->args->elts;
+
+    ckv->key = value[1];
+
+    if (ndk_http_complex_value_compile (cf, &ckv->value, &value[2]) == NGX_ERROR)
+        return  NGX_CONF_ERROR;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, a);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+/* TODO : complex keyval1 */

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_complex_value.h

@@ -0,0 +1,21 @@
+
+
+typedef struct {
+    ngx_str_t                   key;
+    ngx_http_complex_value_t    value;
+} ndk_http_complex_keyval_t;
+
+
+
+/* create/compile functions */
+
+ngx_int_t      ndk_http_complex_value_compile        (ngx_conf_t *cf, ngx_http_complex_value_t *cv, ngx_str_t *value);
+ngx_array_t *  ndk_http_complex_value_array_create   (ngx_conf_t *cf, char **s, ngx_int_t n);
+ngx_int_t      ndk_http_complex_value_array_compile  (ngx_conf_t *cf, ngx_array_t *a);
+
+
+/* conf set slot functions */
+
+char *  ndk_conf_set_http_complex_keyval_slot        (ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+char *  ndk_conf_set_http_complex_value_slot         (ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
+char *  ndk_conf_set_http_complex_value_array_slot   (ngx_conf_t *cf, ngx_command_t *cmd, void *conf);

data/packaging/debian/debian_specs/nginx/modules/nginx-development-kit/src/ndk_conf_file.c

@@ -0,0 +1,396 @@
+
+
+/* NOTE : you will find other conf_set functions in the following files :
+ *
+ * complex_value.c
+ * encoding.c
+ * path.c
+ *
+ */
+
+
+char *
+ndk_conf_set_true_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_flag_t       *fp;
+    ngx_conf_post_t  *post;
+
+    fp = (ngx_flag_t*) (p + cmd->offset);
+
+    if (*fp != NGX_CONF_UNSET) {
+        return  "is duplicate";
+    }
+
+    *fp = 1;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, fp);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_false_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_flag_t       *fp;
+    ngx_conf_post_t  *post;
+
+    fp = (ngx_flag_t*) (p + cmd->offset);
+
+    if (*fp != NGX_CONF_UNSET) {
+        return  "is duplicate";
+    }
+
+    *fp = 0;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, fp);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+
+char *
+ndk_conf_set_ptr_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    void  **ptr;
+
+    ptr = (void**) (p + cmd->offset);
+
+    if (*ptr != NGX_CONF_UNSET_PTR) {
+        return  "is duplicate";
+    }
+
+    *ptr = cmd->post;
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_null_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    void            **pp;
+    ngx_conf_post_t  *post;
+
+    pp = (void **) (p + cmd->offset);
+
+    if (*pp != NGX_CONF_UNSET_PTR) {
+        return  "is duplicate";
+    }
+
+    *pp = NULL;
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, pp);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+char *
+ndk_conf_set_num64_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    int64_t          *np;
+    ngx_str_t        *value;
+    ngx_conf_post_t  *post;
+
+
+    np = (int64_t *) (p + cmd->offset);
+
+    if (*np != NGX_CONF_UNSET) {
+        return "is duplicate";
+    }
+
+    value = cf->args->elts;
+    *np = ndk_atoi64 (value[1].data, value[1].len);
+    if (*np == NGX_ERROR) {
+        return "invalid number";
+    }
+
+    if (cmd->post) {
+        post = cmd->post;
+        return post->post_handler(cf, post, np);
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+char *
+ndk_conf_set_str_array_multi_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_str_t         *value, *s;
+    ngx_array_t      **a;
+    ngx_conf_post_t   *post;
+    ngx_uint_t         i;
+
+    a = (ngx_array_t **) (p + cmd->offset);
+
+    if (*a == NGX_CONF_UNSET_PTR) {
+        *a = ngx_array_create(cf->pool, 4, sizeof(ngx_str_t));
+        if (*a == NULL) {
+            return NGX_CONF_ERROR;
+        }
+    }
+
+    s = NULL;
+
+    for (i=cf->args->nelts-1; i; i--) {
+
+        s = ngx_array_push(*a);
+        if (s == NULL) {
+            return NGX_CONF_ERROR;
+        }
+
+        value = cf->args->elts;
+
+        *s = value[i];
+    }
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler(cf, post, s);
+    }
+
+    return NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_keyval1_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_str_t           *value;
+    ngx_keyval_t        *kv;
+    ngx_conf_post_t     *post;
+
+    kv = (ngx_keyval_t *) (p + cmd->offset);
+
+    if (kv->key.data)
+        return  "is duplicate";
+
+    value = cf->args->elts;
+
+    kv->key = value[1];
+    kv->value = value[2];
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, kv);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_num_flag_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    ngx_int_t        *np;
+    ngx_str_t        *value;
+    ngx_conf_post_t  *post;
+
+    np = (ngx_int_t *) (p + cmd->offset);
+
+    if (*np != NGX_CONF_UNSET) {
+        return  "is duplicate";
+    }
+
+    value = cf->args->elts;
+
+    if (ngx_strcasecmp (value[1].data, (u_char *) "on") == 0) {
+        *np = NDK_CONF_SET_TRUE;
+
+    } else if (ngx_strcasecmp (value[1].data, (u_char *) "off") == 0) {
+        *np = NDK_CONF_SET_FALSE;
+
+    } else {
+        *np = ngx_atoi (value[1].data, value[1].len);
+        if (*np == NGX_ERROR) {
+            return  "invalid number and not 'on'/'off'";
+        }
+    }
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, np);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+char *
+ndk_conf_set_sec_flag_slot (ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
+{
+    char  *p = conf;
+
+    time_t              *tp;
+    ngx_str_t           *value;
+    ngx_conf_post_t     *post;
+
+    tp = (time_t *) (p + cmd->offset);
+
+    if (*tp != NGX_CONF_UNSET) {
+        return  "is duplicate";
+    }
+
+    value = cf->args->elts;
+
+    if (ngx_strcasecmp (value[1].data, (u_char *) "on") == 0) {
+        *tp = NDK_CONF_SET_TRUE;
+
+    } else if (ngx_strcasecmp (value[1].data, (u_char *) "off") == 0) {
+        *tp = NDK_CONF_SET_FALSE;
+
+    } else {
+        *tp = ngx_parse_time (&value[1], 1);
+        if (*tp == NGX_ERROR) {
+            return  "has an invalid time and not 'on'/'off'";
+        }
+    }
+
+    if (cmd->post) {
+        post = cmd->post;
+        return  post->post_handler (cf, post, tp);
+    }
+
+    return  NGX_CONF_OK;
+}
+
+
+
+ngx_http_conf_ctx_t *
+ndk_conf_create_http_location (ngx_conf_t *cf)
+{
+    ngx_http_conf_ctx_t          *ctx, *pctx;
+    void                         *mconf;
+    ngx_http_core_loc_conf_t     *clcf, *pclcf;
+    ngx_uint_t                    i;
+    ngx_http_module_t            *module;
+
+    ndk_pcallocp_rce (ctx, cf->pool);
+
+    pctx = cf->ctx;
+    ctx->main_conf = pctx->main_conf;
+    ctx->srv_conf = pctx->srv_conf;
+
+    ndk_pcalloc_rce (ctx->loc_conf, cf->pool, sizeof(void *) * ngx_http_max_module);
+
+
+    for (i = 0; ngx_modules[i]; i++) {
+        if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
+            continue;
+        }
+
+        module = ngx_modules[i]->ctx;
+
+        if (module->create_loc_conf) {
+
+            mconf = module->create_loc_conf(cf);
+            if (mconf == NULL) {
+                 return NGX_CONF_ERROR;
+            }
+
+            ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
+        }
+    }
+
+    pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];
+
+    clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
+    clcf->loc_conf = ctx->loc_conf;
+    clcf->name = pclcf->name;
+    clcf->noname = 1;
+
+    if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
+        return NGX_CONF_ERROR;
+    }
+
+    return  ctx;
+}
+
+
+ngx_http_conf_ctx_t *
+ngx_conf_create_http_named_location (ngx_conf_t *cf, ngx_str_t *name)
+{
+    ngx_http_conf_ctx_t          *ctx;
+    ngx_http_core_loc_conf_t     *clcf;
+
+    ctx = ndk_conf_create_http_location (cf);
+    if (ctx == NGX_CONF_ERROR)
+        return  NGX_CONF_ERROR;
+
+    clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
+
+    /* in case the developer forgets to add '@' at the beginning of the named location */
+
+    if (name->data[0] != '@' && ndk_catstrf (cf->pool, name, "sS", "@", name) == NULL)
+        return  NGX_CONF_ERROR;
+
+    clcf->name = *name;     /* TODO : copy? */
+    clcf->noname = 0;
+    clcf->named = 1;
+
+    return  ctx;
+}
+
+
+ngx_int_t
+ndk_replace_command (ngx_command_t *new_cmd, ngx_uint_t module_type)
+{
+    ngx_uint_t       i;
+    ngx_command_t   *cmd;
+
+    for (i = 0; ngx_modules[i]; i++) {
+
+        if (ngx_modules[i]->type != module_type)
+            continue;
+
+        cmd = ngx_modules[i]->commands;
+        if (cmd == NULL) {
+            continue;
+        }
+
+        for ( /* void */ ; cmd->name.len; cmd++) {
+
+            if (ndk_cmpstr (&new_cmd->name, &cmd->name) == 0) {
+
+                ndk_memcpyp (cmd, new_cmd);
+                return  NGX_OK;
+            }
+        }
+    }
+
+    return  NGX_DECLINED;
+}