Changeset 298

Timestamp:

04/23/2005 06:32:23 PM (3 years ago)

Author:

moo

Message:

nesting/chaining condition
new config item: debug.log-condition-handling

Location:

trunk

Files:

• src/Makefile.am (modified) (2 diffs)
• src/array.c (modified) (1 diff)
• src/array.h (modified) (5 diffs)
• src/base.h (modified) (2 diffs)
• src/configfile-glue.c (modified) (10 diffs)
• src/configfile.c (modified) (12 diffs)
• src/configfile.h (modified) (1 diff)
• src/configparser.y (modified) (8 diffs)
• src/connections.c (modified) (1 diff)
• tests/Makefile.am (modified) (1 diff)
• tests/condition.conf (added)
• tests/core-condition.t (added)

trunk/src/Makefile.am

@@ -34 +34 @@
       data_string.c data_count.c data_array.c \
       data_integer.c md5.c data_fastcgi.c \
-      data_config.c bitset.c  configparser.c \
+      data_config.c bitset.c \
       inet_ntop_cache.c \
       connections-glue.c \
@@ -45 +45 @@
       network_send.c network-glue.c fdevent-glue.c
 
-src = server.c response.c connections.c configfile.c \
+src = server.c response.c connections.c configfile.c configparser.c \
       request.c network.c log.c fdevent.c \
       fdevent_select.c fdevent_linux_rtsig.c \

trunk/src/array.c

@@ -44 +44 @@
         
         a->used = 0;
+}
+
+data_unset *array_pop(array *a) {
+        data_unset *du;
+
+        assert(a->used != 0);
+
+        a->used --;
+        du = a->data[a->used];
+        a->data[a->used] = NULL;
+
+        return du;
 }
 

trunk/src/array.h

@@ -63 +63 @@
 
 typedef enum { CONFIG_COND_UNSET, CONFIG_COND_EQ, CONFIG_COND_MATCH, CONFIG_COND_NE, CONFIG_COND_NOMATCH } config_cond_t;
+typedef enum { COND_RESULT_FALSE, COND_RESULT_TRUE, COND_RESULT_UNSET } cond_result_t;
 
 /* $HTTP["host"] ==    "incremental.home.kneschke.de" { ... } 
@@ -68 +69 @@
  */
 
-typedef struct {
+typedef struct _data_config data_config;
+struct _data_config {
         DATA_UNSET;
         
@@ -76 +78 @@
         
         config_cond_t cond;
+        int context_ndx; /* more or less like an id */
+        array *childs;
+        /* nested */
+        data_config *parent;
+        /* for chaining only */
+        data_config *prev;
+        data_config *next;
         
         buffer *string;
@@ -82 +91 @@
         pcre_extra *regex_study;
 #endif
-} data_config;
+};
 
 data_config *data_config_init(void);
@@ -112 +121 @@
 void array_reset(array *a);
 int array_insert_unique(array *a, data_unset *str);
+data_unset *array_pop(array *a);
 int array_print(array *a, int depth);
 data_unset *array_get_unused_element(array *a, data_type_t t);

trunk/src/base.h

@@ -216 +216 @@
         unsigned short log_request_handling;
         unsigned short log_response_header;
+        unsigned short log_condition_handling;
         
         
@@ -344 +345 @@
         
         specific_config conf;        /* global connection specific config */
+        cond_result_t *cond_results_cache;
         
         buffer *server_name;

trunk/src/configfile-glue.c

@@ -5 +5 @@
 #include "array.h"
 #include "log.h"
+#include "plugin.h"
 
 /**
@@ -156 +157 @@
 }
 
-int config_check_cond(server *srv, connection *con, data_config *dc) {
+static int config_check_cond_cached(server *srv, connection *con, data_config *dc);
+
+static cond_result_t config_check_cond_nocache(server *srv, connection *con, data_config *dc) {
         server_socket *srv_sock = con->srv_socket;
         buffer *l;
         
-        /* pass the rules */
-        
+        /* check parent first */
+        if (dc->parent) {
+                if (con->conf.log_condition_handling) {
+                        log_error_write(srv, __FILE__, __LINE__,  "sb", "go parent", dc->parent->string);
+                }
+                if (!config_check_cond_cached(srv, con, dc->parent)) {
+                        return COND_RESULT_FALSE;
+                }
+        }
+
+        if (dc->prev) {
+                if (con->conf.log_condition_handling) {
+                        log_error_write(srv, __FILE__, __LINE__,  "sb", "go prev", dc->prev->string);
+                }
+                /* make sure prev is checked first */
+                config_check_cond_cached(srv, con, dc->prev);
+                /* one of prev set me to FALSE */
+                if (con->cond_results_cache[dc->context_ndx] == COND_RESULT_FALSE) {
+                        return COND_RESULT_FALSE;
+                }
+        }
+
         /* 
          * OPTIMIZE
          * 
          * - replace all is_equal be simple == to an enum
-         * - only check each condition once at the start of the request
-         *   afterwards they will always evaluate in the same way 
-         *   as they have the same input data
          * 
          */
