nginx-0.0.3-2004-05-25-19:28:46 import

auto/sources

@@ -18,6 +18,7 @@ CORE_DEPS="src/core/nginx.h \
             src/core/ngx_file.h \
             src/core/ngx_crc.h \
             src/core/ngx_rbtree.h \
+            src/core/ngx_radix_tree.h \
             src/core/ngx_times.h \
             src/core/ngx_connection.h \
             src/core/ngx_cycle.h \
@@ -35,6 +36,7 @@ CORE_SRCS="src/core/nginx.c \
             src/core/ngx_inet.c \
             src/core/ngx_file.c \
             src/core/ngx_rbtree.c \
+            src/core/ngx_radix_tree.c \
             src/core/ngx_times.c \
             src/core/ngx_connection.c \
             src/core/ngx_cycle.c \

src/core/ngx_core.h

@@ -37,6 +37,7 @@ typedef struct ngx_connection_s  ngx_connection_t;
 #include <ngx_regex.h>
 #endif
 #include <ngx_rbtree.h>
+#include <ngx_radix_tree.h>
 #include <ngx_times.h>
 #include <ngx_inet.h>
 #include <ngx_cycle.h>

src/core/ngx_inet.c

@@ -164,3 +164,38 @@ size_t ngx_inet_ntop(int family, void *addr, u_char *text, size_t len)
                         "%u.%u.%u.%u", p[0], p[1], p[2], p[3]);
 #endif
 }
+
+
+/* AF_INET only */
+
+ngx_int_t ngx_ptocidr(ngx_str_t *text, void *cidr)
+{
+    ngx_uint_t        i;
+    ngx_inet_cidr_t  *in_cidr;
+
+    in_cidr = cidr;
+
+    for (i = 0; i < text->len; i++) {
+        if (text->data[i] == '/') {
+            break;
+        }
+    }
+
+    if (i == text->len) {
+        return NGX_ERROR;
+    }
+
+    text->data[i] = '\0';
+    in_cidr->addr = inet_addr((char *) text->data);
+    text->data[i] = '/';
+    if (in_cidr->addr == INADDR_NONE) {
+        return NGX_ERROR;
+    }
+
+    in_cidr->mask = ngx_atoi(&text->data[i + 1], text->len - (i + 1));
+    if (in_cidr->mask == (in_addr_t) NGX_ERROR) {
+        return NGX_ERROR;
+    }
+
+    return NGX_OK;
+}

src/core/ngx_inet.h

@@ -2,9 +2,17 @@
 #define _NGX_INET_H_INCLUDED_
 
 
+typedef struct {
+    in_addr_t  addr;
+    in_addr_t  mask;
+} ngx_inet_cidr_t;
+
+
 size_t ngx_sock_ntop(int family, struct sockaddr *addr, u_char *text,
                      size_t len);
 size_t ngx_inet_ntop(int family, void *addr, u_char *text, size_t len);
 
+ngx_int_t ngx_ptocidr(ngx_str_t *text, void *cidr);
+
 
 #endif /* _NGX_INET_H_INCLUDED_ */

src/core/ngx_radix_tree.c

@@ -0,0 +1,152 @@
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+/* STUB: page size */
+#define NGX_RADIX_TREE_POOL_SIZE  4096
+
+
+static void *ngx_radix_alloc(ngx_radix_tree_t *tree, size_t size);
+
+
+ngx_radix_tree_t *ngx_radix_tree_create(ngx_pool_t *pool)
+{
+    ngx_radix_tree_t  *tree;
+
+    if (!(tree = ngx_palloc(pool, sizeof(ngx_radix_tree_t)))) {
+        return NULL;
+    }
+
+    tree->root = NULL;
+    tree->pool = pool;
+    tree->free = NULL;
+    tree->size = 0;
+
+    return tree;
+}
+
+
+ngx_int_t ngx_radix32tree_insert(ngx_radix_tree_t *tree,
+                                 uint32_t key, uint32_t mask, uintptr_t value)
+{
+    uint32_t           bit;
+    ngx_radix_node_t  *node, *new;
+
+    bit = 0x80000000;
+    node = tree->root;
+
+    while (node && (bit & mask)) {
+        if (key & bit) {
+            node = node->right;
+
+        } else {
+            node = node->left;
+        }
+
+        bit >>= 1;
+    }
+
+    if (node) {
+        if (node->value) {
+            return NGX_BUSY;
+        }
+
+        node->value = value;
+        return NGX_OK;
+    }
+
+    while (bit & mask) {
+        if (!(new = ngx_radix_alloc(tree, sizeof(ngx_radix_node_t)))) {
+            return NGX_ERROR;
+        }
+
+        new->value = value;
+
+        if (key & bit) {
+            node->right = new;
+
+        } else {
+            node->left = new;
+        }
+
+        bit >>= 1;
+        new = node;
+    }
+
+    return NGX_OK;
+}
+
+
+void ngx_radix32tree_delete(ngx_radix_tree_t *tree, uint32_t key, uint32_t mask)
+{
+    uint32_t           bit;
+    ngx_radix_node_t  *node;
+
+    bit = 0x80000000;
+    node = tree->root;
+
+    while (node && (bit & mask)) {
+        if (key & bit) {
+            node = node->right;
+
+        } else {
+            node = node->left;
+        }
+
+        bit >>= 1;
+    }
+
+    if (node) {
+        node->value = (uintptr_t) 0;
+    }
+}
+
+
+uintptr_t ngx_radix32tree_find(ngx_radix_tree_t *tree, uint32_t key)
+{
+    uint32_t           bit;
+    uintptr_t          value;
+    ngx_radix_node_t  *node;
+
+    bit = 0x80000000;
+    value = NULL;
+    node = tree->root;
+
+    while (node) {
+        if (node->value) {
+            value = node->value;
+        }
+
+        if (key & bit) {
+            node = node->right;
+
+        } else {
+            node = node->left;
+        }
+
+        bit >>= 1;
+    }
+
+    return value;
+}
+
+
+static void *ngx_radix_alloc(ngx_radix_tree_t *tree, size_t size)
+{
+    char  *p;
+
+    if (tree->size < size) {
+        if (!(tree->free = ngx_palloc(tree->pool, NGX_RADIX_TREE_POOL_SIZE))) {
+            return NULL;
+        }
+
+        tree->size = NGX_RADIX_TREE_POOL_SIZE;
+    }
+
+    p = tree->free;
+    tree->free += size;
+    tree->size -= size;
+
+    return p;
+}

