Changeset 282

Show
Ignore:
Timestamp:
05/09/06 13:22:53 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r277 r282  
    33        * themes/Makefile.am, themes/default_theme.css, 
    44        themes/default_header.html, themes/default_footer.html, 
    5         themes/default_entry.html: Added default theme for dirlist. 
     5        themes/default_entry.html, configure.in: Added default theme for 
     6        dirlist. 
    67         
    78        * cherokee/handler_dirlist.c, cherokee/handler_dirlist.c: Almost 

  • cherokee/trunk/Makefile.am

    r277 r282  
    11## Cherokee: Makefile.am  -*- makefile -*- 
    22 
    3 SUBDIRS = m4 contrib www doc icons themes qa cherokee cget windows 
     3SUBDIRS = m4 contrib www doc icons themes qa cherokee admin cget windows 
    44bin_SCRIPTS = cherokee-config 
    55SUFFIXES = .sample.pre .sample 

  • cherokee/trunk/cherokee/connection.c

    r269 r282  
     1 
    12/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ 
    23 
    …… 
    13651366        } 
    13661367         
    1367         /* Copy the request 
     1368        /* Copy the request and query string 
    13681369         */ 
    13691370        ret = cherokee_header_copy_request (&cnt->header, &cnt->request); 
    1370         if (ret < ret_ok) goto error; 
     1371        if (unlikely (ret < ret_ok)) goto error; 
     1372 
     1373        ret = cherokee_header_copy_query_string (&cnt->header, &cnt->query_string); 
     1374        if (unlikely (ret < ret_ok)) goto error;         
    13711375 
    13721376        /* Look for starting '/' in the request 
    …… 
    15661570#ifndef CHEROKEE_EMBEDDED 
    15671571        ret = cherokee_reqs_list_get (reqs, &cnt->request, config_entry, cnt); 
    1568 #else 
    1569         return ret_ok; 
    1570 #endif 
    15711572        switch (ret) { 
    15721573        case ret_not_found: 
    …… 
    15881589 
    15891590        return ret; 
     1591#else 
     1592        return ret_ok; 
     1593#endif 
    15901594} 
    15911595 
    …… 
    18081812        /* Parse the header 
    18091813         */ 
    1810         ret = cherokee_header_get_arguments (&cnt->header, &cnt->query_string, cnt->arguments); 
     1814        ret = cherokee_parse_query_string (&cnt->query_string, cnt->arguments); 
    18111815        if (unlikely(ret < ret_ok)) return ret; 
    18121816 

  • cherokee/trunk/cherokee/connection_info.c

    r219 r282  
    175175                char                    *point; 
    176176                double                   percent; 
    177                 cherokee_handler_file_t *file = FHANDLER(conn->handler);               
     177                cherokee_handler_file_t *file = HDL_FILE(conn->handler);               
    178178 
    179179                /* File size 

  • cherokee/trunk/cherokee/ext_source.c

    r269 r282  
    354354 
    355355ret_t  
    356 cherokee_ext_source_configure (cherokee_config_node_t *conf, cherokee_table_t *props) 
     356cherokee_ext_source_configure (cherokee_config_node_t *conf, list_t *ext_list) 
    357357{ 
    358358        ret_t                       ret; 
    359         cherokee_config_node_t     *subconf; 
    360359        cherokee_config_node_t     *child; 
    361360        cherokee_config_node_t     *child2; 
    362         list_t                     *i, *j; 
     361        cherokee_config_node_t     *child3; 
     362        list_t                     *i, *j, *k; 
    363363        list_t                      nlist        = LIST_HEAD_INIT(nlist); 
    364         cherokee_boolean_t          first        = true; 
    365364        cherokee_ext_source_t      *server_entry = NULL; 
    366365        cherokee_ext_source_head_t *head         = NULL; 
    …… 
    371370                child = CONFIG_NODE(i); 
    372371 
    373                 /* Create the external source object 
     372                /* Instance a new entry 
    374373                 */ 
    375                 if (first) { 
     374                if (list_empty (ext_list)) { 
    376375                        ret = cherokee_ext_source_head_new (&head); 
    377376                        if (ret != ret_ok) return ret; 
    378                          
    379                         list_add ((list_t *)head, &nlist); 
    380                         cherokee_typed_table_add_list (props, "servers", &nlist, (cherokee_typed_free_func_t) cherokee_ext_source_free); 
    381  
    382                         first        = false; 
     377 
    383378                        server_entry = EXT_SOURCE(head); 
    384379                } else { 
    385                         cherokee_ext_source_new (&server_entry); 
    386                         list_add_tail ((list_t *)server_entry, &nlist); 
     380                        ret = cherokee_ext_source_new (&server_entry); 
     381                        if (ret != ret_ok) return ret; 
    387382                } 
    388  
    389                 /* Properties 
     383                 
     384                /* Add the entry to the list 
    390385                 */ 
    391                 ret = cherokee_config_node_get (child, "host", &subconf); 
    392                 if (ret == ret_ok) { 
    393                         split_address_or_path (subconf->val.buf, &server_entry->host, &server_entry->port, 
    394                                                &server_entry->unix_socket, &server_entry->original_server); 
    395                 } 
    396  
    397                 subconf = NULL; 
    398                 ret = cherokee_config_node_get (child, "env", &subconf); 
    399                 if (ret == ret_ok) { 
    400                         cherokee_config_node_foreach (j, subconf) { 
    401                                 child2 = CONFIG_NODE(j); 
    402  
    403                                 ret = cherokee_ext_source_add_env (server_entry, child2->key.buf, child2->val.buf); 
    404                                 if (ret != ret_ok) return ret; 
     386                list_add_tail ((list_t *)server_entry, ext_list); 
     387 
     388                /* Parse properties 
     389                 */ 
     390                cherokee_config_node_foreach (j, child) { 
     391                        child2 = CONFIG_NODE(j); 
     392 
     393                        if (equal_buf_str (&child2->key, "host")) { 
     394                                split_address_or_path (child2->val.buf, &server_entry->host, &server_entry->port, 
     395                                                       &server_entry->unix_socket, &server_entry->original_server); 
     396                                 
     397                        } else if (equal_buf_str (&child2->key, "env")) { 
     398                                cherokee_config_node_foreach (k, child2) { 
     399                                        child3 = CONFIG_NODE(k); 
     400                                         
     401                                        ret = cherokee_ext_source_add_env (server_entry, child3->key.buf, child3->val.buf); 
     402                                        if (ret != ret_ok) return ret; 
     403                                } 
     404 
     405                        } else if (equal_buf_str (&child2->key, "interpreter")) { 
     406                                // fix win32 path 
     407                                cherokee_buffer_add_buffer (&server_entry->interpreter, &child2->val); 
     408 
     409                        } else { 
     410                                PRINT_MSG ("ERROR: Handler ext_source: Unknown key: '%s'\n", child2->key.buf); 
     411                                return ret_error; 
    405412                        } 
    406413                } 
    407  
    408                 ret = cherokee_config_node_get (child, "interpreter", &subconf); 
    409                 if (ret == ret_ok) { 
    410                         // fix win32 path 
    411                         cherokee_buffer_add_buffer (&server_entry->interpreter, &subconf->val); 
    412                 } 
    413414        } 
    414415 

  • cherokee/trunk/cherokee/ext_source.h

    r269 r282  
    8484/* Configure 
    8585 */ 
    86 ret_t cherokee_ext_source_configure (cherokee_config_node_t *conf, cherokee_table_t *props); 
     86ret_t cherokee_ext_source_configure (cherokee_config_node_t *conf, list_t *ext_list); 
    8787 
    8888 

  • cherokee/trunk/cherokee/fcgi_manager.c

    r237 r282  
    115115                        continue; 
    116116                         
    117                 cgi = CGI_BASE(mgr->conn.id2conn[i].conn->handler); 
    118  
    119                 if (mgr->generation != HANDLER_FASTCGI(cgi)->generation) { 
     117                cgi = HDL_CGI_BASE(mgr->conn.id2conn[i].conn->handler); 
     118 
     119                if (mgr->generation != HDL_FASTCGI(cgi)->generation) { 
    120120                        continue; 
    121121                } 
    …… 
    269269        } 
    270270 
    271         hdl      = HANDLER_FASTCGI(conn->handler); 
    272         outbuf   = &CGI_BASE(hdl)->data; 
     271        hdl      = HDL_FASTCGI(conn->handler); 
     272        outbuf   = &HDL_CGI_BASE(hdl)->data; 
    273273        data     = inbuf->buf +  FCGI_HEADER_LEN; 
    274274 
    …… 
    300300                              (ending->appStatusB0 << 24)); 
    301301 
    302                 CGI_BASE(hdl)->got_eof    = true; 
     302                HDL_CGI_BASE(hdl)->got_eof    = true; 
    303303                mgr->conn.id2conn[id].eof = true; 
    304304 
    …… 
    392392cherokee_fcgi_manager_unregister (cherokee_fcgi_manager_t *mgr, cherokee_connection_t *conn) 
    393393{ 
    394         cherokee_handler_fastcgi_t *hdl = HANDLER_FASTCGI(conn->handler); 
     394        cherokee_handler_fastcgi_t *hdl = HDL_FASTCGI(conn->handler); 
    395395 
    396396        if (hdl->generation != mgr->generation) { 

  • cherokee/trunk/cherokee/handler.c

    r132 r282  
    3333 
    3434ret_t 
    35 cherokee_handler_init_base (cherokee_handler_t *hdl, void *conn) 
     35cherokee_handler_init_base (cherokee_handler_t *hdl, void *conn, cherokee_handler_props_t *props) 
    3636{ 
    3737        /* Init the base class 
    …… 
    4747         */ 
    4848        hdl->connection = conn; 
     49        hdl->props      = props; 
     50 
    4951        return ret_ok; 
    5052} 

  • cherokee/trunk/cherokee/handler.h

    r277 r282  
    6464typedef ret_t (* handler_func_add_headers_t) (void  *handler, cherokee_buffer_t *buffer); 
    6565 
     66typedef struct { 
     67        void (*free) (void *itself); 
     68} cherokee_handler_props_t; 
    6669 
    6770typedef struct { 
    68         cherokee_module_t module; 
    69          
     71        cherokee_module_t           module; 
     72        cherokee_handler_props_t   *props; 
     73 
    7074        /* Pure virtual methods 
    7175         */ 
    …… 
    7579        /* Properties 
    7680         */ 
    77         void                      *connection; 
    78         cherokee_handler_support_t support; 
     81        void                      *connection; 
     82        cherokee_handler_support_t support; 
    7983} cherokee_handler_t; 
    80  
    81 typedef struct { 
    82         void (*free) (void *itself); 
    83 } cherokee_handler_props_t; 
    8484 
    8585 
    8686#define HANDLER(x)                         ((cherokee_handler_t *)(x)) 
     87#define HANDLER_PROPS(x)                   ((cherokee_handler_props_t *)(x)) 
     88 
    8789#define HANDLER_CONN(h)                    (CONN(HANDLER(h)->connection)) 
    8890#define HANDLER_SRV(h)                     (CONN_SRV(HANDLER_CONN(h))) 
    …… 
    9597 
    9698 
    97 ret_t cherokee_handler_init_base   (cherokee_handler_t  *hdl, void *conn); 
     99ret_t cherokee_handler_init_base   (cherokee_handler_t  *hdl, void *conn, cherokee_handler_props_t *props); 
    98100ret_t cherokee_handler_free_base   (cherokee_handler_t  *hdl); 
    99101 

  • cherokee/trunk/cherokee/handler_admin.c

    r132 r282  
    4343 
    4444ret_t  
    45 cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_table_t *properties) 
     45cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props) 
    4646{ 
    4747        CHEROKEE_NEW_STRUCT (n, handler_admin); 
    …… 
    4949        /* Init the base class object 
    5050         */ 
    51         cherokee_handler_init_base (HANDLER(n), cnt); 
     51        cherokee_handler_init_base (HANDLER(n), cnt, props); 
    5252 
    5353        MODULE(n)->init         = (handler_func_init_t) cherokee_handler_admin_init; 

  • cherokee/trunk/cherokee/handler_admin.h

    r191 r282  
    4040} cherokee_handler_admin_t; 
    4141 
    42 #define AHANDLER(x)  ((cherokee_handler_admin_t *)(x)) 
     42#define PROP_ADMIN(x)      ((cherokee_handler_admin_props_t *)(x))  
     43#define HDL_ADMIN(x)       ((cherokee_handler_admin_t *)(x)) 
     44#define HDL_ADMIN_PROPS(x) (PROP_ADMIN(HANDLER(x)->props)) 
    4345 
    4446 
    …… 
    4648 */ 
    4749void MODULE_INIT(admi) (cherokee_module_loader_t *loader); 
    48 ret_t cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_table_t *properties); 
     50ret_t cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props); 
    4951 
    5052/* virtual methods implementation 

  • cherokee/trunk/cherokee/handler_cgi.c

    r269 r282  
    7777        ret_t                   ret; 
    7878        size_t                  readed = 0; 
    79         cherokee_handler_cgi_t *cgi    = HANDLER_CGI(cgi_base); 
     79        cherokee_handler_cgi_t *cgi    = HDL_CGI(cgi_base); 
    8080 
    8181        /* Read the data from the pipe: 
    …… 
    109109 
    110110ret_t 
    111 cherokee_handler_cgi_new  (cherokee_handler_t **hdl, void *cnt, cherokee_table_t *properties) 
     111cherokee_handler_cgi_new  (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props) 
    112112{ 
    113113        int i; 
    …… 
    116116        /* Init the base class 
    117117         */ 
    118         cherokee_handler_cgi_base_init (CGI_BASE(n), cnt, properties,  
    119                                         cherokee_handler_cgi_add_env_pair, read_from_cgi); 
     118        cherokee_handler_cgi_base_init (HDL_CGI_BASE(n), cnt, props, cherokee_handler_cgi_add_env_pair, read_from_cgi); 
    120119 
    121120        /* Virtual methods 
    …… 
    192191        /* Free the rest of the handler CGI memory 
    193192         */ 
    194         cherokee_handler_cgi_base_free (CGI_BASE(cgi)); 
     193        cherokee_handler_cgi_base_free (HDL_CGI_BASE(cgi)); 
    195194 
    196195        /* Close the connection with the CGI 
    …… 
    254253 
    255254ret_t  
    256 cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_table_t **props) 
    257 { 
    258         return cherokee_handler_cgi_base_configure (conf, srv, props); 
     255cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props) 
     256{ 
     257        cherokee_handler_cgi_props_t *props; 
     258 
     259        /* Instance a new property object 
     260         */ 
     261        if (*_props == NULL) { 
     262                CHEROKEE_NEW_STRUCT (n, handler_cgi_props); 
     263                *_props = HANDLER_PROPS(n); 
     264        } 
     265 
     266        props = PROP_CGI(*_props); 
     267 
     268        /* Parse local options 
     269         */ 
     270         
     271         
     272 
     273        return cherokee_handler_cgi_base_configure (conf, srv, _props); 
    259274} 
    260275 
    …… 
    265280                                   char *content, int content_len) 
    266281{ 
    267         cherokee_handler_cgi_t *cgi = HANDLER_CGI(cgi_base); 
     282        cherokee_handler_cgi_t *cgi = HDL_CGI(cgi_base); 
    268283 
    269284#ifdef _WIN32 
    …… 
    303318        char                        *lenght; 
    304319        cuint_t                      lenght_len; 
    305         cherokee_handler_cgi_base_t *cgi_base = CGI_BASE(cgi); 
    306  
    307         ret = cherokee_handler_cgi_base_build_envp (CGI_BASE(cgi), conn); 
     320        cherokee_handler_cgi_base_t *cgi_base = HDL_CGI_BASE(cgi); 
     321 
     322        ret = cherokee_handler_cgi_base_build_envp (HDL_CGI_BASE(cgi), conn); 
    308323        if (unlikely (ret != ret_ok)) return ret; 
    309324 
    …… 
    362377{ 
    363378        ret_t                        ret; 
    364         cherokee_handler_cgi_base_t *cgi_base = CGI_BASE(cgi); 
     379        cherokee_handler_cgi_base_t *cgi_base = HDL_CGI_BASE(cgi); 
    365380        cherokee_connection_t       *conn     = HANDLER_CONN(cgi); 
    366381 
    …… 
    441456        int                          re; 
    442457        cherokee_connection_t       *conn          = HANDLER_CONN(cgi); 
    443         cherokee_handler_cgi_base_t *cgi_base      = CGI_BASE(cgi); 
     458        cherokee_handler_cgi_base_t *cgi_base      = HDL_CGI_BASE(cgi); 
    444459        char                        *absolute_path = cgi_base->executable.buf; 
    445460        char                        *argv[4]       = { NULL, NULL, NULL, NULL }; 
    …… 
    504519        /* Change the execution user? 
    505520         */ 
    506         if (cgi_base->change_user) { 
     521        if (HDL_CGI_BASE_PROPS(cgi_base)->change_user) { 
    507522                struct stat info; 
    508523                         
    …… 
    628643        /* Command line 
    629644         */ 
    630         cmd = CGI_BASE(cgi)->executable.buf; 
     645        cmd = HDL_CGI_BASE(cgi)->executable.buf; 
    631646        cherokee_buffer_add (&cmd_line, cmd, strlen(cmd)); 
    632         cherokee_buffer_add_va (&cmd_line, " \"%s\"", CGI_BASE(cgi)->param.buf); 
     647        cherokee_buffer_add_va (&cmd_line, " \"%s\"", HDL_CGI_BASE(cgi)->param.buf); 
    633648 
    634649        /* Execution directory 
    …… 
    638653        } else { 
    639654                char *file = strrchr (cmd, '/'); 
    640                 char *end  = CGI_BASE(cgi)->executable.buf + CGI_BASE(cgi)->executable.len; 
     655                char *end  = HDL_CGI_BASE(cgi)->executable.buf + HDL_CGI_BASE(cgi)->executable.len; 
    641656 
    642657                cherokee_buffer_add (&exec_dir, cmd,  
    643                                      CGI_BASE(cgi)->executable.len - (end - file)); 
     658                                     HDL_CGI_BASE(cgi)->executable.len - (end - file)); 
    644659        } 
    645660 

  • cherokee/trunk/cherokee/handler_cgi.h

    r269 r282  
    4343 
    4444 
     45typedef cherokee_handler_cgi_base_props_t cherokee_handler_cgi_props_t; 
     46 
    4547typedef struct { 
    4648        cherokee_handler_cgi_base_t base; 
    …… 
    5961        pid_t             pid;               /* CGI pid */ 
    6062#endif 
    61  
    62  
    63  
    6463} cherokee_handler_cgi_t; 
    6564 
    66 #define HANDLER_CGI(x)  ((cherokee_handler_cgi_t *)(x)) 
     65#define HDL_CGI(x)       ((cherokee_handler_cgi_t *)(x)) 
     66#define PROP_CGI(x)      ((cherokee_handler_cgi_props_t *)(x)) 
     67#define HDL_CGI_PROPS(x) (PROP_CGI(HANDLER(x)->props)) 
    6768 
    6869 
    …… 
    7374/* Methods 
    7475 */ 
    75 ret_t cherokee_handler_cgi_new         (cherokee_handler_t    **hdl, void *cnt, cherokee_table_t *properties); 
     76ret_t cherokee_handler_cgi_new         (cherokee_handler_t    **hdl, void *cnt, cherokee_handler_props_t *props); 
    7677ret_t cherokee_handler_cgi_free        (cherokee_handler_cgi_t *hdl); 
    7778 
    …… 
    8889                                           char *content, int content_len); 
    8990 
    90 ret_t cherokee_handler_cgi_configure      (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_table_t **props); 
     91ret_t cherokee_handler_cgi_configure      (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **props); 
    9192 
    9293#endif /* CHEROKEE_HANDLER_CGI_H */ 

  • cherokee/trunk/cherokee/handler_cgi_base.c

    r273 r282  
    4545cherokee_handler_cgi_base_init (cherokee_handler_cgi_base_t              *cgi,  
    4646                                cherokee_connection_t                    *conn, 
    47                                 cherokee_table_t                         *properties, 
     47                                cherokee_handler_props_t                 *props, 
    4848                                cherokee_handler_cgi_base_add_env_pair_t  add_env_pair, 
    4949                                cherokee_handler_cgi_base_read_from_cgi_t read_from_cgi) 
    …… 
    5353        /* Init the base class object 
    5454         */ 
    55         cherokee_handler_init_base (HANDLER(cgi), conn); 
     55        cherokee_handler_init_base (HANDLER(cgi), conn, props); 
    5656 
    5757        /* Supported features 
    …… 
    6868         */ 
    6969        cgi->init_phase          = hcgi_phase_build_headers; 
    70         cgi->script_alias        = NULL; 
    71         cgi->system_env          = NULL; 
    7270        cgi->content_length      = 0; 
    7371        cgi->got_eof             = false; 
    74         cgi->is_error_handler    = false; 
    75         cgi->check_file          = true; 
    76         cgi->change_user         = 0; 
    7772 
    7873        cherokee_buffer_init (&cgi->executable); 
    …… 
    9085        /* Read the properties 
    9186         */ 
    92         if (properties) { 
    93                 cherokee_typed_table_get_str  (properties, "script_alias",  &cgi->script_alias); 
    94                 cherokee_typed_table_get_list (properties, "env",           &cgi->system_env); 
    95                 cherokee_typed_table_get_int  (properties, "error_handler", &cgi->is_error_handler); 
    96                 cherokee_typed_table_get_int  (properties, "change_user",   &cgi->change_user);          
    97                 cherokee_typed_table_get_int  (properties, "check_file",    &cgi->check_file);           
    98         } 
    99  
    100         if (cgi->is_error_handler) { 
     87        if (HDL_CGI_BASE_PROPS(cgi)->is_error_handler) { 
    10188                HANDLER(cgi)->support |= hsupport_error;                 
    10289        } 
    …… 
    140127 
    141128ret_t  
    142 cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_table_t **props) 
    143 { 
    144         ret_t   ret; 
    145         list_t *i, *j; 
    146  
     129cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props) 
     130{ 
     131        ret_t                              ret; 
     132        list_t                            *i, *j; 
     133        cherokee_handler_cgi_base_props_t *props; 
     134 
     135        /* Sanity check: This class is pure virtual, it shouldn't allocate memory here.  
     136         * Check that the object space has been already instanced by it father. 
     137         */ 
     138        if (*_props == NULL) { 
     139                SHOULDNT_HAPPEN; 
     140                return ret_ok; 
     141        } 
     142         
     143        /* Init 
     144         */ 
     145        props = PROP_CGI_BASE(*_props); 
     146 
     147        INIT_LIST_HEAD (&props->system_env); 
     148        cherokee_buffer_init (&props->script_alias); 
     149 
     150        props->is_error_handler = false; 
     151        props->change_user      = false; 
     152        props->check_file       = true; 
     153 
     154        /* Parse the configuration tree 
     155         */ 
    147156        cherokee_config_node_foreach (i, conf) { 
    148157                cherokee_config_node_t *subconf = CONFIG_NODE(i); 
    149158 
    150                 ret = cherokee_typed_table_instance (props); 
    151                 if (ret != ret_ok) return ret; 
    152  
    153159                if (equal_buf_str (&subconf->key, "script_alias")) { 
    154                         ret = cherokee_typed_table_add_str (*props, "script_alias", strdup(subconf->val.buf)); 
     160                        ret = cherokee_buffer_add_buffer (&props->script_alias, &subconf->val); 
    155161                        if (ret != ret_ok) return ret; 
    156162 
    …… 
    158164                        cherokee_config_node_foreach (j, subconf) { 
    159165                                env_item_t             *env; 
    160                                 list_t                 *plist    = NULL; 
    161                                 list_t                  nlist    = LIST_HEAD_INIT(nlist); 
    162166                                cherokee_config_node_t *subconf2 = CONFIG_NODE(j); 
    163167 
    …… 
    165169                                if (env == NULL) return ret_error; 
    166170 
    167                                 cherokee_typed_table_get_list (*props, "env", &plist); 
    168  
    169                                 if (plist == NULL) { 
    170                                         list_add ((list_t *)env, &nlist); 
    171                                         cherokee_typed_table_add_list (*props, "env", &nlist, env_item_free); 
    172                                 } else { 
    173                                         list_add_tail ((list_t *)env, plist); 
    174                                 } 
     171                                list_add_tail ((list_t *)env, &props->system_env); 
    175172                        } 
    176173                } else if (equal_buf_str (&subconf->key, "error_handler")) { 
    177                         ret = cherokee_typed_table_add_int (*props, "error_handler", atoi(subconf->val.buf)); 
    178                         if (ret != ret_ok) return ret; 
     174                        props->is_error_handler = atoi(subconf->val.buf); 
    179175 
    180176                } else if (equal_buf_str (&subconf->key, "change_user")) { 
    181                         ret = cherokee_typed_table_add_int (*props, "change_user", atoi(subconf->val.buf)); 
    182                         if (ret != ret_ok) return ret; 
     177                        props->change_user = atoi(subconf->val.buf); 
    183178 
    184179                } else if (equal_buf_str (&subconf->key, "check_file")) { 
    185                         ret = cherokee_typed_table_add_int (*props, "check_file", atoi(subconf->val.buf)); 
    186                         if (ret != ret_ok) return ret; 
     180                        props->check_file = atoi(subconf->val.buf); 
    187181                } 
    188182        } 
    …… 
    419413         * these have precedence.. 
    420414         */ 
    421         if (cgi->system_env != NULL) { 
    422                 list_for_each (i, cgi->system_env) { 
    423                         env_item_t *env = (env_item_t *)i;                       
    424                         cgi->add_env_pair (cgi,  
    425                                            env->env.buf, env->env.len,  
    426                                            env->val.buf, env->val.len); 
    427                 }                
    428         } 
     415        list_for_each (i, &HDL_CGI_BASE_PROPS(cgi)->system_env) { 
     416                env_item_t *env = (env_item_t *)i;                       
     417                cgi->add_env_pair (cgi,  
     418                                   env->env.buf, env->env.len,  
     419                                   env->val.buf, env->val.len); 
     420        }                
    429421 
    430422        /* Add the basic enviroment variables 
    …… 
    436428         * It is the request without the pathinfo if it exists 
    437429         */      
    438         if (! cgi->script_alias) { 
     430        if (cherokee_buffer_is_empty (&HDL_CGI_BASE_PROPS(cgi)->script_alias)) { 
    439431                if (cgi->param.len > 0) { 
    440432                        /* phpcgi request        
    …… 
    458450        cherokee_buffer_clean (&tmp); 
    459451         
    460         if (cgi->check_file && 
     452        if (HDL_CGI_BASE_PROPS(cgi)->check_file && 
    461453            (conn->web_directory.len > 1)) 
    462454        { 
    …… 
    482474cherokee_handler_cgi_base_extract_path (cherokee_handler_cgi_base_t *cgi, cherokee_boolean_t check_filename) 
    483475{ 
    484         struct stat            st; 
    485         ret_t                  ret; 
    486         cherokee_connection_t *conn         = HANDLER_CONN(cgi); 
    487         int                    req_len; 
    488         int                    local_len; 
    489         int                    pathinfo_len = 0; 
     476        ret_t                              ret; 
     477        cint_t                             req_len; 
     478        cint_t                             local_len; 
     479        struct stat                        st; 
     480        cint_t                             pathinfo_len = 0; 
     481        cherokee_connection_t             *conn         = HANDLER_CONN(cgi); 
     482        cherokee_handler_cgi_base_props_t *props        = HDL_CGI_BASE_PROPS(cgi); 
    490483 
    491484        /* ScriptAlias: If there is a ScriptAlias directive, it 
    492485         * doesn't need to find the executable file.. 
    493486         */ 
    494         if (cgi->script_alias != NULL) { 
    495                 TRACE (ENTRIES, "Script alias '%s'\n", cgi->script_alias); 
    496  
    497                 if (stat(cgi->script_alias, &st) == -1) { 
     487        if (! cherokee_buffer_is_empty (&props->script_alias)) { 
     488                TRACE (ENTRIES, "Script alias '%s'\n", props->script_alias.buf); 
     489 
     490                if (stat (props->script_alias.buf, &st) == -1) { 
    498491                        conn->error_code = http_not_found; 
    499492                        return ret_error; 
    500493                } 
    501494 
    502                 cherokee_buffer_add (&cgi->executable, cgi->script_alias, strlen(cgi->script_alias)); 
     495                cherokee_buffer_add_buffer (&cgi->executable, &props->script_alias); 
    503496 
    504497                /* Check the path_info even if it uses a  scriptalias. The PATH_INFO     

  • cherokee/trunk/cherokee/handler_cgi_base.h

    r269 r282  
    4949} cherokee_handler_cgi_base_phase_t; 
    5050 
     51typedef struct { 
     52        list_t                             system_env; 
     53        cuint_t                            change_user; 
     54        cherokee_buffer_t                  script_alias; 
     55        cherokee_boolean_t                 check_file;   
     56        cherokee_boolean_t                 is_error_handler; 
     57} cherokee_handler_cgi_base_props_t; 
    5158 
    5259struct cherokee_handler_cgi_base { 
    53         cherokee_handler_t                handler; 
    54         cherokee_handler_cgi_base_phase_t init_phase; 
     60        cherokee_handler_t                handler; 
     61        cherokee_handler_cgi_base_phase_t init_phase; 
    5562         
    56         char               *script_alias; 
    57         char               *extra_param; 
    58         list_t             *system_env; 
    59         size_t              content_length; 
    60         cherokee_boolean_t  is_error_handler; 
    61         cherokee_boolean_t  check_file; 
     63        cuint_t                            got_eof; 
     64        char                              *extra_param; 
     65        size_t                             content_length; 
    6266 
    63         cuint_t             change_user; 
    64         cuint_t             got_eof; 
    65  
    66         cherokee_buffer_t   executable; 
    67         cherokee_buffer_t   param;  
    68         cherokee_buffer_t   param_extra; 
    69  
    70         cherokee_buffer_t   data;  
     67        cherokee_buffer_t                  param;  
     68        cherokee_buffer_t                  param_extra; 
     69        cherokee_buffer_t                  executable; 
     70        cherokee_buffer_t                  data;  
    7171 
    7272        /* Virtual methods 
    …… 
    7676} ; 
    7777