Changeset 471

Show
Ignore:
Timestamp:
07/23/2005 08:58:46 PM (3 years ago)
Author:
jan
Message:

added url.rewrite-once and url.rewrite-repeat and mapped the old options both to url.rewrite-once
if the user really wants url.rewrite-repeat he has to use it expecitly.
Added detection for endless loops

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • branches/lighttpd-1.3.x/src/mod_rewrite.c

    r1 r471  
    2020        buffer *value; 
    2121         
    22         int final; 
     22        int once; 
    2323} rewrite_rule; 
    2424 
    … …  
    3636typedef struct { 
    3737        enum { REWRITE_STATE_UNSET, REWRITE_STATE_FINISHED} state; 
     38        int loops; 
    3839} handler_ctx; 
    3940 
    … …  
    5354         
    5455        hctx->state = REWRITE_STATE_UNSET; 
     56        hctx->loops = 0; 
    5557         
    5658        return hctx; 
    … …  
    6971} 
    7072 
    71 int rewrite_rule_buffer_append(rewrite_rule_buffer *kvb, buffer *key, buffer *value, int final) { 
     73int rewrite_rule_buffer_append(rewrite_rule_buffer *kvb, buffer *key, buffer *value, int once) { 
    7274#ifdef HAVE_PCRE_H 
    7375        size_t i; 
    … …  
    104106        kvb->ptr[kvb->used]->value = buffer_init(); 
    105107        buffer_copy_string_buffer(kvb->ptr[kvb->used]->value, value); 
    106         kvb->ptr[kvb->used]->final = final; 
     108        kvb->ptr[kvb->used]->once = once; 
    107109         
    108110        kvb->used++; 
    … …  
    112114        UNUSED(kvb); 
    113115        UNUSED(value); 
    114         UNUSED(final); 
     116        UNUSED(once); 
    115117        UNUSED(key); 
    116118 
    … …  
    170172} 
    171173 
    172 SETDEFAULTS_FUNC(mod_rewrite_set_defaults) { 
    173         plugin_data *p = p_d; 
     174static int parse_config_entry(server *srv, plugin_config *s, array *ca, const char *option, int once) { 
    174175        data_unset *du; 
    175         size_t i = 0; 
    176          
    177         config_values_t cv[] = {  
    178                 { "url.rewrite",                NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 0 */ 
    179                 { "url.rewrite-final",          NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 1 */ 
    180                 { NULL,                         NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET } 
    181         }; 
    182          
    183         if (!p) return HANDLER_ERROR; 
    184          
    185         /* 0 */ 
    186         p->config_storage = malloc(srv->config_context->used * sizeof(specific_config *)); 
    187          
    188         for (i = 0; i < srv->config_context->used; i++) { 
    189                 plugin_config *s; 
     176         
     177        if (NULL != (du = array_get_element(ca, option))) { 
     178                data_array *da = (data_array *)du; 
    190179                size_t j; 
    191                 array *ca; 
    192                 data_array *da = (data_array *)du; 
    193                  
    194                 s = malloc(sizeof(plugin_config)); 
    195                 s->rewrite   = rewrite_rule_buffer_init(); 
    196                  
    197                 cv[0].destination = s->rewrite; 
    198                 cv[1].destination = s->rewrite; 
    199                  
    200                 p->config_storage[i] = s; 
    201                 ca = ((data_config *)srv->config_context->data[i])->value; 
    202          
    203                 if (0 != config_insert_values_global(srv, ca, cv)) { 
     180                 
     181                if (du->type != TYPE_ARRAY) { 
     182                        log_error_write(srv, __FILE__, __LINE__, "sss",  
     183                                        "unexpected type for key: ", option, "array of strings"); 
     184                         
    204185                        return HANDLER_ERROR; 
    205186                } 
    206187                 
    207                 if (NULL != (du = array_get_element(ca, "url.rewrite"))) { 
    208                         if (du->type != TYPE_ARRAY) { 
    209                                 log_error_write(srv, __FILE__, __LINE__, "sss",  
    210                                                 "unexpected type for key: ", "url.rewrite", "array of strings"); 
     188                da = (data_array *)du; 
     189                 
     190                for (j = 0; j < da->value->used; j++) { 
     191                        if (da->value->data[j]->type != TYPE_STRING) { 
     192                                log_error_write(srv, __FILE__, __LINE__, "sssbs",  
     193                                                "unexpected type for key: ",  
     194                                                option,  
     195                                                "[", da->value->data[j]->key, "](string)"); 
    211196                                 
    212197                                return HANDLER_ERROR; 
    213198                        } 
    214                  
    215                         da = (data_array *)du; 
    216                                  
    217                         for (j = 0; j < da->value->used; j++) { 
    218                                 if (da->value->data[j]->type != TYPE_STRING) { 
    219                                         log_error_write(srv, __FILE__, __LINE__, "sssbs",  
    220                                                         "unexpected type for key: ",  
    221                                                         "url.rewrite",  
    222                                                         "[", da->value->data[j]->key, "](string)"); 
    223                                          
    224                                         return HANDLER_ERROR; 
    225                                 } 
    226                                  
    227                                 if (0 != rewrite_rule_buffer_append(s->rewrite,  
    228                                                                     ((data_string *)(da->value->data[j]))->key, 
    229                                                                     ((data_string *)(da->value->data[j]))->value, 
    230                                                                     0)) { 
    231 #ifdef HAVE_PCRE_H 
    232                                         log_error_write(srv, __FILE__, __LINE__, "sb",  
    233                                                         "pcre-compile failed for", da->value->data[j]->key); 
     199                         
     200                        if (0 != rewrite_rule_buffer_append(s->rewrite,  
     201                                                            ((data_string *)(da->value->data[j]))->key, 
     202                                                            ((data_string *)(da->value->data[j]))->value, 
     203                                                            once)) { 
     204#ifdef HAVE_PCRE_H 
     205                                log_error_write(srv, __FILE__, __LINE__, "sb",  
     206                                                "pcre-compile failed for", da->value->data[j]->key); 
    234207#else 
    235                                         log_error_write(srv, __FILE__, __LINE__, "s",  
    236                                                         "pcre support is missing, please install libpcre and the headers"); 
    237 #endif 
    238                                 } 
     208                                log_error_write(srv, __FILE__, __LINE__, "s",  
     209                                                "pcre support is missing, please install libpcre and the headers"); 
     210#endif 
    239211                        } 
    240212                } 
    241                  
    242                 if (NULL != (du = array_get_element(ca, "url.rewrite-final"))) { 
    243                         if (du->type != TYPE_ARRAY) { 
    244                                 log_error_write(srv, __FILE__, __LINE__, "sss",  
    245                                                 "unexpected type for key: ", "url.rewrite", "array of strings"); 
    246                                  
    247                                 return HANDLER_ERROR; 
    248                         } 
    249                  
    250                         da = (data_array *)du; 
    251                                  
    252                         for (j = 0; j < da->value->used; j++) { 
    253                                 if (da->value->data[j]->type != TYPE_STRING) { 
    254                                         log_error_write(srv, __FILE__, __LINE__, "sssbs",  
    255                                                         "unexpected type for key: ",  
    256                                                         "url.rewrite",  
    257                                                         "[", da->value->data[j]->key, "](string)"); 
    258                                          
    259                                         return HANDLER_ERROR; 
    260                                 } 
    261                                  
    262                                 if (0 != rewrite_rule_buffer_append(s->rewrite,  
    263                                                                     ((data_string *)(da->value->data[j]))->key, 
    264                                                                     ((data_string *)(da->value->data[j]))->value,  
    265                                                                     1)) { 
    266                                          
    267 #ifdef HAVE_PCRE_H 
    268                                         log_error_write(srv, __FILE__, __LINE__, "sb",  
    269                                                         "pcre-compile failed for", da->value->data[j]->key); 
    270 #else 
    271                                         log_error_write(srv, __FILE__, __LINE__, "s",  
    272                                                         "pcre support is missing, please install libpcre and the headers"); 
    273 #endif 
    274                                 } 
    275                         } 
    276                 } 
     213        } 
     214         
     215        return 0; 
     216} 
     217 
     218SETDEFAULTS_FUNC(mod_rewrite_set_defaults) { 
     219        plugin_data *p = p_d; 
     220        size_t i = 0; 
     221         
     222        config_values_t cv[] = {  
     223                { "url.rewrite-repeat",        NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 0 */ 
     224                { "url.rewrite-once",          NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 1 */ 
     225                 
     226                /* old names, still supported  
     227                 *  
     228                 * url.rewrite remapped to url.rewrite-once 
     229                 * url.rewrite-final    is url.rewrite-once 
     230                 *  
     231                 */ 
     232                { "url.rewrite",               NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 2 */ 
     233                { "url.rewrite-final",         NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION }, /* 3 */ 
     234                { NULL,                        NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET } 
     235        }; 
     236         
     237        if (!p) return HANDLER_ERROR; 
     238         
     239        /* 0 */ 
     240        p->config_storage = malloc(srv->config_context->used * sizeof(specific_config *)); 
     241         
     242        for (i = 0; i < srv->config_context->used; i++) { 
     243                plugin_config *s; 
     244                array *ca; 
     245                 
     246                s = malloc(sizeof(plugin_config)); 
     247                s->rewrite   = rewrite_rule_buffer_init(); 
     248                 
     249                cv[0].destination = s->rewrite; 
     250                cv[1].destination = s->rewrite; 
     251                cv[2].destination = s->rewrite; 
     252                 
     253                p->config_storage[i] = s; 
     254                ca = ((data_config *)srv->config_context->data[i])->value; 
     255         
     256                if (0 != config_insert_values_global(srv, ca, cv)) { 
     257                        return HANDLER_ERROR; 
     258                } 
     259                 
     260                parse_config_entry(srv, s, ca, "url.rewrite-once",   1); 
     261                parse_config_entry(srv, s, ca, "url.rewrite-final",  1); 
     262                parse_config_entry(srv, s, ca, "url.rewrite",        1); 
     263                parse_config_entry(srv, s, ca, "url.rewrite-repeat", 0); 
    277264        } 
    278265         
    … …  
    299286                         
    300287                        if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite"))) { 
     288                                p->conf.rewrite = s->rewrite; 
     289                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-once"))) { 
     290                                p->conf.rewrite = s->rewrite; 
     291                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-repeat"))) { 
    301292                                p->conf.rewrite = s->rewrite; 
    302293                        } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("url.rewrite-final"))) { 
    … …  
    348339        if (con->plugin_ctx[p->id]) { 
    349340                hctx = con->plugin_ctx[p->id]; 
     341                 
     342                if (hctx->loops++ > 100) { 
     343                        log_error_write(srv, __FILE__, __LINE__,  "s",  "ENDLESS LOOP IN rewrite-rule DETECTED ... aborting request, perhaps you want to use url.rewrite instead of url.rewrite-repeat"); 
     344                         
     345                        return HANDLER_ERROR; 
     346                } 
    350347                 
    351348                if (hctx->state == REWRITE_STATE_FINISHED) return HANDLER_GO_ON; 
    … …  
    422419                        con->plugin_ctx[p->id] = hctx; 
    423420                         
    424                         if (rule->final) hctx->state = REWRITE_STATE_FINISHED; 
     421                        if (rule->once) hctx->state = REWRITE_STATE_FINISHED; 
    425422                         
    426423                        return HANDLER_COMEBACK;