Changeset 510

Timestamp:

08/08/2005 10:26:13 AM (3 years ago)

Author:

moo

Message:

mod_redirect/mod_rewrite substitute %n with condition substring

Location:

trunk

Files:

• src/array.h (modified) (1 diff)
• src/base.h (modified) (2 diffs)
• src/configfile-glue.c (modified) (6 diffs)
• src/configfile.c (modified) (1 diff)
• src/connections.c (modified) (3 diffs)
• src/mod_redirect.c (modified) (6 diffs)
• src/mod_rewrite.c (modified) (3 diffs)
• src/response.c (modified) (2 diffs)
• tests/lighttpd.conf (modified) (3 diffs)
• tests/mod-redirect.t (modified) (3 diffs)

trunk/src/array.h

@@ -65 +65 @@
 
 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;
 
 #define PATCHES NULL, "SERVERsocket", "HTTPurl", "HTTPhost", "HTTPreferer", "HTTPuseragent", "HTTPcookie", "HTTPremoteip"

trunk/src/base.h

@@ -280 +280 @@
 } server_socket_array;
 
+typedef enum { COND_RESULT_UNSET, COND_RESULT_FALSE, COND_RESULT_TRUE } cond_result_t;
+typedef struct {
+        cond_result_t result;
+        int patterncount;
+        int matches[3 * 10];
+        buffer *comp_value; /* just a pointer */
+} cond_cache_t;
+
 typedef struct {
         connection_state_t state;
@@ -346 +354 @@
         
         specific_config conf;        /* global connection specific config */
-        cond_result_t *cond_results_cache;
+        cond_cache_t *cond_cache;
         
         buffer *server_name;

trunk/src/configfile-glue.c

@@ -157 +157 @@
 }
 
-static int config_check_cond_cached(server *srv, connection *con, data_config *dc);
+static cond_result_t 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) {
@@ -166 +166 @@
         if (dc->parent && dc->parent->context_ndx) {
                 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)) {
+                        log_error_write(srv, __FILE__, __LINE__,  "sb", "go parent", dc->parent->key);
+                }
+                if (config_check_cond_cached(srv, con, dc->parent) == COND_RESULT_FALSE) {
                         return COND_RESULT_FALSE;
                 }
@@ -175 +175 @@
         if (dc->prev) {
                 if (con->conf.log_condition_handling) {
-                        log_error_write(srv, __FILE__, __LINE__,  "sb", "go prev", dc->prev->string);
+                        log_error_write(srv, __FILE__, __LINE__,  "sb", "go prev", dc->prev->key);
                 }
                 /* 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) {
+                if (COND_RESULT_FALSE == con->cond_cache[dc->context_ndx].result) {
                         return COND_RESULT_FALSE;
                 }
@@ -359 +359 @@
         case CONFIG_COND_MATCH: {
 #ifdef HAVE_PCRE_H
-#define N 10
-                int ovec[N * 3];
+                cond_cache_t *cache = &con->cond_cache[dc->context_ndx];
                 int n;
                 
-                n = pcre_exec(dc->regex, dc->regex_study, l->ptr, l->used - 1, 0, 0, ovec, N * 3);
+#ifndef elementsof
+#define elementsof(x) (sizeof(x) / sizeof(x[0]))
+#endif
+                n = pcre_exec(dc->regex, dc->regex_study, l->ptr, l->used - 1, 0, 0,
+                                cache->matches, elementsof(cache->matches));
                 
                 if (n > 0) {
+                        cache->patterncount = n;
+                        cache->comp_value = l;
                         return (dc->cond == CONFIG_COND_MATCH) ? COND_RESULT_TRUE : COND_RESULT_FALSE;
                 } else {
+                        /* cache is already cleared */
                         return (dc->cond == CONFIG_COND_MATCH) ? COND_RESULT_FALSE : COND_RESULT_TRUE;
                 }
@@ -382 +388 @@
 }
 
-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))) {
+static cond_result_t config_check_cond_cached(server *srv, connection *con, data_config *dc) {
+        cond_cache_t *caches = con->cond_cache;
+
+        if (COND_RESULT_UNSET == caches[dc->context_ndx].result) {
+                if (COND_RESULT_TRUE == (caches[dc->context_ndx].result = 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");
+                                        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;
+                                        caches[c->context_ndx].result = 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]);
+                        log_error_write(srv, __FILE__, __LINE__, "dss", dc->context_ndx,
+                                        "(uncached) result:",
+                                        caches[dc->context_ndx].result == COND_RESULT_TRUE ? "true" : "false");
                 }
         } 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];
+                        log_error_write(srv, __FILE__, __LINE__, "dss", dc->context_ndx,
+                                        "(cached) result:",
+                                        caches[dc->context_ndx].result == COND_RESULT_TRUE ? "true" : "false");
+                }
+        }
+        return caches[dc->context_ndx].result;
 }
 