+
+        /* pass the rules */
         
         buffer_copy_string(srv->cond_check_buf, "");
@@ -224 +246 @@
                                 log_error_write(srv, __FILE__, __LINE__, "sb", "ERROR: no number after / ", dc->string);
                                         
-                                return 0;
+                                return COND_RESULT_FALSE;
                         }
                         
@@ -232 +254 @@
                                 log_error_write(srv, __FILE__, __LINE__, "sbs", "ERROR: non-digit found in netmask:", dc->string, *err);
                                 
-                                return 0;
+                                return COND_RESULT_FALSE;
                         }
                         
@@ -241 +263 @@
                                 log_error_write(srv, __FILE__, __LINE__, "sb", "ERROR: ip addr is invalid:", srv->cond_check_buf);
                                 
-                                return 0;
+                                return COND_RESULT_FALSE;
                         }
 
@@ -248 +270 @@
                                 log_error_write(srv, __FILE__, __LINE__, "sb", "ERROR: ip addr is invalid:", srv->cond_check_buf);
                                 
-                                return 0;
+                                return COND_RESULT_FALSE;
                         }
 #endif
@@ -256 +278 @@
                         
                         if ((val_inp.s_addr & nm) == (con->dst_addr.ipv4.sin_addr.s_addr & nm)) {
-                                return (dc->cond == CONFIG_COND_EQ) ? 1 : 0;
+                                return (dc->cond == CONFIG_COND_EQ) ? COND_RESULT_TRUE : COND_RESULT_FALSE;
                         } else {
-                                return (dc->cond == CONFIG_COND_EQ) ? 0 : 1;
+                                return (dc->cond == CONFIG_COND_EQ) ? COND_RESULT_FALSE : COND_RESULT_TRUE;
                         }
                 } else {
@@ -296 +318 @@
                 }
         } else {
-                return 0;
+                return COND_RESULT_FALSE;
         }
         
         l = srv->cond_check_buf;
         
+        if (con->conf.log_condition_handling) {
+                log_error_write(srv, __FILE__, __LINE__,  "bsbsb", dc->comp_key, "(", l, ") compare to ", dc->string);
+        }
         switch(dc->cond) {
         case CONFIG_COND_NE:
         case CONFIG_COND_EQ:
                 if (buffer_is_equal(l, dc->string)) {
-                        return (dc->cond == CONFIG_COND_EQ) ? 1 : 0;
+                        return (dc->cond == CONFIG_COND_EQ) ? COND_RESULT_TRUE : COND_RESULT_FALSE;
                 } else {
-                        return (dc->cond == CONFIG_COND_EQ) ? 0 : 1;
+                        return (dc->cond == CONFIG_COND_EQ) ? COND_RESULT_FALSE : COND_RESULT_TRUE;
                 }
                 break;
@@ -321 +346 @@
                 
                 if (n > 0) {
-                        return (dc->cond == CONFIG_COND_MATCH) ? 1 : 0;
+                        return (dc->cond == CONFIG_COND_MATCH) ? COND_RESULT_TRUE : COND_RESULT_FALSE;
                 } else {
-                        return (dc->cond == CONFIG_COND_MATCH) ? 0 : 1;
+                        return (dc->cond == CONFIG_COND_MATCH) ? COND_RESULT_FALSE : COND_RESULT_TRUE;
                 }
 #endif          
@@ -334 +359 @@
         }
         
-        return 0;
-}
-
+        return COND_RESULT_FALSE;
+}
+
+static int config_check_cond_cached(server *srv, connection *con, data_config *dc) {
+        cond_result_t *cache = con->cond_results_cache;
+
+        if (cache[dc->context_ndx] == COND_RESULT_UNSET) {
+                if (COND_RESULT_TRUE == (cache[dc->context_ndx] = config_check_cond_nocache(srv, con, dc))) {
+                        if (dc->next) {
+                                data_config *c;
+                                if (con->conf.log_condition_handling) {
+                                        log_error_write(srv, __FILE__, __LINE__, "s", "setting remains of chaining to FALSE");
+                                }
+                                for (c = dc->next; c; c = c->next) {
+                                        cache[c->context_ndx] = COND_RESULT_FALSE;
+                                }
+                        }
+                }
+                if (con->conf.log_condition_handling) {
+                        log_error_write(srv, __FILE__, __LINE__, "dsd", dc->context_ndx, "(uncached) result:", cache[dc->context_ndx]);
+                }
+        }
+        else {
+                if (con->conf.log_condition_handling) {
+                        log_error_write(srv, __FILE__, __LINE__, "dsd", dc->context_ndx, "(cached) result:", cache[dc->context_ndx]);
+                }
+        }
+        return cache[dc->context_ndx];
+}
+
+int config_check_cond(server *srv, connection *con, data_config *dc) {
+        if (con->conf.log_condition_handling) {
+                log_error_write(srv, __FILE__, __LINE__,  "s",  "=== start of condition block ===");
+        }
+        return config_check_cond_cached(srv, con, dc);
+}