src/core/ngx_radix_tree.h

@@ -0,0 +1,34 @@
+#ifndef _NGX_RADIX_TREE_H_INCLUDED_
+#define _NGX_RADIX_TREE_H_INCLUDED_
+
+
+#include <ngx_config.h>
+#include <ngx_core.h>
+
+
+typedef struct ngx_radix_node_s  ngx_radix_node_t;
+
+struct ngx_radix_node_s {
+    uintptr_t          value;
+    ngx_radix_node_t  *right;
+    ngx_radix_node_t  *left;
+};
+
+
+typedef struct {
+    ngx_radix_node_t  *root;
+    ngx_pool_t        *pool;
+    char              *free;
+    size_t             size;
+} ngx_radix_tree_t;
+
+
+ngx_radix_tree_t *ngx_radix_tree_create(ngx_pool_t *pool);
+ngx_int_t ngx_radix32tree_insert(ngx_radix_tree_t *tree,
+                                 uint32_t key, uint32_t mask, uintptr_t value);
+void ngx_radix32tree_delete(ngx_radix_tree_t *tree,
+                            uint32_t key, uint32_t mask);
+uintptr_t ngx_radix32tree_find(ngx_radix_tree_t *tree, uint32_t key);
+
+
+#endif /* _NGX_RADIX_TREE_H_INCLUDED_ */

src/http/modules/ngx_http_charset_filter.c

@@ -291,8 +291,8 @@ static char *ngx_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd,
     }
 
     for (i = 0; i < 128; i++) {
-        table->src2dst[i] = i;
+        table->src2dst[i] = (char) i;
-        table->dst2src[i] = i;
+        table->dst2src[i] = (char) i;
     }
 
     for (/* void */; i < 256; i++) {
@@ -313,8 +313,6 @@ static char *ngx_charset_map_block(ngx_conf_t *cf, ngx_command_t *cmd,
 
 static char *ngx_charset_map(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
 {
-    ngx_http_charset_main_conf_t  *mcf = conf;
-
     ngx_int_t                   src, dst;
     ngx_str_t                  *value;
     ngx_http_charset_tables_t  *table;
@@ -342,8 +340,8 @@ static char *ngx_charset_map(ngx_conf_t *cf, ngx_command_t *dummy, void *conf)
 
     table = cf->ctx;
 
-    table->src2dst[src] = dst;
+    table->src2dst[src] = (char) dst;
-    table->dst2src[dst] = src;
+    table->dst2src[dst] = (char) src;
 
     return NGX_CONF_OK;
 }
@@ -449,7 +447,7 @@ static char *ngx_http_charset_init_main_conf(ngx_conf_t *cf, void *conf)
     ngx_http_charset_main_conf_t *mcf = conf;
 
     ngx_uint_t                  i, n;
-    ngx_http_charset_t         *charset, *c;
+    ngx_http_charset_t         *charset;
     ngx_http_charset_tables_t  *tables;
 
     tables = mcf->tables.elts;
@@ -531,13 +529,12 @@ static char *ngx_http_charset_merge_loc_conf(ngx_conf_t *cf,
     ngx_conf_merge_value(conf->enable, prev->enable, 0);
     ngx_conf_merge_value(conf->autodetect, prev->autodetect, 0);
 
-    if (conf->default_charset == NGX_CONF_UNSET) {
-        conf->default_charset = prev->default_charset;
-    }
-
     if (conf->source_charset == NGX_CONF_UNSET) {
         conf->source_charset = prev->source_charset;
     }
 
+    ngx_conf_merge_value(conf->default_charset, prev->default_charset,
+                         conf->source_charset);
+
     return NGX_CONF_OK;
 }