@@ -412 +423 @@
                 log_error_write(srv, __FILE__, __LINE__,  "s",  "=== start of condition block ===");
         }
-        return config_check_cond_cached(srv, con, dc);
-}
+        return (config_check_cond_cached(srv, con, dc) == COND_RESULT_TRUE);
+}
+
+int config_append_cond_match_buffer(connection *con, data_config *dc, buffer *buf, int n)
+{
+        cond_cache_t *cache = &con->cond_cache[dc->context_ndx];
+        if (n > cache->patterncount) {
+                return 0;
+        }
+
+        n <<= 1; /* n *= 2 */
+        buffer_append_string_len(buf,
+                        cache->comp_value->ptr + cache->matches[n],
+                        cache->matches[n + 1] - cache->matches[n]);
+        return 1;
+}
+

trunk/src/configfile.c

@@ -188 +188 @@
 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);

trunk/src/connections.c

@@ -468 +468 @@
         con->plugin_ctx = calloc(srv->plugins.used + 1, sizeof(void *));
         
-        con->cond_results_cache = calloc(srv->config_context->used, sizeof(cond_result_t));
+        con->cond_cache = calloc(srv->config_context->used, sizeof(cond_cache_t));
         con->dst_addr_buf = buffer_init();
         config_setup_connection(srv, con);
@@ -520 +520 @@
 #undef CLEAN
                 free(con->plugin_ctx);
-                free(con->cond_results_cache);
+                free(con->cond_cache);
 
                 file_descr_free(con->fd);
@@ -618 +618 @@
                 con->plugin_ctx[0] = NULL;
         }
+        
+#if COND_RESULT_UNSET
+        for (i = srv->config_context->used - 1; i >= 0; i --) {
+                con->cond_cache[i].result = COND_RESULT_UNSET;
+                con->cond_cache[i].patterncount = 0;
+        }
+#else
+        memset(con->cond_cache, 0, sizeof(cond_cache_t) * srv->config_context->used);
+#endif
         
         con->header_len = 0;

trunk/src/mod_redirect.c

@@ -14 +14 @@
 typedef struct {
         pcre_keyvalue_buffer *redirect;
+        data_config *context; /* to which apply me */
 } plugin_config;
 
@@ -153 +154 @@
                         if (0 == strcmp(du->key->ptr, "url.redirect")) {
                                 p->conf.redirect = s->redirect;
+                                p->conf.context = dc;
                         }
                 }