trunk/src/configfile.c

@@ -71 +71 @@
                 { "server.close-stderr",         NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_SERVER },     /* 37 */
                 { "server.force-lowercase-filenames", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_SERVER },   /* 38 */
+                { "debug.log-condition-handling", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_SERVER }, /* 39 */
                 
                 { "server.host",                 "use server.bind instead", T_CONFIG_DEPRECATED, T_CONFIG_SCOPE_UNSET },
@@ -169 +170 @@
                 
                 cv[38].destination = &(s->force_lower_case);
+                cv[39].destination = &(s->log_condition_handling);
                 
                 srv->config_storage[i] = s;
@@ -185 +187 @@
 int config_setup_connection(server *srv, connection *con) {
         specific_config *s = srv->config_storage[0];
+        int i;
+        
+        for (i = srv->config_context->used - 1; i >= 0; i --) {
+                con->cond_results_cache[i] = COND_RESULT_UNSET;
+        }
         
         PATCH(allow_http11);
@@ -206 +213 @@
         PATCH(log_response_header);
         PATCH(log_request_handling);
+        PATCH(log_condition_handling);
         PATCH(log_file_not_found);
         
@@ -265 +273 @@
                         } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-response-header"))) {
                                 PATCH(log_response_header);
+                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-condition-handling"))) {
+                                PATCH(log_condition_handling);
                         } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("debug.log-file-not-found"))) {
                                 PATCH(log_file_not_found);
@@ -297 +307 @@
         int in_cond;
 } tokenizer_t;
+
+static int config_skip_newline(tokenizer_t *t) {
+        int skipped = 1;
+        assert(t->input[t->offset] == '\r' || t->input[t->offset] == '\n');
+        if (t->input[t->offset] == '\r' && t->input[t->offset + 1] == '\n') {
+                skipped ++;
+                t->offset ++;
+        }
+        t->offset ++;
+        return skipped;
+}
+
+static int config_skip_comment(tokenizer_t *t) {
+        int i;
+        assert(t->input[t->offset] == '#');
+        for (i = 1; t->input[t->offset + i] && 
+             (t->input[t->offset + i] != '\n' && t->input[t->offset + i] != '\r');
+             i++);
+        t->offset += i;
+        return i;
+}
 
 static int config_tokenizer(server *srv, tokenizer_t *t, int *token_id, buffer *token) {
@@ -389 +420 @@
                         t->line_pos++;
                         break;
+                case '\n':
                 case '\r':
                         if (t->in_brace == 0) {
-                                if (t->input[t->offset + 1] == '\n') {
-                                        t->in_key = 1;
-                                        t->offset += 2;
-                                        
-                                        tid = TK_EOL;
-                                        t->line++;
-                                        t->line_pos = 1;
-                                        
-                                        buffer_copy_string(token, "(EOL)");
-                                } else {
-                                        log_error_write(srv, __FILE__, __LINE__, "sdsds", 
-                                                        "line:", t->line, "pos:", t->line_pos, 
-                                                        "CR without LF");
-                                        return 0;
+                                int done = 0;
+                                while (!done) {
+                                        switch (t->input[t->offset]) {
+                                        case '\r':
+                                        case '\n':
+                                                config_skip_newline(t);
+                                                t->line_pos = 1;
+                                                t->line++;
+                                                break;
+
+                                        case '#':
+                                                t->line_pos += config_skip_comment(t);
+                                                break;
+
+                                        case '\t':
+                                        case ' ':
+                                                t->offset++;
+                                                t->line_pos++;
+                                                break;
+
+                                        default:
+                                                done = 1;
+                                        }
                                 }
+                                t->in_key = 1;
+                                tid = TK_EOL;
+                                buffer_copy_string(token, "(EOL)");
                         } else {
-                                t->offset++;
-                                t->line_pos++;
-                        }
-                        break;
-                case '\n':
-                        if (t->in_brace == 0) {
-                                t->in_key = 1;
-                                
-                                tid = TK_EOL;
-                                
-                                buffer_copy_string(token, "(EOL)");
-                        }
-                        t->line++;
-                        t->line_pos = 1;
-                        t->offset++;
+                                config_skip_newline(t);
+                                t->line_pos = 1;
+                                t->line++;
+                        }
                         break;
                 case ',':
@@ -501 +534 @@
                         
                         break;
+                case '|':
+                        t->offset++;
+                        tid = TK_OR;
+                        buffer_copy_string(token, "|");
+                        break;
+
                 case '{':
                         t->offset++;
@@ -520 +559 @@
                         
                         break;
+
                 case '[':
                         t->offset++;
@@ -538 +578 @@
                         break;
                 case '#':
-                        for (i = 1; t->input[t->offset + i] && 
-                             (t->input[t->offset + i] != '\n' && t->input[t->offset + i] != '\r');
-                             i++);
-                        
-                        t->offset += i;
+                        t->line_pos += config_skip_comment(t);
                         
                         break;
@@ -663 +699 @@
         
         context.ok = 1;
-        context.config = srv->config_context;
+        context.all_configs = srv->config_context;
+        context.configs_stack = array_init();
         
         dc = data_config_init();
         buffer_copy_string(dc->key, "global");
-        array_insert_unique(srv->config_context, (data_unset *)dc);
-        
-        context.ctx_name = dc->key;
-        context.ctx_config = dc->value;
+
+        assert(context.all_configs->used == 0);
+        dc->context_ndx = context.all_configs->used;
+        array_insert_unique(context.all_configs, (data_unset *)dc);
+        context.current = dc;
         
         /* default context */
@@ -702 +740 @@
         }
         
