Changeset 343

Show
Ignore:
Timestamp:
08/22/06 18:43:26 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/Makefile.am

    r340 r343  
    3131 
    3232CONFS_PRE = \ 
    33 cherokee.conf.sample.pre 
     33cherokee.conf.sample.pre \ 
     34cherokee.conf.performance.pre 
    3435 
    3536CONFS_DONE =      \ 
    …… 
    8788                $(INSTALL_DATA) $(top_builddir)/cherokee.conf.sample $(DESTDIR)$(cherokeeconfdir)/cherokee.conf; \ 
    8889        fi 
     90        @if test -f $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample ; then \ 
     91                echo "$@ will not overwrite existing $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample"; \ 
     92        else \ 
     93                $(INSTALL_DATA) $(top_builddir)/cherokee.conf.performance $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample; \ 
     94        fi 
    8995        @if test -f $(DESTDIR)$(cherokeeconfdir)/mime.types ; then \ 
    9096                echo "$@ will not overwrite existing $(DESTDIR)$(cherokeeconfdir)/mime.types"; \ 
    …… 
    112118                $(RM) -f $(DESTDIR)$(cherokeeconfdir)/cherokee.conf; \ 
    113119        fi 
     120        @if test -f $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample ; then \ 
     121                echo "rm -f $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample"; \ 
     122                $(RM) -f $(DESTDIR)$(cherokeeconfdir)/cherokee.conf.perf_sample; \ 
     123        fi 
    114124        @if test -f $(DESTDIR)$(cherokeeconfdir)/mime.types ; then \ 
    115125                echo "rm -f $(cherokeeconfdir)/mime.types"; \ 

  • cherokee/trunk/cherokee.conf.sample.pre

    r340 r343  
    11## 
    22## cherokee.conf -- Cherokee HTTP server configuration file 
     3## 
     4## Common use 
    35## 
    46## NOTE: This file is NOT meant to be edited by hand. 
    …… 
    2325vserver!default!document_root = %wwwroot% 
    2426vserver!default!directory_index = index.php,index.html 
     27 
     28vserver!default!logger = combined 
     29vserver!default!logger!access = /var/log/cherokee.access 
     30vserver!default!logger!error = /var/log/cherokee.error 
    2531 
    2632vserver!default!directory!/!handler = common 

  • cherokee/trunk/cherokee/buffer.c

    r342 r343  
    331331 
    332332 
    333 /* This function is based on code from thttpd 
    334  * Copyright: Jef Poskanzer <jef@acme.com> 
    335  * 
    336  * Copies and decodes a string.  It's ok for from and to to be the 
    337  * same string. 
    338  */ 
    339  
    340333ret_t 
    341334cherokee_buffer_decode (cherokee_buffer_t *buffer) 
    …… 
    348341        } 
    349342 
     343        /* Copies and decodes a string.  It's ok for from and to to be 
     344         * the same string. 
     345         */ 
    350346        from = to = buffer->buf; 
    351347 
    352348        for (; *from != '\0'; ++to, ++from) { 
    353349                if (from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2])) { 
    354                         if ((from[1] == '0') && (from[2] == '0')) { 
    355                                 /* Replace null bytes (%00) with spaces, 
    356                                  * to prevent attacks   
     350                        if (unlikely (((from[1] == '0') && (from[2] == '0')))) { 
     351                                /* Replace null bytes (%00) with 
     352                                 * spaces, to prevent attacks 
    357353                                 */ 
    358354                                *to = ' '; 
    …… 
    668664 
    669665 
    670 /* b64_decode_table has been copy&pasted from the code of thttpd:   
    671  * Copyright <A9> 1995,1998,1999,2000,2001 by Jef Poskanzer <jef@acme.com> 
    672  */ 
    673  
    674 /* Base-64 decoding.  This represents binary data as printable ASCII 
    675  * characters.  Three 8-bit binary bytes are turned into four 6-bit 
    676  * values, like so: 
    677  * 
    678  *   [11111111]  [22222222]  [33333333] 
    679  *   [111111] [112222] [222233] [333333] 
    680  * 
    681  * Then the 6-bit values are represented using the characters "A-Za-z0-9+/". 
    682  */ 
    683  
    684666ret_t  
    685667cherokee_buffer_decode_base64 (cherokee_buffer_t *buf) 
    …… 
    690672        int  d, prev_d = 0; 
    691673        int  buf_pos   = 0; 
     674 
     675        /* Base-64 decoding: This represents binary data as printable 
     676         * ASCII characters. Three 8-bit binary bytes are turned into 
     677         * four 6-bit values, like so: 
     678         *       
     679         *   [11111111]  [22222222]  [33333333] 
     680         *   [111111] [112222] [222233] [333333] 
     681         * 
     682         * Then the 6-bit values are represented using the characters 
     683         * "A-Za-z0-9+/". 
     684         */ 
    692685 
    693686        static const char 
    …… 
    711704                }; 
    712705 
    713  
    714         space_idx = 0; 
    715         phase = 0; 
    716706        for (i=0; i < buf->len; i++) { 
    717707                d = b64_decode_table[(int) buf->buf[i]]; 

  • cherokee/trunk/cherokee/config_entry.h

    r289 r343  
    5252        /* Handler 
    5353         */ 
    54         handler_func_new_t        handler_new_func; 
    55         cherokee_http_method_t    handler_methods; 
    56         cherokee_handler_props_t *handler_properties;  
     54        handler_func_new_t          handler_new_func; 
     55        cherokee_http_method_t      handler_methods; 
     56        cherokee_handler_props_t   *handler_properties;  
    5757 
    5858        /* Validator 
    5959         */ 
    60         validator_func_new_t      validator_new_func; 
    61         cherokee_table_t        *validator_properties;  
     60        validator_func_new_t        validator_new_func; 
     61        cherokee_validator_props_t *validator_properties;  
    6262 
    63         cherokee_buffer_t        *auth_realm; 
    64         cherokee_http_auth_t      authentication; 
    65         cherokee_table_t         *users; 
     63        cherokee_buffer_t          *auth_realm; 
     64        cherokee_http_auth_t        authentication; 
     65        cherokee_table_t           *users; 
    6666} cherokee_config_entry_t;  
    6767 

  • cherokee/trunk/cherokee/fdpoll-epoll.c

    r122 r343  
    5858} cherokee_fdpoll_epoll_t; 
    5959 
    60  
    61 /* 
    62 ** Copyright (c) 1999,2000 by Jef Poskanzer <jef@acme.com> 
    63 ** All rights reserved. 
    64 ** 
    65 ** Redistribution and use in source and binary forms, with or without 
    66 ** modification, are permitted provided that the following conditions 
    67 ** are met: 
    68 ** 1. Redistributions of source code must retain the above copyright 
    69 **    notice, this list of conditions and the following disclaimer. 
    70 ** 2. Redistributions in binary form must reproduce the above copyright 
    71 **    notice, this list of conditions and the following disclaimer in the 
    72 **    documentation and/or other materials provided with the distribution. 
    73 */ 
    7460 
    7561static ret_t  

  • cherokee/trunk/cherokee/fdpoll-poll.c

    r122 r343  
    5050} cherokee_fdpoll_poll_t; 
    5151 
    52  
    53 /* 
    54 ** Copyright (c) 1999,2000 by Jef Poskanzer <jef@acme.com> 
    55 ** All rights reserved. 
    56 ** 
    57 ** Redistribution and use in source and binary forms, with or without 
    58 ** modification, are permitted provided that the following conditions 
    59 ** are met: 
    60 ** 1. Redistributions of source code must retain the above copyright 
    61 **    notice, this list of conditions and the following disclaimer. 
    62 ** 2. Redistributions in binary form must reproduce the above copyright 
    63 **    notice, this list of conditions and the following disclaimer in the 
    64 **    documentation and/or other materials provided with the distribution. 
    65 */ 
    6652 
    6753static ret_t 

  • cherokee/trunk/cherokee/fdpoll-select.c

    r333 r343  
    7171 
    7272 
    73 /* 
    74 ** Copyright (c) 1999,2000 by Jef Poskanzer <jef@acme.com> 
    75 ** All rights reserved. 
    76 ** 
    77 ** Redistribution and use in source and binary forms, with or without 
    78 ** modification, are permitted provided that the following conditions 
    79 ** are met: 
    80 ** 1. Redistributions of source code must retain the above copyright 
    81 **    notice, this list of conditions and the following disclaimer. 
    82 ** 2. Redistributions in binary form must reproduce the above copyright 
    83 **    notice, this list of conditions and the following disclaimer in the 
    84 **    documentation and/or other materials provided with the distribution. 
    85 */ 
    86  
    8773static ret_t  
    8874_free (cherokee_fdpoll_select_t *fdp) 

  • cherokee/trunk/cherokee/handler.h

    r283 r343  
    5555} cherokee_handler_support_t; 
    5656 
     57/* Handler properties 
     58 */ 
     59typedef ret_t (* handler_props_func_free_t)  (void  *handlerp); 
     60 
     61typedef struct { 
     62        handler_props_func_free_t   free; 
     63} cherokee_handler_props_t; 
     64 
    5765 
    5866/* Callback function definitions 
    5967 */ 
    60 typedef ret_t (* handler_func_new_t)         (void **handler, void *cnt, cherokee_table_t *properties); 
     68typedef ret_t (* handler_func_new_t)         (void **handler, void *cnt, cherokee_handler_props_t *properties); 
    6169typedef ret_t (* handler_func_init_t)        (void  *handler); 
    6270typedef ret_t (* handler_func_free_t)        (void  *handler); 
    6371typedef ret_t (* handler_func_step_t)        (void  *handler, cherokee_buffer_t *buffer); 
    6472typedef ret_t (* handler_func_add_headers_t) (void  *handler, cherokee_buffer_t *buffer); 
    65 typedef ret_t (* handler_props_func_free_t)  (void  *handlerp); 
    6673 
    6774/* Data types 
    6875 */ 
    69 typedef struct { 
    70         void (*free) (void *itself); 
    71 } cherokee_handler_props_t; 
    72  
    7376typedef struct { 
    7477        cherokee_module_t           module; 

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

    r342 r343  
    7676        cherokee_buffer_t      *input_buffer; 
    7777        crc_t                   input_buffer_crc; 
    78         uint32_t                input_header_start; 
    7978        uint32_t                input_header_len; 
    80  
    8179}; 
    8280 

  • cherokee/trunk/cherokee/logger.h

    r122 r343  
    4343/* Callback function definitions 
    4444 */ 
    45 typedef ret_t (* logger_func_new_t)          (void **logger, cherokee_table_t *properties); 
     45typedef ret_t (* logger_func_new_t)          (void **logger, cherokee_config_node_t *config); 
    4646typedef ret_t (* logger_func_init_t)         (void  *logger); 
    4747typedef ret_t (* logger_func_free_t)         (void  *logger); 

  • cherokee/trunk/cherokee/logger_combined.c

    r122 r343  
    3535 
    3636ret_t 
    37 cherokee_logger_combined_new (cherokee_logger_t **logger, cherokee_table_t *properties) 
     37cherokee_logger_combined_new (cherokee_logger_t **logger, cherokee_config_node_t *config) 
    3838{ 
    3939        ret_t ret; 
    …… 
    5454        /* Init the base class: NCSA 
    5555         */ 
    56         ret = cherokee_logger_ncsa_init_base (n, properties); 
     56        ret = cherokee_logger_ncsa_init_base (n, config); 
    5757        if (unlikely(ret < ret_ok)) return ret; 
    5858 

  • cherokee/trunk/cherokee/logger_combined.h

    r122 r343  
    2323 */ 
    2424 
    25 #ifndef __CHEROKEE_LOGGER_COMBINED_H__ 
    26 #define __CHEROKEE_LOGGER_COMBINED_H__ 
     25#ifndef CHEROKEE_LOGGER_COMBINED_H 
     26#define CHEROKEE_LOGGER_COMBINED_H 
    2727 
    2828#include "logger_ncsa.h" 
    …… 
    3030typedef cherokee_logger_ncsa_t cherokee_logger_combined_t; 
    3131 
    32 ret_t cherokee_logger_combined_new (cherokee_logger_t **logger, cherokee_table_t *properties); 
     32ret_t cherokee_logger_combined_new (cherokee_logger_t **logger, cherokee_config_node_t *config); 
    3333 
    34 #endif /* __CHEROKEE_LOGGER_COMBINED_H__ */ 
     34#endif /* CHEROKEE_LOGGER_COMBINED_H */ 

  • cherokee/trunk/cherokee/logger_ncsa.c

    r220 r343  
    7171 
    7272ret_t 
    73 cherokee_logger_ncsa_new (cherokee_logger_t **logger, cherokee_table_t *properties) 
     73cherokee_logger_ncsa_new (cherokee_logger_t **logger, cherokee_config_node_t *config) 
    7474{ 
    7575        ret_t ret; 
    …… 
    8282        MODULE(n)->init         = (logger_func_init_t) cherokee_logger_ncsa_init; 
    8383        MODULE(n)->free         = (logger_func_free_t) cherokee_logger_ncsa_free; 
     84         
    8485        LOGGER(n)->flush        = (logger_func_flush_t) cherokee_logger_ncsa_flush; 
    8586        LOGGER(n)->reopen       = (logger_func_reopen_t) cherokee_logger_ncsa_reopen; 
    …… 
    8889        LOGGER(n)->write_string = (logger_func_write_string_t) cherokee_logger_ncsa_write_string; 
    8990 
    90         ret = cherokee_logger_ncsa_init_base (n, properties); 
     91        ret = cherokee_logger_ncsa_init_base (n, config); 
    9192        if (unlikely(ret < ret_ok)) return ret; 
    9293 
    …… 
    99100 
    100101ret_t  
    101 cherokee_logger_ncsa_init_base (cherokee_logger_ncsa_t *logger, cherokee_table_t *properties) 
    102 { 
     102cherokee_logger_ncsa_init_base (cherokee_logger_ncsa_t *logger, cherokee_config_node_t *config) 
     103{ 
     104        ret_t              ret; 
     105        cherokee_buffer_t *tmp; 
     106 
    103107        /* Init 
    104108         */ 
     109        cherokee_buffer_init (&logger->accesslog); 
     110        cherokee_buffer_init (&logger->errorlog); 
     111 
    105112        logger->errorlog_fd        = NULL; 
    106113        logger->accesslog_fd       = NULL; 
    107         logger->accesslog_filename = NULL; 
    108         logger->errorlog_filename  = NULL; 
    109114        logger->combined           = false; 
    110115         
    111         if (properties != NULL) { 
    112                 cherokee_typed_table_get_str (properties, "AccessLog", &logger->accesslog_filename); 
    113                 cherokee_typed_table_get_str (properties, "ErrorLog", &logger->errorlog_filename); 
     116        ret = cherokee_config_node_read (config, "access", &tmp); 
     117        if (ret == ret_ok) { 
     118                cherokee_buffer_add_buffer (&logger->accesslog, tmp); 
     119        } 
     120 
     121        ret = cherokee_config_node_read (config, "error", &tmp); 
     122        if (ret == ret_ok) { 
     123                cherokee_buffer_add_buffer (&logger->errorlog, tmp); 
    114124        } 
    115125         
    …… 
    121131open_output (cherokee_logger_ncsa_t *logger) 
    122132{ 
    123         if ((logger->accesslog_filename == NULL) || 
    124             (logger->errorlog_filename == NULL)) 
     133        if (cherokee_buffer_is_empty (&logger->accesslog) || 
     134            cherokee_buffer_is_empty (&logger->errorlog)) 
    125135        { 
    126136                openlog ("Cherokee", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); 
    …… 
    128138        } 
    129139 
    130         logger->accesslog_fd = fopen (logger->accesslog_filename, "a+"); 
     140        logger->accesslog_fd = fopen (logger->accesslog.buf, "a+"); 
    131141        if (logger->accesslog_fd == NULL) { 
    132                 PRINT_ERROR("cherokee_logger_ncsa: error opening %s for append\n", logger->accesslog_filename);  
     142                PRINT_ERROR("cherokee_logger_ncsa: error opening %s for append\n", logger->accesslog.buf);  
    133143                return ret_error; 
    134144        } 
    …… 
    137147#endif   
    138148 
    139         logger->errorlog_fd  = fopen (logger->errorlog_filename, "a+"); 
     149        logger->errorlog_fd  = fopen (logger->errorlog.buf, "a+"); 
    140150        if (logger->errorlog_fd == NULL) { 
    141                 PRINT_ERROR("cherokee_logger_ncsa: error opening %s for append\n", logger->errorlog_filename);  
     151                PRINT_ERROR("cherokee_logger_ncsa: error opening %s for append\n", logger->errorlog.buf);  
    142152                return ret_error; 
    143153        } 
    …… 
    186196cherokee_logger_ncsa_free (cherokee_logger_ncsa_t *logger) 
    187197{ 
     198        cherokee_buffer_mrproper (&logger->accesslog); 
     199        cherokee_buffer_mrproper (&logger->errorlog); 
     200 
    188201        return close_output (logger); 
    189202} 

  • cherokee/trunk/cherokee/logger_ncsa.h

    r122 r343  
    4040        cherokee_boolean_t combined; 
    4141 
    42         char *accesslog_filename; 
    43         char *errorlog_filename; 
     42        cherokee_buffer_t  accesslog; 
     43        cherokee_buffer_t  errorlog; 
    4444 
    4545        FILE *accesslog_fd; 
    4646        FILE *errorlog_fd; 
    47  
    4847} cherokee_logger_ncsa_t; 
    4948 
    5049 
    51 ret_t cherokee_logger_ncsa_new       (cherokee_logger_t     **logger, cherokee_table_t *properties); 
    52 ret_t cherokee_logger_ncsa_init_base (cherokee_logger_ncsa_t *logger, cherokee_table_t *properties); 
     50ret_t cherokee_logger_ncsa_new       (cherokee_logger_t     **logger, cherokee_config_node_t *config); 
     51ret_t cherokee_logger_ncsa_init_base (cherokee_logger_ncsa_t *logger, cherokee_config_node_t *config); 
    5352 
    5453/* virtual methods implementation 

  • cherokee/trunk/cherokee/logger_w3c.c

    r221 r343  
    7676 
    7777ret_t 
    78 cherokee_logger_w3c_new  (cherokee_logger_t **logger, cherokee_table_t *properties) 
    79 { 
     78cherokee_logger_w3c_new  (cherokee_logger_t **logger, cherokee_config_node_t *config) 
     79{ 
     80        ret_t              ret; 
     81        cherokee_buffer_t *tmp; 
    8082        CHEROKEE_NEW_STRUCT (n, logger_w3c); 
    8183         
    …… 
    9597        /* Init 
    9698         */ 
    97          
    98         n->header_added = 0; 
    99         n->filename     = NULL; 
     99        cherokee_buffer_init (&n->filename); 
     100 
     101        n->header_added = false; 
    100102        n->file         = NULL; 
    101103         
    102         if (properties != NULL) { 
    103                 cherokee_typed_table_get_str (properties, "LogFile", &n->filename); 
    104         } 
    105          
     104        ret = cherokee_config_node_read (config, "file", &tmp); 
     105        if (ret == ret_ok) {  
     106                cherokee_buffer_add_buffer (&n->filename, tmp); 
     107        } 
     108 
    106109        return ret_ok; 
    107110} 
    …… 
    113116        /* Syslog 
    114117         */ 
    115         if (logger->filename == NULL) { 
     118        if (cherokee_buffer_is_empty (&logger->filename)) { 
    116119                openlog ("Cherokee", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); 
    117120                return ret_ok; 
    …… 
    121124        /* Direct file writting 
    122125         */ 
    123         logger->file = fopen (logger->filename, "a+"); 
     126        logger->file = fopen (logger->filename.buf, "a+"); 
    124127        if (logger->file == NULL) { 
    125                 PRINT_ERROR("cherokee_logger_w3c: error opening %s for append\n", logger->filename);  
     128                PRINT_ERROR("cherokee_logger_w3c: error opening %s for append\n", logger->filename.buf);  
    126129                return ret_error; 
    127130        } 
    …… 
    163166cherokee_logger_w3c_free (cherokee_logger_w3c_t *logger) 
    164167{ 
     168        cherokee_buffer_mrproper (&logger->filename); 
    165169        return close_output (logger); 
    166170} 
    …… 
    291295        conn_time = &CONN_THREAD(cnt)->bogo_now_tm; 
    292296 
    293         if ((logger->header_added == 0) && (logger->file)) { 
     297        if ((! logger->header_added) && (logger->file)) { 
    294298                len = snprintf (tmp, tmp_size-1,  
    295299                                "#Version 1.0\n" 
    …… 
    307311                CHEROKEE_MUTEX_UNLOCK(&buffer_lock); 
    308312 
    309                 logger->header_added = 1; 
     313                logger->header_added = true; 
    310314        } 
    311315         

  • cherokee/trunk/cherokee/logger_w3c.h

    r122 r343  
    4343 
    4444typedef struct { 
    45            cherokee_logger_t logger; 
    46  
    47            int   header_added; 
    48  
    49            char *filename; 
    50            FILE *file; 
    51  
     45        cherokee_logger_t logger; 
     46         
     47        cherokee_boolean_t header_added; 
     48        cherokee_buffer_t  filename; 
     49        FILE              *file; 
    5250} cherokee_logger_w3c_t; 
    5351 
    5452 
    55 ret_t cherokee_logger_w3c_new (cherokee_logger_t **logger, cherokee_table_t *properties); 
     53ret_t cherokee_logger_w3c_new (cherokee_logger_t **logger, cherokee_config_node_t *config); 
    5654 
    5755/* virtual methods implementation 

  • cherokee/trunk/cherokee/module.h

    r336 r343  
    5656 
    5757 
    58 /* Data types for module_info 
     58/* Data types for the plug-ins: module_info 
    5959 */ 
    6060typedef struct { 
    …… 
    7575 
    7676 
    77 /* Data types for module 
     77/* Data types for module objects 
    7878 */ 
    7979typedef struct { 

  • cherokee/trunk/cherokee/pcre/pcre.c

    r31 r343  
    471471 
    472472 
    473  
    474473#ifdef SUPPORT_UTF8 
    475474/************************************************* 
    …… 
    55685567 
    55695568const uschar *callpat;             /* Many of these variables are used ony */ 
    5570 const uschar *charptr;             /* small blocks of the code. My normal  */ 
     5569// const uschar *charptr;          /* small blocks of the code. My normal  */ 
    55715570const uschar *data;                /* style of coding would have declared  */ 
    5572 const uschar *lastptr;             /* them within each of those blocks.    */ 
     5571// const uschar *lastptr;          /* them within each of those blocks.    */ 
    55735572const uschar *next;                /* However, in order to accommodate the */ 
    55745573const uschar *pp;                  /* version of this code that uses an    */ 

  • cherokee/trunk/cherokee/validator.h

    r330 r343  
    3737CHEROKEE_BEGIN_DECLS 
    3838 
     39 
     40/* Validator properties 
     41 */ 
     42typedef ret_t (* validator_props_func_free_t)  (void  *validatorp); 
     43 
     44typedef struct { 
     45        validator_props_func_free_t free; 
     46} cherokee_validator_props_t; 
     47 
     48 
    3949/* Callback function definitions 
    4050 */ 
    41 typedef ret_t (* validator_func_new_t)         (void **validator, cherokee_table_t *properties);  
     51typedef ret_t (* validator_func_new_t)         (void **validator, cherokee_validator_props_t *props);  
    4252typedef ret_t (* validator_func_check_t)       (void  *validator, void *conn); 
    4353typedef ret_t (* validator_func_add_headers_t) (void  *validator, void *conn, cherokee_buffer_t *buf); 
    44 typedef ret_t (* validator_props_func_free_t)  (void  *validatorp); 
     54 
    4555 
    4656/* Data types 
    4757 */ 
    48 typedef struct { 
    49         void (*free) (void *itself); 
    50 } cherokee_validator_props_t; 
    51  
    5258typedef struct { 
    5359        cherokee_module_t            module; 

  • cherokee/trunk/cherokee/validator_htdigest.c

    r342 r343  
    3737 
    3838ret_t  
    39 cherokee_validator_htdigest_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_table_t **_props) 
     39cherokee_validator_htdigest_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_validator_props_t **_props) 
    4040{ 
    4141        ret_t                                ret; 

  • cherokee/trunk/cherokee/validator_ldap.c

    r333 r343  
    3737cherokee_validator_ldap_new (cherokee_validator_ldap_t **ldap, cherokee_validator_props_t *props) 
    3838{          
    39         ret_t ret; 
    4039        CHEROKEE_NEW_STRUCT(n,validator_ldap); 
    4140 

  • cherokee/trunk/cherokee/virtual_server.c

    r340 r343  
    572572 
    573573static ret_t  
     574add_logger (cherokee_config_node_t *config, cherokee_virtual_server_t *vserver) 
     575{ 
     576        ret_t                   ret; 
     577        logger_func_new_t       func_new; 
     578        cherokee_module_info_t *info      = NULL; 
     579        cherokee_server_t      *srv       = SRV(vserver->server_ref); 
     580 
     581        if (cherokee_buffer_is_empty (&config->val)) { 
     582                PRINT_ERROR_S ("ERROR: A logger must be specified\n"); 
     583                return ret_error; 
     584        } 
     585 
     586        ret = cherokee_module_loader_get (&srv->loader, config->val.buf, &info); 
     587        if (ret < ret_ok) { 
     588                PRINT_MSG ("ERROR: Couldn't load logger module '%s'\n", config->val.buf); 
     589                return ret_error; 
     590        } 
     591 
     592        func_new = (logger_func_new_t) info->new_func; 
     593        if (func_new == NULL) return ret_error; 
     594 
     595        ret = func_new ((void **) &vserver->logger, config); 
     596        if (ret != ret_ok) return ret; 
     597         
     598        return ret_ok; 
     599} 
     600 
     601 
     602static ret_t  
    574603configure_user_dir (cherokee_config_node_t *config, cherokee_virtual_server_t *vserver) 
    575604{ 
    …… 
    646675                        if (ret != ret_ok) return ret; 
    647676                } 
     677        } else if (equal_buf_str (&conf->key, "logger")) { 
     678                ret = add_logger (conf, vserver); 
     679                if (ret != ret_ok) return ret; 
    648680 
    649681        } else if (equal_buf_str (&conf->key, "directory_index")) {