Changeset 387

Show
Ignore:
Timestamp:
09/04/06 12:19:04 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/cherokee/Makefile.am

    r384 r387  
    750750 
    751751libcherokee_server_la_SOURCES = \ 
     752source.h \ 
     753source.c \ 
     754source_interpreter.h \ 
     755source_interpreter.c \ 
    752756$(static_handler_file_src) \ 
    753757$(static_handler_admin_src) \ 
    …… 
    825829nonce.h \ 
    826830nonce.c \ 
    827 ext_source.h \ 
    828 ext_source.c \ 
    829831config_node.h \ 
    830832config_node.c \ 
    831833balancer.h \ 
    832 balancer.c 
     834balancer.c  
    833835 
    834836libcherokee_config_la_SOURCES = \ 

  • cherokee/trunk/cherokee/balancer.c

    r381 r387  
    2525#include "common-internal.h" 
    2626#include "balancer.h" 
    27  
    28  
    29 #define DEFAULT_HOSTS_ALLOCATION 5 
     27#include "module_loader.h" 
     28#include "server-protected.h" 
     29#include "source_interpreter.h" 
     30 
     31#define DEFAULT_SOURCES_ALLOCATION 5 
    3032 
    3133 
    …… 
    3941        /* Virtual methods 
    4042         */ 
    41         balancer->dispatch   = NULL; 
    42          
    43         /* Hosts 
    44          */ 
    45         balancer->hosts_len  = 0; 
    46         balancer->hosts_size = 0; 
    47         balancer->hosts      = NULL; 
     43        balancer->dispatch     = NULL; 
     44         
     45        /* Sources 
     46         */ 
     47        balancer->sources_len  = 0; 
     48        balancer->sources_size = 0; 
     49        balancer->sources      = NULL; 
    4850 
    4951        return ret_ok; 
    …… 
    5456cherokee_balancer_mrproper (cherokee_balancer_t *balancer) 
    5557{ 
    56         if (balancer->hosts != NULL) { 
    57                 free (balancer->hosts); 
    58         } 
     58        if (balancer->sources != NULL) { 
     59                free (balancer->sources); 
     60        } 
     61 
     62        return ret_ok; 
     63} 
     64 
     65 
     66ret_t  
     67cherokee_balancer_configure (cherokee_balancer_t *balancer, cherokee_config_node_t *conf) 
     68{ 
     69        ret_t              ret; 
     70        cherokee_list_t   *i; 
     71        cherokee_buffer_t *buf; 
     72        cherokee_boolean_t interpreter = false; 
     73 
     74        /* Look for the type of the source objects 
     75         */ 
     76        ret = cherokee_config_node_read (conf, "type", &buf); 
     77        if (ret != ret_ok) { 
     78                PRINT_ERROR_S ("ERROR: Balancer: An entry 'type' is needed\n"); 
     79                return ret; 
     80        } 
     81         
     82        if (equal_buf_str (buf, "interpreter")) { 
     83                interpreter = true; 
     84        } else { 
     85                PRINT_ERROR ("ERROR: Balancer: Unknown type '%s'\n", buf->buf); 
     86                return ret_error; 
     87        } 
     88         
     89        /* Add the source objects 
     90         */ 
     91        cherokee_config_node_foreach (i, conf) { 
     92                cherokee_source_t      *src     = NULL; 
     93                cherokee_config_node_t *subconf = CONFIG_NODE(i); 
     94 
     95                if (equal_buf_str (&subconf->key, "type")) 
     96                        continue; 
     97 
     98                if (interpreter) { 
     99                        cherokee_source_interpreter_t *src2; 
     100 
     101                        ret = cherokee_source_interpreter_new (&src2); 
     102                        if (ret != ret_ok) return ret; 
     103                         
     104                        ret = cherokee_source_interpreter_configure (src2, subconf); 
     105                        if (ret != ret_ok) return ret; 
     106 
     107                        src = SOURCE(src2); 
     108                } 
     109                 
     110                cherokee_balancer_add_source (balancer, src); 
     111        }        
    59112 
    60113        return ret_ok; 
    …… 
    63116 
    64117static ret_t 
    65 alloc_more_hosts (cherokee_balancer_t *balancer) 
     118alloc_more_sources (cherokee_balancer_t *balancer) 
    66119{ 
    67120        size_t size; 
    68121 
    69         if (balancer->hosts == NULL) { 
    70                 size = DEFAULT_HOSTS_ALLOCATION * sizeof(cherokee_balancer_host_t *); 
    71                 balancer->hosts = (cherokee_balancer_host_t **) malloc (size); 
     122        if (balancer->sources == NULL) { 
     123                size = DEFAULT_SOURCES_ALLOCATION * sizeof(cherokee_source_t *); 
     124                balancer->sources = (cherokee_source_t **) malloc (size); 
    72125        } else { 
    73                 size = (balancer->hosts_size + DEFAULT_HOSTS_ALLOCATION ) * sizeof(cherokee_balancer_host_t *); 
    74                 balancer->hosts = (cherokee_balancer_host_t **) realloc (balancer->hosts, size); 
    75         } 
    76          
    77         if (balancer->hosts == NULL)  
     126                size = (balancer->sources_size + DEFAULT_SOURCES_ALLOCATION ) * sizeof(cherokee_source_t *); 
     127                balancer->sources = (cherokee_source_t **) realloc (balancer->sources, size); 
     128        } 
     129         
     130        if (balancer->sources == NULL)  
    78131                return ret_nomem; 
    79132         
    80         memset (balancer->hosts + balancer->hosts_len, 0, DEFAULT_HOSTS_ALLOCATION); 
    81  
    82         balancer->hosts_size += DEFAULT_HOSTS_ALLOCATION; 
    83         return ret_ok; 
    84 } 
    85  
    86  
    87 ret_t  
    88 cherokee_balancer_add_host (cherokee_balancer_t *balancer, cherokee_balancer_host_t *host) 
     133        memset (balancer->sources + balancer->sources_len, 0, DEFAULT_SOURCES_ALLOCATION); 
     134 
     135        balancer->sources_size += DEFAULT_SOURCES_ALLOCATION; 
     136        return ret_ok; 
     137} 
     138 
     139 
     140ret_t  
     141cherokee_balancer_add_source (cherokee_balancer_t *balancer, cherokee_source_t *source) 
    89142{ 
    90143        ret_t ret; 
    91  
    92         if (balancer->hosts_len >= balancer->hosts_size) { 
    93                 ret = alloc_more_hosts (balancer); 
     144         
     145        if (balancer->sources_len >= balancer->sources_size) { 
     146                ret = alloc_more_sources (balancer); 
    94147                if (ret != ret_ok) return ret; 
    95148        } 
    96149 
    97         balancer->hosts[balancer->hosts_len] = host; 
    98         balancer->hosts_len++; 
    99  
    100         return ret_ok; 
    101 } 
    102  
    103  
    104 ret_t  
    105 cherokee_balancer_dispatch (cherokee_balancer_t *balancer, cherokee_connection_t *conn, cherokee_balancer_host_t **host) 
     150        balancer->sources[balancer->sources_len] = source; 
     151        balancer->sources_len++; 
     152 
     153        return ret_ok; 
     154} 
     155 
     156 
     157ret_t  
     158cherokee_balancer_dispatch (cherokee_balancer_t *balancer, cherokee_connection_t *conn, cherokee_source_t **source) 
    106159{ 
    107160        if (balancer->dispatch == NULL) 
    108161                return ret_error; 
    109162 
    110         return balancer->dispatch (balancer, conn, host); 
     163        return balancer->dispatch (balancer, conn, source); 
    111164} 
    112165 
    …… 
    136189        return ret_ok; 
    137190} 
     191 
     192 
     193ret_t  
     194cherokee_balancer_instance (cherokee_buffer_t       *name,  
     195                            cherokee_config_node_t  *conf,  
     196                            cherokee_server_t       *srv,  
     197                            cherokee_balancer_t    **balancer) 
     198{ 
     199        ret_t                   ret; 
     200        balancer_new_func_t     new_func; 
     201        cherokee_module_info_t *info      = NULL; 
     202         
     203        ret = cherokee_module_loader_get (&srv->loader, name->buf, &info); 
     204        if (ret != ret_ok) return ret; 
     205         
     206        new_func = (balancer_new_func_t) info->new_func; 
     207        ret = new_func (balancer); 
     208        if (ret != ret_ok) return ret; 
     209 
     210        ret = cherokee_balancer_configure (*balancer, conf); 
     211        if (ret != ret_ok) return ret; 
     212 
     213        return ret_ok; 
     214} 

  • cherokee/trunk/cherokee/balancer.h

    r380 r387  
    3333#include <cherokee/module.h> 
    3434#include <cherokee/connection.h> 
     35#include <cherokee/source.h> 
    3536 
    3637CHEROKEE_BEGIN_DECLS 
    3738 
    38  
    39 /* Hosts 
    40  */ 
    41 typedef struct { 
    42         int foo; 
    43 } cherokee_balancer_host_t; 
    44  
    45  
    46 /* Handler properties 
    47  */ 
    48 typedef ret_t (* balancer_props_func_free_t)  (void  *balancerp); 
     39typedef ret_t (* balancer_dispatch_func_t) (void *balancer, cherokee_connection_t *conn, cherokee_source_t **src); 
    4940 
    5041typedef struct { 
    51         balancer_props_func_free_t free; 
    52 } cherokee_balancer_props_t; 
    53  
    54  
    55 /* Balancer 
    56  */ 
    57 typedef ret_t (* balancer_dispatch_func_t) (void *balancer, cherokee_connection_t *conn, cherokee_balancer_host_t **hosts); 
    58 typedef ret_t (* balancer_free_func_t)     (void *balancer); 
    59  
    60 typedef struct { 
    61         cherokee_module_t          module; 
     42        cherokee_module_t        module; 
    6243 
    6344        /* Properties */ 
    64         cherokee_balancer_host_t **hosts; 
    65         cuint_t                    hosts_len; 
    66         cuint_t                    hosts_size; 
     45        cherokee_source_t      **sources; 
     46        cuint_t                  sources_len; 
     47        cuint_t                  sources_size; 
    6748 
    6849        /* Virtual methods */ 
    69         balancer_dispatch_func_t   dispatch; 
     50        balancer_dispatch_func_t dispatch; 
     51 
    7052} cherokee_balancer_t; 
    7153 
    7254#define BAL(b)  ((cherokee_balancer_t *)(b)) 
    7355 
     56 
     57typedef ret_t (* balancer_new_func_t)      (cherokee_balancer_t **balancer); 
     58typedef ret_t (* balancer_free_func_t)     (cherokee_balancer_t  *balancer); 
     59 
     60 
    7461ret_t cherokee_balancer_init_base  (cherokee_balancer_t *balancer); 
    7562ret_t cherokee_balancer_mrproper   (cherokee_balancer_t *balancer); 
     63ret_t cherokee_balancer_configure  (cherokee_balancer_t *balancer, cherokee_config_node_t *conf); 
    7664 
    77 ret_t cherokee_balancer_add_host   (cherokee_balancer_t *balancer, cherokee_balancer_host_t *host); 
     65/* Public methods 
     66 */ 
     67ret_t cherokee_balancer_add_source (cherokee_balancer_t *balancer, cherokee_source_t *source); 
    7868 
    7969/* Virtual methods 
    8070 */ 
    81 ret_t cherokee_balancer_dispatch   (cherokee_balancer_t *balancer, cherokee_connection_t *conn, cherokee_balancer_host_t **host); 
     71ret_t cherokee_balancer_dispatch   (cherokee_balancer_t *balancer, cherokee_connection_t *conn, cherokee_source_t **source); 
    8272ret_t cherokee_balancer_free       (cherokee_balancer_t *balancer); 
     73 
     74/* Commodity  
     75 */ 
     76ret_t cherokee_balancer_instance   (cherokee_buffer_t       *name,  
     77                                    cherokee_config_node_t  *conf,  
     78                                    cherokee_server_t       *srv,  
     79                                    cherokee_balancer_t    **balancer); 
    8380 
    8481CHEROKEE_END_DECLS 

  • cherokee/trunk/cherokee/balancer_round_robin.c

    r380 r387  
    2828#include "module_loader.h" 
    2929 
     30static ret_t 
     31dispatch (cherokee_balancer_round_robin_t *balancer,  
     32          cherokee_connection_t           *conn,  
     33          cherokee_source_t              **src); 
     34 
    3035 
    3136ret_t  
    32 cherokee_balancer_round_robin_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, void **props) 
     37cherokee_balancer_round_robin_configure (cherokee_balancer_t  *balancer, cherokee_config_node_t *conf) 
    3338{ 
     39        ret_t ret; 
     40 
     41        ret = cherokee_balancer_configure (BAL(balancer), conf); 
     42        if (ret != ret_ok) return ret; 
     43 
    3444        return ret_ok; 
    3545} 
    3646 
     47 
    3748ret_t  
    38 cherokee_balancer_round_robin_new (cherokee_balancer_t **bal, cherokee_connection_t *cnt, cherokee_balancer_props_t *props) 
     49cherokee_balancer_round_robin_new (cherokee_balancer_t **bal) 
    3950{ 
    4051        CHEROKEE_NEW_STRUCT (n, balancer_round_robin); 
    …… 
    4556 
    4657        MODULE(n)->free  = (module_func_free_t) cherokee_balancer_round_robin_free; 
    47         BAL(n)->dispatch = (balancer_dispatch_func_t) cherokee_balancer_round_robin_dispatch; 
     58        BAL(n)->dispatch = (balancer_dispatch_func_t) dispatch; 
    4859 
    4960        /* Init properties 
    …… 
    6778 
    6879 
    69 ret_t 
    70 cherokee_balancer_round_robin_dispatch (cherokee_balancer_round_robin_t *balancer,  
    71                                        cherokee_connection_t           *conn,  
    72                                        cherokee_balancer_host_t       **host) 
     80static ret_t 
     81dispatch (cherokee_balancer_round_robin_t *balancer,  
     82          cherokee_connection_t           *conn,  
     83          cherokee_source_t              **src) 
    7384{ 
    7485        cherokee_balancer_t *gbal = BAL(balancer); 
    …… 
    7687        CHEROKEE_MUTEX_LOCK (&balancer->last_one_mutex); 
    7788 
    78         if (gbal->hosts_len <= 0) 
     89        if (gbal->sources_len <= 0) 
    7990                goto error; 
    8091         
    81         balancer->last_one = (balancer->last_one + 1) % gbal->hosts_len; 
    82         *host = gbal->hosts[balancer->last_one]; 
     92        balancer->last_one = (balancer->last_one + 1) % gbal->sources_len; 
     93        *src = gbal->sources[balancer->last_one]; 
    8394 
    8495        CHEROKEE_MUTEX_UNLOCK (&balancer->last_one_mutex); 
    …… 
    89100        return ret_error; 
    90101} 
     102 
    91103 
    92104 

  • cherokee/trunk/cherokee/balancer_round_robin.h

    r380 r387  
    3939} cherokee_balancer_round_robin_t; 
    4040 
    41  
    42 #define PROP_RR(x)      ((cherokee_balancer_round_robin_props_t *)(x)) 
    4341#define BAL_RR(x)       ((cherokee_balancer_round_robin_file_t *)(x)) 
    44 #define BAL_RR_PROP(x)  (PROP_RR(BAL(x)->props)) 
    4542 
    4643 
    47 ret_t cherokee_balancer_round_robin_new       (cherokee_balancer_t **hdl, cherokee_connection_t *cnt, cherokee_balancer_props_t *props); 
    48 ret_t cherokee_balancer_round_robin_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, void **props); 
    49  
     44ret_t cherokee_balancer_round_robin_new       (cherokee_balancer_t **balancer); 
     45ret_t cherokee_balancer_round_robin_configure (cherokee_balancer_t  *balancer, cherokee_config_node_t *conf); 
    5046ret_t cherokee_balancer_round_robin_free      (cherokee_balancer_round_robin_t *balancer); 
    51 ret_t cherokee_balancer_round_robin_dispatch  (cherokee_balancer_round_robin_t *balancer, cherokee_connection_t *conn, cherokee_balancer_host_t **host); 
    52  
    5347 
    5448#endif /* CHEROKEE_BALANCER_ROUND_ROBIN_H */ 

  • cherokee/trunk/cherokee/config_entry.c

    r354 r387  
    7676{ 
    7777        if (entry->handler_properties != NULL) { 
    78                 cherokee_handler_props_free (entry->handler_properties); 
     78                cherokee_module_props_free (entry->handler_properties); 
    7979                entry->handler_properties = NULL; 
    8080        } 

  • cherokee/trunk/cherokee/config_entry.h

    r384 r387  
    4040        /* Parent table_entry 
    4141         */ 
    42         void                     *parent; 
    43         cuint_t                   priority; 
     42        void                       *parent; 
     43        cuint_t                     priority; 
    4444 
    4545        /* Properties 
    4646         */ 
    47         cherokee_buffer_t        *document_root; 
    48         cherokee_boolean_t        only_secure; 
    49         void                     *access; 
     47        cherokee_buffer_t          *document_root; 
     48        cherokee_boolean_t          only_secure; 
     49        void                       *access; 
    5050 
    5151        /* Handler 
    …… 
    5353        handler_func_new_t          handler_new_func; 
    5454        cherokee_http_method_t      handler_methods; 
    55         cherokee_handler_props_t   *handler_properties;  
     55        cherokee_module_props_t    *handler_properties;  
    5656 
    5757        /* Validator 

  • cherokee/trunk/cherokee/fcgi_dispatcher.c

    r385 r387  
    3333cherokee_fcgi_dispatcher_new (cherokee_fcgi_dispatcher_t **fcgi,  
    3434                              cherokee_thread_t           *thd,  
    35                               cherokee_ext_source_t       *src,  
     35                              cherokee_source_t           *src,  
    3636                              cuint_t                      mgr_num,  
    3737                              cuint_t                      keepalive, 

  • cherokee/trunk/cherokee/fcgi_dispatcher.h

    r384 r387  
    4848 
    4949 
    50 ret_t cherokee_fcgi_dispatcher_new        (cherokee_fcgi_dispatcher_t **fcgi, cherokee_thread_t *thd, cherokee_ext_source_t *src, cuint_t mgr_num, cuint_t nkeepalive, cuint_t pipeline); 
     50ret_t cherokee_fcgi_dispatcher_new        (cherokee_fcgi_dispatcher_t **fcgi, cherokee_thread_t *thd, cherokee_source_t *src, cuint_t mgr_num, cuint_t nkeepalive, cuint_t pipeline); 
    5151ret_t cherokee_fcgi_dispatcher_free       (cherokee_fcgi_dispatcher_t  *fcgi); 
    5252 

  • cherokee/trunk/cherokee/fcgi_manager.c

    r282 r387  
    2929#include "connection-protected.h" 
    3030#include "handler_fastcgi.h" 
     31#include "source_interpreter.h" 
    3132 
    3233#include <unistd.h> 
    …… 
    4041cherokee_fcgi_manager_init (cherokee_fcgi_manager_t *mgr, 
    4142                            void                    *dispatcher, 
    42                             cherokee_ext_source_t   *src,  
     43                            cherokee_source_t       *src,  
    4344                            cherokee_boolean_t       keepalive,  
    4445                            cuint_t                  pipeline) 
    …… 
    132133reconnect (cherokee_fcgi_manager_t *mgr, cherokee_thread_t *thd, cherokee_boolean_t clean_up) 
    133134{ 
    134         ret_t                  ret; 
    135         cuint_t                next; 
    136         cuint_t                try = 0; 
    137         cherokee_ext_source_t *src = mgr->source; 
     135        ret_t              ret; 
     136        cuint_t            next; 
     137        cuint_t            try = 0; 
     138        cherokee_source_t *src = mgr->source; 
    138139 
    139140        /* Do some clean up 
    …… 
    159160        /* If it connects we're done here.. 
    160161         */ 
    161         ret = cherokee_ext_source_connect (src, &mgr->socket); 
     162        ret = cherokee_source_connect (src, &mgr->socket); 
    162163        if (ret != ret_ok) { 
     164                cherokee_source_interpreter_t *src2 = SOURCE_INT(src); 
     165 
    163166                /* It didn't sucess to connect, so lets spawn a new server 
    164167                 */ 
    165                 ret = cherokee_ext_source_spawn_srv (src); 
     168                ret = cherokee_source_interpreter_spawn (src2); 
    166169                if (ret != ret_ok) { 
    167170                        TRACE (ENTRIES, "Couldn't spawn: %s\n", src->host.buf ? src->host.buf : src->unix_socket.buf); 
    …… 
    172175                        /* Try to connect again  
    173176                         */ 
    174                         ret = cherokee_ext_source_connect (src, &mgr->socket); 
     177                        ret = cherokee_source_connect (src, &mgr->socket); 
    175178                        if (ret == ret_ok) break; 
    176179 

  • cherokee/trunk/cherokee/fcgi_manager.h

    r203 r387  
    3030#include "socket.h" 
    3131#include "thread.h" 
    32 #include "ext_source.h" 
     32#include "source.h" 
    3333 
    3434 
    …… 
    4141        cherokee_socket_t      socket; 
    4242        cherokee_buffer_t      read_buffer; 
    43         cherokee_ext_source_t *source; 
     43        cherokee_source_t    *source; 
    4444        void                  *dispatcher; 
    4545 
    …… 
    5959#define FCGI_MANAGER(f) ((cherokee_fcgi_manager_t *)(f)) 
    6060 
    61 ret_t cherokee_fcgi_manager_init        (cherokee_fcgi_manager_t *mgr, void *dispatcher, cherokee_ext_source_t *src, cherokee_boolean_t keepalive, cuint_t pipeline); 
     61ret_t cherokee_fcgi_manager_init        (cherokee_fcgi_manager_t *mgr, void *dispatcher, cherokee_source_t *src, cherokee_boolean_t keepalive, cuint_t pipeline); 
    6262ret_t cherokee_fcgi_manager_mrproper    (cherokee_fcgi_manager_t *mgr); 
    6363 

  • cherokee/trunk/cherokee/handler.c

    r370 r387  
    3333 
    3434ret_t 
    35 cherokee_handler_init_base (cherokee_handler_t *hdl, void *conn, cherokee_handler_props_t *props) 
     35cherokee_handler_init_base (cherokee_handler_t *hdl, void *conn, cherokee_module_props_t *props) 
    3636{ 
    3737        /* Init the base class 
    …… 
    130130 
    131131 
    132 /* Handler properties 
    133  */ 
    134 ret_t  
    135 cherokee_handler_props_init_base (cherokee_handler_props_t *hdlp, handler_props_func_free_t free_func) 
    136 { 
    137         hdlp->free = free_func; 
    138         return ret_ok; 
    139 } 
    140  
    141  
    142 ret_t  
    143 cherokee_handler_props_free (cherokee_handler_props_t *hdlp) 
    144 { 
    145         if (hdlp == NULL)  
    146                 return ret_error; 
    147  
    148         if (hdlp->free == NULL) { 
    149                 SHOULDNT_HAPPEN; 
    150                 return ret_error; 
    151         } 
    152  
    153         hdlp->free (hdlp); 
    154         return ret_ok; 
    155 } 
    156  
    157  
    158 ret_t  
    159 cherokee_handler_props_free_base (cherokee_handler_props_t *hdlp) 
    160 { 
    161         free (hdlp); 
    162         return ret_ok; 
    163 } 

  • cherokee/trunk/cherokee/handler.h

    r379 r387  
    5555} cherokee_handler_support_t; 
    5656 
    57 /* Handler properties 
    58  */ 
    59 typedef ret_t (* handler_props_func_free_t)  (void  *handlerp); 
    60  
    61 typedef struct { 
    62         handler_props_func_free_t free; 
    63 } cherokee_handler_props_t; 
    64  
    6557 
    6658/* Callback function definitions 
    6759 */ 
    68 typedef ret_t (* handler_func_new_t)         (void **handler, void *cnt, cherokee_handler_props_t *properties); 
     60typedef ret_t (* handler_func_new_t)         (void **handler, void *cnt, cherokee_module_props_t *properties); 
    6961typedef ret_t (* handler_func_init_t)        (void  *handler); 
    7062typedef ret_t (* handler_func_step_t)        (void  *handler, cherokee_buffer_t *buffer); 
    …… 
    7567typedef struct { 
    7668        cherokee_module_t           module; 
    77         cherokee_handler_props_t   *props; 
     69        cherokee_module_props_t    *props; 
    7870 
    7971        /* Pure virtual methods 
    …… 
    9082 
    9183#define HANDLER(x)                         ((cherokee_handler_t *)(x)) 
    92 #define HANDLER_PROPS(x)                   ((cherokee_handler_props_t *)(x)) 
    93 #define HANDLER_PROPS_FREE(f)              ((handler_props_func_free_t)(f)) 
    94  
    9584#define HANDLER_CONN(h)                    (CONN(HANDLER(h)->connection)) 
    9685#define HANDLER_SRV(h)                     (CONN_SRV(HANDLER_CONN(h))) 
    …… 
    10493/* Handler methods 
    10594 */ 
    106 ret_t cherokee_handler_init_base   (cherokee_handler_t  *hdl, void *conn, cherokee_handler_props_t *props); 
     95ret_t cherokee_handler_init_base   (cherokee_handler_t  *hdl, void *conn, cherokee_module_props_t *props); 
    10796ret_t cherokee_handler_free_base   (cherokee_handler_t  *hdl); 
    10897 
    …… 
    114103ret_t cherokee_handler_add_headers (cherokee_handler_t  *hdl, cherokee_buffer_t *buffer); 
    115104 
    116 /* Handler properties 
    117  */ 
    118 ret_t cherokee_handler_props_init_base (cherokee_handler_props_t *hdlp, handler_props_func_free_t free_func); 
    119 ret_t cherokee_handler_props_free_base (cherokee_handler_props_t *hdlp); 
    120 ret_t cherokee_handler_props_free      (cherokee_handler_props_t *hdlp); 
    121  
    122105 
    123106CHEROKEE_END_DECLS 

  • cherokee/trunk/cherokee/handler_admin.c

    r342 r387  
    4343 
    4444ret_t  
    45 cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props) 
     45cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_module_props_t *props) 
    4646{ 
    4747        CHEROKEE_NEW_STRUCT (n, handler_admin); 

  • cherokee/trunk/cherokee/handler_admin.h

    r282 r387  
    4848 */ 
    4949void MODULE_INIT(admi) (cherokee_module_loader_t *loader); 
    50 ret_t cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props); 
     50ret_t cherokee_handler_admin_new (cherokee_handler_t **hdl, void *cnt, cherokee_module_props_t *props); 
    5151 
    5252/* virtual methods implementation 

  • cherokee/trunk/cherokee/handler_cgi.c

    r384 r387  
    108108 
    109109ret_t 
    110 cherokee_handler_cgi_new  (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *props) 
     110cherokee_handler_cgi_new  (cherokee_handler_t **hdl, void *cnt, cherokee_module_props_t *props) 
    111111{ 
    112112        int i; 
    …… 
    259259 
    260260ret_t  
    261 cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props) 
     261cherokee_handler_cgi_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) 
    262262{ 
    263263        cherokee_handler_cgi_props_t *props; 
    …… 
    268268                CHEROKEE_NEW_STRUCT (n, handler_cgi_props); 
    269269 
    270                 cherokee_handler_props_init_base (HANDLER_PROPS(n),  
    271                                                   HANDLER_PROPS_FREE(cherokee_handler_cgi_props_free)); 
    272                 *_props = HANDLER_PROPS(n); 
     270                cherokee_module_props_init_base (MODULE_PROPS(n),  
     271                                                 MODULE_PROPS_FREE(cherokee_handler_cgi_props_free)); 
     272                *_props = MODULE_PROPS(n); 
    273273        } 
    274274 

  • cherokee/trunk/cherokee/handler_cgi.h

    r283 r387  
    7474/* Methods 
    7575 */ 
    76 ret_t cherokee_handler_cgi_new         (cherokee_handler_t    **hdl, void *cnt, cherokee_handler_props_t *props); 
     76ret_t cherokee_handler_cgi_new         (cherokee_handler_t    **hdl, void *cnt, cherokee_module_props_t *props); 
    7777ret_t cherokee_handler_cgi_free        (cherokee_handler_cgi_t *hdl); 
    7878 
    …… 
    8989                                           char *content, int content_len); 
    9090 
    91 ret_t cherokee_handler_cgi_configure      (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **props); 
     91ret_t cherokee_handler_cgi_configure      (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **props); 
    9292ret_t cherokee_handler_cgi_props_free     (cherokee_handler_cgi_props_t *props); 
    9393 

  • cherokee/trunk/cherokee/handler_cgi_base.c

    r385 r387  
    4343cherokee_handler_cgi_base_init (cherokee_handler_cgi_base_t              *cgi,  
    4444                                cherokee_connection_t                    *conn, 
    45                                 cherokee_handler_props_t                 *props, 
     45                                cherokee_module_props_t                  *props, 
    4646                                cherokee_handler_cgi_base_add_env_pair_t  add_env_pair, 
    4747                                cherokee_handler_cgi_base_read_from_cgi_t read_from_cgi) 
    …… 
    134134        } 
    135135         
    136         return cherokee_handler_props_free_base (HANDLER_PROPS(props)); 
     136        return cherokee_module_props_free_base (MODULE_PROPS(props)); 
    137137} 
    138138 
    139139ret_t  
    140 cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props) 
     140cherokee_handler_cgi_base_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) 
    141141{ 
    142142        ret_t                              ret; 

  • cherokee/trunk/cherokee/handler_cgi_base.h

    r384 r387  
    5050 
    5151typedef struct { 
    52         cherokee_handler_props_t           base; 
     52        cherokee_module_props_t            base; 
    5353        cherokee_list_t                    system_env; 
    5454        cuint_t                            change_user; 
    …… 
    8484ret_t cherokee_handler_cgi_base_init           (cherokee_handler_cgi_base_t              *hdl,  
    8585                                                cherokee_connection_t                    *conn, 
    86                                                 cherokee_handler_props_t                 *props,  
     86                                                cherokee_module_props_t                  *props,  
    8787                                                cherokee_handler_cgi_base_add_env_pair_t  add_env_pair, 
    8888                                                cherokee_handler_cgi_base_read_from_cgi_t read_from_cgi); 
    …… 
    107107                                                 cherokee_buffer_t                        *tmp); 
    108108 
    109 ret_t cherokee_handler_cgi_base_configure       (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **props); 
     109ret_t cherokee_handler_cgi_base_configure       (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **props); 
    110110ret_t cherokee_handler_cgi_base_props_free      (cherokee_handler_cgi_base_props_t *props); 
    111111 

  • cherokee/trunk/cherokee/handler_common.c

    r384 r387  
    6666        } 
    6767 
    68         return cherokee_handler_props_free_base (HANDLER_PROPS(props)); 
     68        return cherokee_module_props_free_base (MODULE_PROPS(props)); 
    6969} 
    7070 
    7171 
    7272ret_t  
    73 cherokee_handler_common_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_props_t **_props) 
     73cherokee_handler_common_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_module_props_t **_props) 
    7474{ 
    7575        ret_t ret; 
    …… 
    7979                CHEROKEE_NEW_STRUCT (n, handler_common_props); 
    8080 
    81                 cherokee_handler_props_init_base (HANDLER_PROPS(n), 
    82                                                   HANDLER_PROPS_FREE(cherokee_handler_common_props_free)); 
     81                cherokee_module_props_init_base (MODULE_PROPS(n), 
     82                                          &nb