+        assert(context.configs_stack->used == 0);
+        array_free(context.configs_stack);
+
         if (0 != config_insert(srv)) {
                 return -1;

trunk/src/configfile.h

@@ -7 +7 @@
 typedef struct {
         int     ok;
-        array  *config;
-        buffer *ctx_name;
-        array  *ctx_config;
+        array  *all_configs;
+        array  *configs_stack; /* to parse nested block */
+        data_config *current; /* current started with { */
 } config_t;
 

trunk/src/configparser.y

@@ -11 +11 @@
 #include "buffer.h"
 #include "array.h"
+
+static void configparser_push(config_t *ctx, data_config *dc, int isnew) {
+  if (isnew) {
+    dc->context_ndx = ctx->all_configs->used;
+    array_insert_unique(ctx->all_configs, (data_unset *)dc);
+  }
+  array_insert_unique(ctx->configs_stack, (data_unset *)ctx->current);
+  ctx->current = dc;
+}
+
+static data_config *configparser_pop(config_t *ctx) {
+  data_config *old = ctx->current;
+  ctx->current = (data_config *) array_pop(ctx->configs_stack);
+  return old;
+}
+
 }
 
@@ -21 +37 @@
 metalines ::= .
 metaline ::= varline.
-metaline ::= condline.
+metaline ::= condlines EOL.
 metaline ::= EOL.
 
@@ -28 +44 @@
 %type aelements {array *}
 %type array {array *}
+%type condline {data_config *}
+%type condlines {data_config *}
 %type cond {config_cond_t }
 %token_destructor { buffer_free($$); }
@@ -33 +51 @@
 varline ::= key(A) ASSIGN value(B). {
   buffer_copy_string_buffer(B->key, A);
-  if (NULL == array_get_element(ctx->ctx_config, B->key->ptr)) {
-    array_insert_unique(ctx->ctx_config, B);
+  if (NULL == array_get_element(ctx->current->value, B->key->ptr)) {
+    array_insert_unique(ctx->current->value, B);
   } else {
-    fprintf(stderr, "Duplicate config variable in conditional %s: %s\n", 
-            ctx->ctx_name->ptr, B->key->ptr);
+    fprintf(stderr, "Duplicate config variable in conditional 1 %s: %s\n", 
+            ctx->current->key->ptr, B->key->ptr);
     ctx->ok = 0;
     B->free(B);
@@ -104 +122 @@
   C = NULL;
 }
-condline ::= context LCURLY metalines RCURLY EOL. {
-  data_config *dc;
-  
-  dc = (data_config *)array_get_element(ctx->config, "global");
-  assert(dc);
-  ctx->ctx_name = dc->key;
-  ctx->ctx_config = dc->value;
+
+eols ::= EOL.
+eols ::= .
+
+condlines(A) ::= condlines(B) eols OR condline(C). {
+  assert(B->context_ndx < C->context_ndx);
+  C->prev = B;
+  B->next = C;
+  A = C;
+  B = NULL;
+  C = NULL;
+}
+
+condlines(A) ::= condline(B). {
+  A = B;
+  B = NULL;
+}
+
+condline(A) ::= context LCURLY metalines RCURLY. {
+  data_config *parent, *cur;
+  
+  cur = ctx->current;
+  configparser_pop(ctx);
+  parent = ctx->current;
+
+  assert(cur && parent);
+
+  if (0 != parent->context_ndx) { /* not global */
+    assert(cur->context_ndx > parent->context_ndx);
+    cur->parent = parent;
+  }
+  A = cur;
 }