@@ -193 +195 @@
                 if ((n = pcre_exec(match, extra, p->match_buf->ptr, p->match_buf->used - 1, 0, 0, ovec, 3 * N)) < 0) {
                         if (n != PCRE_ERROR_NOMATCH) {
-                                log_error_write(srv, __FILE__, __LINE__, "sd"
+                                log_error_write(srv, __FILE__, __LINE__, "sd",
                                                 "execution error while matching: ", n);
                                 return HANDLER_ERROR;
@@ -201 +203 @@
                         size_t start, end;
                         size_t k;
+                        
                         /* it matched */
                         pcre_get_substring_list(p->match_buf->ptr, ovec, n, &list);
@@ -210 +213 @@
                         start = 0; end = pattern_len;
                         for (k = 0; k < pattern_len; k++) {
-                                if (pattern[k] == '$' &&
+                                if ((pattern[k] == '$' || pattern[k] == '%') &&
                                     isdigit((unsigned char)pattern[k + 1])) {
                                         /* got one */
@@ -220 +223 @@
                                         buffer_append_string_len(p->location, pattern + start, end - start);
                                         
-                                        /* n is always > 0 */
-                                        if (num < (size_t)n) {
-                                                buffer_append_string(p->location, list[num]);
+                                        if (pattern[k] == '$') {
+                                                /* n is always > 0 */
+                                                if (num < (size_t)n) {
+                                                        buffer_append_string(p->location, list[num]);
+                                                }
+                                        } else {
+                                                config_append_cond_match_buffer(con, p->conf.context, p->location, num);
                                         }
                                         

trunk/src/mod_rewrite.c

@@ -16 +16 @@
         pcre_keyvalue_buffer *rewrite;
         buffer *final;
+        data_config *context; /* to which apply me */
 } plugin_config;
 
@@ -298 +299 @@
                         start = 0; end = pattern_len;
                         for (k = 0; k < pattern_len; k++) {
-                                if (pattern[k] == '$' &&
+                                if ((pattern[k] == '$' || pattern[k] == '%') &&
                                     isdigit((unsigned char)pattern[k + 1])) {
                                         /* got one */
@@ -308 +309 @@
                                         buffer_append_string_len(con->request.uri, pattern + start, end - start);
                                         
-                                        /* n is always larger than 0 */
-                                        if (num < (size_t)n) {
-                                                buffer_append_string(con->request.uri, list[num]);
+                                        if (pattern[k] == '$') {
+                                                /* n is always > 0 */
+                                                if (num < (size_t)n) {
+                                                        buffer_append_string(con->request.uri, list[num]);
+                                                }
+                                        } else {
+                                                config_append_cond_match_buffer(con, p->conf.context, con->request.uri, num);
                                         }
                                         

trunk/src/response.c

@@ -126 +126 @@
                 char *qstr;
                 
+                if (con->conf.log_condition_handling) {
+                        log_error_write(srv, __FILE__, __LINE__,  "s",  "run condition");
+                }
                 config_patch_connection(srv, con, COMP_SERVER_SOCKET); /* SERVERsocket */
-                config_patch_connection(srv, con, COMP_HTTP_REMOTEIP); /* Client-IP */
                 
                 /**
@@ -156 +158 @@
                 
                 config_patch_connection(srv, con, COMP_HTTP_HOST);      /* Host:        */
+                config_patch_connection(srv, con, COMP_HTTP_REMOTEIP);  /* Client-IP */
                 config_patch_connection(srv, con, COMP_HTTP_REFERER);   /* Referer:     */
                 config_patch_connection(srv, con, COMP_HTTP_USERAGENT); /* User-Agent:  */

trunk/tests/lighttpd.conf

@@ -1 +1 @@
 
 debug.log-request-handling = "enable"
+debug.log-condition-handling = "enable"
 
 server.document-root         = "/tmp/lighttpd/servers/www.example.org/pages/"
@@ -129 +130 @@
 url.access-deny             = ( "~", ".inc")
 
-url.redirect                = ( "^/redirect/$" => "http://localhost:2048/" )
-
 url.rewrite                 = ( "^/rewrite/foo($|\?.+)" => "/indexfile/rewrite.php$1",
                                 "^/rewrite/bar(?:$|\?(.+))" => "/indexfile/rewrite.php?bar&$1" )
@@ -163 +162 @@
 }
 
+$HTTP["host"] =~ "(vvv).example.org" {
+  url.redirect = ( "^/redirect/$" => "http://localhost:2048/" )
+}
+
+$HTTP["host"] =~ "(zzz).example.org" {
+  url.redirect = ( "^/redirect/$" => "http://localhost:2048/%1" )
+}
+
+$HTTP["host"] =~ "(remoteip).example.org" {
+  $HTTP["remoteip"] =~ "(127.0.0.1)" {
+    url.redirect = ( "^/redirect/$" => "http://localhost:2048/%1" )
+  }
+}
+
+$HTTP["remoteip"] =~ "(127.0.0.1)" {
+  $HTTP["host"] =~ "(remoteip2).example.org" {
+    url.redirect = ( "^/redirect/$" => "http://localhost:2048/%1" )
+  }
+}

trunk/tests/mod-redirect.t

@@ -3 +3 @@
 use strict;
 use IO::Socket;
-use Test::More tests => 3;
+use Test::More tests => 6;
 
 my $basedir = (defined $ENV{'top_builddir'} ? $ENV{'top_builddir'} : '..');
@@ -191 +191 @@
 @request  = ( <<EOF
 GET /redirect/ HTTP/1.0
+Host: vvv.example.org
 EOF
  );
@@ -196 +197 @@
 ok(handle_http == 0, 'external redirect');
 
+@request  = ( <<EOF
+GET /redirect/ HTTP/1.0
+Host: zzz.example.org
+EOF
+ );
+@response = ( { 'HTTP-Protocol' => 'HTTP/1.0', 'HTTP-Status' => 301, 'Location' => 'http://localhost:2048/zzz' } );
+ok(handle_http == 0, 'external redirect with cond regsub');
+
+@request  = ( <<EOF
+GET /redirect/ HTTP/1.0
+Host: remoteip.example.org
+EOF
+ );
+@response = ( { 'HTTP-Protocol' => 'HTTP/1.0', 'HTTP-Status' => 301, 'Location' => 'http://localhost:2048/127.0.0.1' } );
+ok(handle_http == 0, 'external redirect with cond regsub on remoteip');
+
+@request  = ( <<EOF
+GET /redirect/ HTTP/1.0
+Host: remoteip2.example.org
+EOF
+ );
+@response = ( { 'HTTP-Protocol' => 'HTTP/1.0', 'HTTP-Status' => 301, 'Location' => 'http://localhost:2048/remoteip2' } );
+ok(handle_http == 0, 'external redirect with cond regsub on remoteip2');
 
 ok(stop_proc == 0, "Stopping lighttpd");