Changeset 1975

Show
Ignore:
Timestamp:
09/11/08 20:00:53 (4 months ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r1970 r1975  
    112008-09-11  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/virtual_server.c, cherokee/encoder_table.c, 
     4        cherokee/encoder_table.h, cherokee/Makefile.am, 
     5        cherokee/connection-protected.h, cherokee/config_entry.c, 
     6        cherokee/config_entry.h, cherokee/thread.c, 
     7        cherokee/server-protected.h, cherokee/connection.c, 
     8        cherokee/server.c, qa/089-gzip-encoding.py, qa/run-tests.py, 
     9        qa/168-Deflate-Encoding.py: Encoders are now a configuration 
     10        entry (directories, regexs, extensions, etc) property rather than 
     11        a global server one. 
    212 
    313        * admin/ModuleDbslayer.py (ModuleDbslayer._op_apply_changes): Add 

  • cherokee/trunk/cherokee/Makefile.am

    r1969 r1975  
    10881088encoder.h \ 
    10891089encoder.c \ 
    1090 encoder_table.h \ 
    1091 encoder_table.c \ 
    10921090logger.h \ 
    10931091logger.c \ 

  • cherokee/trunk/cherokee/config_entry.c

    r1880 r1975  
    2929#include "http.h" 
    3030#include "util.h" 
     31#include "encoder.h" 
    3132 
    3233#define ENTRIES "config,rules" 
    …… 
    3738        table_validator 
    3839} prop_table_types_t; 
    39  
     40         
    4041 
    4142/* Implements _new() and _free()  
    …… 
    6667        entry->expiration_time      = 0; 
    6768 
     69        entry->encoders             = NULL; 
     70 
    6871        return ret_ok; 
    6972} 
    …… 
    102105                entry->users = NULL; 
    103106        } 
    104  
    105         return ret_ok; 
    106 } 
    107  
    108  
    109 ret_t  
    110 cherokee_config_entry_set_handler (cherokee_config_entry_t *entry, cherokee_plugin_info_handler_t *plugin_info) 
     107         
     108        if (entry->encoders) { 
     109                cherokee_avl_mrproper (entry->encoders, NULL); 
     110                entry->encoders = NULL; 
     111        } 
     112 
     113        return ret_ok; 
     114} 
     115 
     116ret_t 
     117cherokee_config_entry_add_encoder (cherokee_config_entry_t *entry,  
     118                                   cherokee_buffer_t       *name, 
     119                                   cherokee_plugin_info_t  *plugin_info) 
     120{ 
     121        if (entry->encoders == NULL) { 
     122                cherokee_avl_new (&entry->encoders); 
     123        } 
     124 
     125        cherokee_avl_add (entry->encoders, name, (void*)plugin_info->instance); 
     126        return ret_ok; 
     127} 
     128 
     129 
     130ret_t  
     131cherokee_config_entry_set_handler (cherokee_config_entry_t        *entry, 
     132                                   cherokee_plugin_info_handler_t *plugin_info) 
    111133{ 
    112134        return_if_fail (plugin_info != NULL, ret_error); 
    …… 
    169191                entry->expiration_time = source->expiration_time; 
    170192        } 
     193 
     194        if (! entry->encoders) 
     195                entry->encoders = source->encoders; 
    171196 
    172197        return ret_ok; 
    …… 
    189214        printf ("expiration type:           %d\n", entry->expiration); 
    190215        printf ("expiration_time            %lu\n", entry->expiration_time); 
    191  
    192         return ret_ok; 
    193 } 
     216        printf ("encoders_accepted          %p\n", entry->encoders); 
     217 
     218        return ret_ok; 
     219} 

  • cherokee/trunk/cherokee/config_entry.h

    r1880 r1975  
    7171        cherokee_expiration_t       expiration; 
    7272        time_t                      expiration_time; 
     73 
     74        /* Encoding 
     75         */ 
     76        cherokee_avl_t             *encoders; 
     77 
    7378} cherokee_config_entry_t;  
    7479 
    …… 
    8186ret_t cherokee_config_entry_mrproper (cherokee_config_entry_t  *entry); 
    8287 
    83 ret_t cherokee_config_entry_set_handler (cherokee_config_entry_t *entry, cherokee_plugin_info_handler_t *modinfo);  
     88ret_t cherokee_config_entry_add_encoder (cherokee_config_entry_t *entry, cherokee_buffer_t *name, cherokee_plugin_info_t *plugin_info); 
     89ret_t cherokee_config_entry_set_handler (cherokee_config_entry_t *entry, cherokee_plugin_info_handler_t *plugin_info);  
    8490ret_t cherokee_config_entry_complete    (cherokee_config_entry_t *entry, cherokee_config_entry_t *source); 
    8591 

  • cherokee/trunk/cherokee/connection-protected.h

    r1967 r1975  
    5959#include "encoder.h" 
    6060#include "iocache.h" 
    61 #include "encoder_table.h" 
    6261#include "post.h" 
    6362#include "header-protected.h" 
    …… 
    235234 */ 
    236235ret_t cherokee_connection_create_handler         (cherokee_connection_t *conn, cherokee_config_entry_t *config_entry); 
     236ret_t cherokee_connection_create_encoder         (cherokee_connection_t *conn, cherokee_avl_t *encoders, cherokee_avl_t *accept_enc); 
    237237ret_t cherokee_connection_setup_error_handler    (cherokee_connection_t *conn); 
    238238ret_t cherokee_connection_check_authentication   (cherokee_connection_t *conn, cherokee_config_entry_t *config_entry); 
    …… 
    252252ret_t cherokee_connection_build_header           (cherokee_connection_t *conn); 
    253253ret_t cherokee_connection_get_request            (cherokee_connection_t *conn); 
    254 ret_t cherokee_connection_parse_header           (cherokee_connection_t *conn, cherokee_encoder_table_t *encoders); 
     254ret_t cherokee_connection_parse_range            (cherokee_connection_t *conn); 
    255255int   cherokee_connection_is_userdir             (cherokee_connection_t *conn); 
    256256ret_t cherokee_connection_build_local_directory  (cherokee_connection_t *conn, cherokee_virtual_server_t *vsrv, cherokee_config_entry_t *entry); 

  • cherokee/trunk/cherokee/connection.c

    r1967 r1975  
    7171#include "buffer.h" 
    7272#include "config_entry.h" 
    73 #include "encoder_table.h" 
    7473#include "server-protected.h" 
    7574#include "access.h" 
    …… 
    11551154 
    11561155static ret_t 
    1157 get_encoding (cherokee_connection_t    *conn, 
    1158               char                     *ptr, 
    1159               cherokee_encoder_table_t *encoders)  
    1160 { 
     1156get_encoding (cherokee_connection_t *conn, 
     1157              char                  *ptr, 
     1158              cherokee_avl_t        *encoders, 
     1159              cherokee_avl_t        *encoders_accepted) 
     1160{ 
     1161        ret_t ret; 
    11611162        char tmp; 
    11621163        char *i1, *i2; 
    11631164        char *end; 
    1164         char *ext; 
    1165         ret_t ret; 
     1165        encoder_func_new_t new_func = NULL; 
    11661166 
    11671167        /* ptr = Header at the "Accept-Encoding" position  
    …… 
    11711171                return ret_error; 
    11721172        } 
    1173  
    1174         /* Look for the request extension 
    1175          */ 
    1176         ext = strrchr (conn->request.buf, '.'); 
    1177         if (ext == NULL) { 
    1178                 return ret_ok; 
    1179         } 
    1180  
    11811173        *end = '\0'; /* (1) */ 
    11821174 
    11831175        i1 = ptr; 
    1184  
    11851176        do { 
    1186                 while (*i1 == ' ') i1++; 
     1177                while (*i1 == ' ')  
     1178                        i1++; 
    11871179 
    11881180                i2 = strchr (i1, ','); 
    1189                 if (!i2) i2 = strchr (i1, ';'); 
    1190                 if (!i2) i2 = end; 
     1181                if (!i2)  
     1182                        i2 = strchr (i1, ';'); 
     1183                if (!i2)  
     1184                        i2 = end; 
    11911185 
    11921186                tmp = *i2;    /* (2) */ 
    11931187                *i2 = '\0'; 
    1194                 cherokee_encoder_table_new_encoder (encoders, i1, ext+1, &conn->encoder); 
    1195                 *i2 = tmp;    /* (2') */ 
    1196  
    1197                 if (conn->encoder != NULL) { 
    1198                         /* Init the encoder related objects 
    1199                          */ 
     1188                ret = cherokee_avl_get_ptr (encoders_accepted, i1, (void **)&new_func); 
     1189                *i2 = tmp;    /* (2') */                 
     1190                 
     1191                if ((ret == ret_ok) && (new_func)) { 
     1192                        ret = new_func ((void **)&conn->encoder); 
     1193                        if (unlikely (ret != ret_ok)) 
     1194                                goto error; 
     1195 
    12001196                        ret = cherokee_encoder_init (conn->encoder, conn); 
    1201                         if (ret < ret_ok) { 
     1197                        if (unlikely (ret != ret_ok)) 
    12021198                                goto error; 
    1203                         } 
     1199 
    12041200                        cherokee_buffer_clean (&conn->encoder_buffer); 
    12051201                        break; 
    …… 
    19301926 
    19311927ret_t 
    1932 cherokee_connection_parse_header (cherokee_connection_t *conn, cherokee_encoder_table_t *encoders) 
     1928cherokee_connection_parse_range (cherokee_connection_t *conn) 
    19331929{ 
    19341930        ret_t    ret; 
    …… 
    19511947        } 
    19521948 
    1953         /* Look for "Accept-Encoding:" 
     1949        return ret_ok; 
     1950} 
     1951 
     1952ret_t 
     1953cherokee_connection_create_encoder (cherokee_connection_t *conn, 
     1954                                    cherokee_avl_t        *encoders, 
     1955                                    cherokee_avl_t        *encoders_accepted) 
     1956{ 
     1957        ret_t    ret; 
     1958        char    *ptr; 
     1959        cuint_t  ptr_len; 
     1960 
     1961        /* No encoders are accepted 
     1962         */ 
     1963        if ((encoders_accepted == NULL) || 
     1964            (encoders_accepted->root == NULL)) 
     1965                return ret_ok; 
     1966 
     1967        /* Process the "Accept-Encoding" header 
    19541968         */ 
    19551969        ret = cherokee_header_get_known (&conn->header, header_accept_encoding, &ptr, &ptr_len); 
    19561970        if (ret == ret_ok) { 
    1957                 ret = get_encoding (conn, ptr, encoders); 
     1971                ret = get_encoding (conn, ptr, encoders, encoders_accepted); 
    19581972                if (ret < ret_ok) { 
    19591973                        return ret; 
    19601974                } 
    19611975        } 
    1962  
     1976         
    19631977        return ret_ok; 
    19641978} 

  • cherokee/trunk/cherokee/server-protected.h

    r1949 r1975  
    4646#include "fdpoll.h" 
    4747#include "virtual_server.h" 
    48 #include "encoder_table.h" 
    4948#include "thread.h" 
    5049#include "plugin_loader.h" 
    …… 
    8382         */ 
    8483        cherokee_plugin_loader_t   loader; 
    85         cherokee_encoder_table_t   encoders; 
     84        cherokee_avl_t             encoders; 
    8685 
    8786        /* Tables: iocache, nonces, etc 

  • cherokee/trunk/cherokee/server.c

    r1949 r1975  
    202202        /* Encoders  
    203203         */ 
    204         cherokee_encoder_table_init (&n->encoders); 
     204        cherokee_avl_init (&n->encoders); 
    205205 
    206206        /* Server string 
    …… 
    327327        /* Attached objects 
    328328         */ 
    329         cherokee_encoder_table_mrproper (&srv->encoders); 
     329        cherokee_avl_mrproper (&srv->encoders, NULL); 
    330330 
    331331        cherokee_mime_free (srv->mime); 
    …… 
    12451245} 
    12461246 
    1247  
    1248 static ret_t  
    1249 add_encoder (cherokee_config_node_t *node, void *data) 
    1250 { 
    1251         ret_t                           ret; 
    1252         cherokee_encoder_table_entry_t *enc      = NULL; 
    1253         cherokee_matching_list_t       *matching = NULL; 
    1254         cherokee_plugin_info_t         *info     = NULL; 
    1255         cherokee_server_t              *srv      = SRV(data); 
    1256  
    1257         TRACE(ENTRIES, "Encoder: %s\n", node->key.buf); 
    1258  
    1259         /* Set the matching list 
    1260          */ 
    1261         ret = cherokee_matching_list_new (&matching); 
    1262         if (ret != ret_ok) goto error; 
    1263  
    1264         ret = cherokee_matching_list_configure (matching, node); 
    1265         if (ret != ret_ok) goto error;   
    1266  
    1267         /* Load the module library and set the info 
    1268          */ 
    1269         ret = cherokee_plugin_loader_get (&srv->loader, node->key.buf, &info); 
    1270         if (ret != ret_ok) goto error; 
    1271  
    1272         ret = cherokee_encoder_table_entry_new (&enc); 
    1273         if (ret != ret_ok) goto error; 
    1274  
    1275         ret = cherokee_encoder_table_entry_get_info (enc, info); 
    1276         if (ret != ret_ok) goto error; 
    1277  
    1278         cherokee_encoder_entry_set_matching_list (enc, matching); 
    1279   
    1280         /* Set in the encoders table 
    1281          */ 
    1282         ret = cherokee_encoder_table_set (&srv->encoders, &node->key, enc); 
    1283         if (ret != ret_ok) goto error; 
    1284  
    1285         return ret_ok; 
    1286  
    1287 error: 
    1288         TRACE(ENTRIES, "Could not add '%s' encoder\n", node->key.buf); 
    1289         return ret; 
    1290 } 
    12911247 
    12921248static ret_t  
    …… 
    15511507                srv->group = grp->gr_gid; 
    15521508 
    1553         } else if (equal_buf_str (&conf->key, "encoder")) { 
    1554                 ret = cherokee_config_node_while (conf, add_encoder, srv); 
    1555                 if (ret != ret_ok) return ret; 
    1556  
    15571509        } else if (equal_buf_str (&conf->key, "module_dir") || 
    15581510                   equal_buf_str (&conf->key, "module_deps")) { 

  • cherokee/trunk/cherokee/thread.c

    r1959 r1975  
    957957                                continue; 
    958958                        } 
     959                         
     960                        /* Instance a encoded if needed 
     961                         */ 
     962                        ret = cherokee_connection_create_encoder (conn, &srv->encoders, entry.encoders); 
     963                        if (unlikely (ret != ret_ok)) { 
     964                                cherokee_connection_setup_error_handler (conn); 
     965                                conn->phase = phase_init; 
     966                                continue; 
     967                        } 
    959968 
    960969                        /* Parse the rest of headers 
    961970                         */ 
    962                         ret = cherokee_connection_parse_header (conn, &srv->encoders); 
     971                        ret = cherokee_connection_parse_range (conn); 
    963972                        if (unlikely (ret != ret_ok)) { 
    964973                                cherokee_connection_setup_error_handler (conn); 

  • cherokee/trunk/cherokee/virtual_server.c

    r1930 r1975  
    585585        ret_t                      ret; 
    586586        cherokee_buffer_t         *tmp; 
     587        cherokee_list_t           *i; 
    587588        cherokee_plugin_info_t    *info    = NULL; 
    588589        cherokee_virtual_server_t *vserver = ((void **)data)[0]; 
    589590        cherokee_config_entry_t   *entry   = ((void **)data)[1]; 
     591        cherokee_server_t         *srv     = VSERVER_SRV(vserver); 
    590592 
    591593        if (equal_buf_str (&conf->key, "allow_from")) { 
    …… 
    610612                tmp = &conf->val; 
    611613 
    612                 ret = cherokee_plugin_loader_get (&SRV(vserver->server_ref)->loader, tmp->buf, &info); 
     614                ret = cherokee_plugin_loader_get (&srv->loader, tmp->buf, &info); 
    613615                if (ret != ret_ok) 
    614616                        return ret; 
    …… 
    617619                        handler_func_configure_t configure = info->configure; 
    618620 
    619                         ret = configure (conf, vserver->server_ref, &entry->handler_properties); 
     621                        ret = configure (conf, srv, &entry->handler_properties); 
    620622                        if (ret != ret_ok) 
    621623                                return ret; 
    …… 
    625627                cherokee_config_entry_set_handler (entry, PLUGIN_INFO_HANDLER(info)); 
    626628 
     629        } else if (equal_buf_str (&conf->key, "encoder")) { 
     630                cherokee_config_node_foreach (i, conf) { 
     631                        tmp = &CONFIG_NODE(i)->val; 
     632 
     633                        ret = cherokee_plugin_loader_get (&srv->loader, tmp->buf, &info); 
     634                        if (ret != ret_ok) return ret; 
     635 
     636                        ret = cherokee_avl_get (&srv->encoders, tmp, NULL); 
     637                        if (ret != ret_ok) { 
     638                                cherokee_avl_add (&srv->encoders, tmp, info); 
     639                        } 
     640 
     641                        cherokee_config_entry_add_encoder (entry, tmp, info); 
     642                        TRACE(ENTRIES, "Encoder: %s\n", tmp->buf); 
     643                } 
     644 
    627645        } else if (equal_buf_str (&conf->key, "auth")) { 
    628646                cherokee_plugin_info_validator_t *vinfo; 
    …… 
    632650                tmp = &conf->val; 
    633651 
    634                 ret = cherokee_plugin_loader_get (&SRV(vserver->server_ref)->loader, tmp->buf, &info); 
     652                ret = cherokee_plugin_loader_get (&srv->loader, tmp->buf, &info); 
    635653                if (ret != ret_ok) 
    636654                        return ret; 
    …… 
    641659                        validator_func_configure_t configure = info->configure; 
    642660 
    643                         ret = configure (conf, vserver->server_ref, &entry->validator_properties); 
     661                        ret = configure (conf, srv, &entry->validator_properties); 
    644662                        if (ret != ret_ok) return ret; 
    645663                } 

  • cherokee/trunk/qa/089-gzip-encoding.py

    r1738 r1975  
    1212vserver!1!rule!890!match!directory = /gzip1 
    1313vserver!1!rule!890!handler = file 
     14vserver!1!rule!890!encoder!1 = gzip 
    1415""" 
    1516 

  • cherokee/trunk/qa/168-Deflate-Encoding.py

    r1738 r1975  
    1212vserver!1!rule!1680!match!directory = /deflate1 
    1313vserver!1!rule!1680!handler = file 
     14vserver!1!rule!1680!encoder!1 = deflate 
    1415""" 
    1516 

  • cherokee/trunk/qa/run-tests.py

    r1949 r1975  
    141141server!listen = 127.0.0.1 
    142142server!panic_action = %(panic)s 
    143 server!encoder!gzip!allow = txt 
    144 server!encoder!deflate!allow = txt 
    145143server!pid_file = %(pid)s 
    146144server!module_dir = %(CHEROKEE_MODS)s