Changeset 433

Show
Ignore:
Timestamp:
10/21/06 15:47:20 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r432 r433  
    112006-10-19  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/server.c (update_bogo_now): Date header wasn't 
     4        generated because of an error in the logic. Fixed. 
     5 
     6        * cherokee/handler_dirlist.c (render_file): Code that replaces 
     7        %icon% and %icon_alt% has been slightly cleaned up. Now it is a 
     8        bit cleaner. 
     9 
     10        * cherokee/exts_table.h, cherokee/exts_table.h, cherokee/thread.c: 
     11        The extensions table is now implemented as a static structure. 
     12 
     13        * cherokee/Makefile.embedded (OBJS): Little files: a couple of 
     14        objects have been added and removed. 
     15 
     16        * cherokee/server.c (cherokee_server_new): Fixed tiny memory leak: 
     17        The server->icons object was created twice. 
     18 
     19        * cherokee/module_loader.c (cherokee_module_loader_get, 
     20        cherokee_module_loader_set_directory): These are now common 
     21        function between embedded and non-embedded version. 
     22 
     23        * cherokee/handler_redir.c: Code has been re-factored in order to 
     24        make u-cherokee compile again. 
     25 
     26        * cherokee/handler_file.c (cherokee_handler_file_init): use_io 
     27        cache logic was wrong. There was a extra "not" that was fucking it 
     28        up.  Thanks to A.D.F for noticing there was something wrong with 
     29        the iocache behaviour. 
     30 
     31        * cherokee/mime.c (cherokee_mime_free): Added check to ensure mime 
     32        object exists. 
     33 
     34        * cherokee/server-protected.h, 
     35        cherokee/server.c (cherokee_server_new): Removed config_file and 
     36        icons_file properties.  They are no longer needed. 
     37 
     38        * cherokee/virtual_server.c (configure_virtual_server_property): 
     39        Added three new configuration keys: "ssl_certificate_file", 
     40        "ssl_certificate_key_file" and "ssl_ca_list_file". 
     41 
     42        * cherokee/virtual_server.h, cherokee/virtual_server.c: 
     43        server_cert, server_key and ca_cert are not longer char *, not 
     44        they are cherokee_buffer_t's. 
    245 
    346        * doc/develop/Makefile.am (EXTRA_DIST), 

  • cherokee/trunk/cherokee/Makefile.embedded

    r198 r433  
    1 CFLAGS=-O0 -g -DCHEROKEE_COMPILATION -DCHEROKEE_EMBEDDED -I. -I.. -DCHEROKEE_CONFDIR=\""/etc/cherokee"\" -DCHEROKEE_DEPSDIR=\""/usr/share/cherokee/deps"\" 
     1CFLAGS=-O0 -g -DCHEROKEE_COMPILATION -DCHEROKEE_EMBEDDED -I. -I.. \ 
     2          -DCHEROKEE_CONFDIR=\""/etc/cherokee"\" \ 
     3          -DCHEROKEE_DEPSDIR=\""/usr/share/cherokee/deps"\" \ 
     4          -DCHEROKEE_ICONSDIR=\""/usr/share/cherokee/icons"\" \ 
     5          -DCHEROKEE_THEMEDIR=\""/usr/share/cherokee/themes"\"  
    26LDFLAGS=-lc -ldl 
    37 
    48OBJS = \ 
     9avl.o \ 
    510md5.o \ 
    611main.o \ 
    712http.o \ 
    813util.o \ 
     14list.o \ 
    915table.o \ 
    1016crc32.o \ 
    …… 
    2127avl/avl.o \ 
    2228encoder.o \ 
    23 list_ext.o \ 
    2429validator.o \ 
    2530exts_table.o \ 
    2631connection.o \ 
    2732tdate_parse.o \ 
     33config_node.o \ 
    2834logger_table.o \ 
    2935resolv_cache.o \ 
    …… 
    4753handler_dirlist.o \ 
    4854handler_common.o \ 
    49 list_merge_sort.o \ 
    5055post.o \ 
    5156nonce.o \ 
    52 typed_table.o \ 
    53 read_config_embedded.o  
     57read_config_embedded.o \ 
     58virtual_entries.o 
    5459 
    5560all: u-cherokee 

  • cherokee/trunk/cherokee/connection.c

    r389 r433  
    15701570         */ 
    15711571        ret = cherokee_exts_table_get (exts, &conn->request, config_entry); 
    1572         if (unlikely (ret == ret_error)) { 
     1572        switch (ret) { 
     1573        case ret_ok: 
     1574                break; 
     1575        case ret_not_found: 
     1576                return ret_ok; 
     1577        default: 
    15731578                conn->error_code = http_internal_error; 
    15741579                return ret_error; 

  • cherokee/trunk/cherokee/exts_table.c

    r384 r433  
    2424 
    2525#include "exts_table.h" 
    26 #include "table.h" 
    2726 
    2827#define ENTRIES "exts" 
    2928 
    3029 
    31 struct cherokee_exts_table { 
    32         cherokee_table_t table; 
    33         cherokee_list_t  list; 
    34 }; 
    35  
    3630ret_t  
    37 cherokee_exts_table_new (cherokee_exts_table_t **et) 
     31cherokee_exts_table_init (cherokee_exts_table_t *et) 
    3832{ 
    3933        ret_t ret; 
    40         CHEROKEE_NEW_STRUCT(n, exts_table); 
    4134 
    42         ret = cherokee_table_init(&n->table); 
    43         if (unlikely(ret != ret_ok)) return ret; 
     35        ret = cherokee_table_init(&et->table); 
     36        if (unlikely (ret != ret_ok)) return ret; 
    4437 
    45         INIT_LIST_HEAD(&n->list); 
     38        INIT_LIST_HEAD(&et->list); 
    4639 
    47         *et = n; 
    4840        return ret_ok; 
    4941} 
    …… 
    5143 
    5244ret_t  
    53 cherokee_exts_table_free (cherokee_exts_table_t *et) 
     45cherokee_exts_table_mrproper (cherokee_exts_table_t *et) 
    5446{ 
    5547        cherokee_list_content_free (&et->list, (cherokee_list_free_func) cherokee_config_entry_free); 
    5648        cherokee_table_mrproper (&et->table); 
    5749 
    58         free (et); 
    5950        return ret_ok; 
    6051} 
    …… 
    7162        if (dot == NULL) return ret_not_found; 
    7263 
     64        printf ("GET0: et %p table %p ext %s\n", et, &et->table, dot+1); 
    7365        ret = cherokee_table_get (&et->table, dot+1, (void **)&entry); 
     66        printf ("GET1: et %p table %p ext %s: %d\n", et, &et->table, dot+1, ret); 
    7467        if (ret != ret_ok) return ret; 
    7568 
    …… 
    10093         * plugin entry object. 
    10194         */ 
     95        printf ("ADD: et %p table %p ext %s\n", et, &et->table, ext); 
    10296        return cherokee_table_add (&et->table, ext, plugin_entry); 
    10397} 

  • cherokee/trunk/cherokee/exts_table.h

    r122 r433  
    2929#include "buffer.h" 
    3030#include "config_entry.h" 
     31#include "list.h" 
     32#include "table.h" 
    3133 
    32 typedef struct cherokee_exts_table cherokee_exts_table_t;      /* Extension -> config_entry */ 
     34 
     35typedef struct { 
     36        cherokee_table_t table; 
     37        cherokee_list_t  list; 
     38} cherokee_exts_table_t; 
     39 
    3340#define EXTTABLE(x) ((cherokee_exts_table_t *)(x)) 
    3441 
    35 ret_t cherokee_exts_table_new  (cherokee_exts_table_t **et); 
    36 ret_t cherokee_exts_table_free (cherokee_exts_table_t  *et); 
     42 
     43ret_t cherokee_exts_table_init     (cherokee_exts_table_t *et); 
     44ret_t cherokee_exts_table_mrproper (cherokee_exts_table_t *et); 
    3745 
    3846ret_t cherokee_exts_table_get  (cherokee_exts_table_t *et, cherokee_buffer_t *requested_url, cherokee_config_entry_t *plugin_entry); 

  • cherokee/trunk/cherokee/handler_dirlist.c

    r390 r433  
    501501list_sort_by_type (cherokee_list_t *list, cherokee_dirlist_sort_t sort) 
    502502{ 
     503#ifndef CHEROKEE_EMBEDDED 
    503504        switch (sort) { 
    504505        case Name_Down: 
    …… 
    521522                break; 
    522523        } 
     524#endif 
    523525} 
    524526 
    …… 
    705707{ 
    706708        cherokee_boolean_t                is_dir; 
     709        char                             *alt      = NULL; 
    707710        char                             *icon     = NULL; 
     711        char                             *name     = (char *) &file->info.d_name; 
    708712        cherokee_icons_t                 *icons    = HANDLER_SRV(dhdl)->icons; 
    709         char                             *name     = (char *) &file->info.d_name; 
    710713        cherokee_buffer_t                *tmp      = &dhdl->header; 
    711714        cherokee_handler_dirlist_props_t *props    = HDL_DIRLIST_PROP(dhdl); 
    …… 
    722725        is_dir = S_ISDIR(file->stat.st_mode); 
    723726 
    724         if (is_dir) { 
    725                 replace_token (buffer, "%icon_alt%", "[DIR]"); 
    726                 replace_token (buffer, "%icon%", icons->directory_icon.buf); 
    727         } else { 
    728                 cherokee_icons_get_icon (icons, name, &icon); 
    729                 if (icon == NULL) 
    730                         icon = "blank.png"; 
    731  
    732                 replace_token (buffer, "%icon_alt%", "[   ]"); 
    733                 replace_token (buffer, "%icon%", icon); 
    734         } 
     727        alt = (is_dir) ? "[DIR]" : "[   ]"; 
     728         
     729#ifndef CHEROKEE_EMBEDDED 
     730        if (icons != NULL) { 
     731                if (is_dir) { 
     732                        icon = icons->directory_icon.buf; 
     733                } else { 
     734                        cherokee_icons_get_icon (icons, name, &icon); 
     735                        if (icon == NULL) icon = "blank.png"; 
     736                } 
     737        } 
     738#endif 
     739 
     740        replace_token (buffer, "%icon_alt%", alt); 
     741        replace_token (buffer, "%icon%", icon); 
    735742 
    736743        /* File 

  • cherokee/trunk/cherokee/handler_file.c

    r419 r433  
    4444#include "util.h" 
    4545 
     46#define ENTRIES "handler,file" 
     47 
    4648 
    4749ret_t  
    …… 
    410412         */ 
    411413#ifndef CHEROKEE_EMBEDDED 
    412         use_io = ((!HDL_FILE_PROP(fhdl)->use_cache) && 
     414        use_io = ((HDL_FILE_PROP(fhdl)->use_cache) && 
    413415                  (conn->encoder == NULL) && 
    414416                  (conn->socket.is_tls == non_TLS) && 
    …… 
    416418                  (http_method_with_body (conn->header.method))); 
    417419         
     420 
     421        TRACE(ENTRIES, "Using iocache %d\n", use_io); 
     422         
    418423        if (use_io) { 
    419424                ret = cherokee_iocache_mmap_lookup (srv->iocache, 
    420425                                                    conn->local_directory.buf, 
    421426                                                    &io_entry); 
    422                 if (ret != ret_ok) { 
     427 
     428                TRACE(ENTRIES, "iocache looked up, local=%s ret=%d\n", conn->local_directory.buf, ret); 
     429                         
     430                if ((ret != ret_ok) ||  
     431                    (io_entry->mmaped == NULL)) 
     432                { 
     433                        /* Open fhdl->fd 
     434                         */ 
    423435                        ret = open_local_directory (fhdl, conn); 
    424436                        if (ret != ret_ok) { 
    …… 
    427439                        } 
    428440 
     441                        /* Map the file 
     442                         */ 
    429443                        ret = cherokee_iocache_mmap_get_w_fd (srv->iocache, 
    430444                                                              conn->local_directory.buf, 
    431445                                                              fhdl->fd, 
    432446                                                              &io_entry); 
     447 
     448                        TRACE(ENTRIES, "Got it from the iocache fd=%d, entry=%p\n", fhdl->fd, io_entry); 
    433449                } 
    434450 

  • cherokee/trunk/cherokee/handler_redir.c

    r387 r433  
    198198} 
    199199 
    200 #endif 
     200static ret_t 
     201configure_rewrite (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_redir_props_t *props) 
     202{ 
     203        ret_t               ret; 
     204        cint_t              hidden; 
     205        struct cre_list    *n; 
     206        cherokee_buffer_t  *substring; 
     207        pcre               *re         = NULL; 
     208        cherokee_buffer_t  *regex      = NULL; 
     209 
     210        TRACE(ENTRIES, "Converting rewrite rule '%s'\n", conf->key.buf); 
     211 
     212        /* Query conf 
     213         */ 
     214        cherokee_config_node_read_int (conf, "show", &hidden); 
     215        hidden = !hidden; 
     216 
     217        ret = cherokee_config_node_read (conf, "regex", &regex); 
     218        if (ret == ret_ok) { 
     219                ret = cherokee_regex_table_get (srv->regexs, regex->buf, (void **)&re); 
     220                if (ret != ret_ok) return ret; 
     221        }  
     222 
     223        ret = cherokee_config_node_read (conf, "substring", &substring); 
     224        if (ret != ret_ok) return ret; 
     225 
     226        /* New RegEx 
     227         */ 
     228        n = (struct cre_list*)malloc(sizeof(struct cre_list)); 
     229 
     230        INIT_LIST_HEAD (&n->item); 
     231        n->re         = re; 
     232        n->hidden     = hidden; 
     233         
     234        cherokee_buffer_init (&n->subs); 
     235        cherokee_buffer_add_buffer (&n->subs, substring); 
     236 
     237        /* Add the list 
     238         */ 
     239        cherokee_list_add_tail (LIST(n), &props->regex_list); 
     240 
     241        return ret_ok; 
     242} 
     243 
     244 
     245static void 
     246cre_entry_free (struct cre_list *n)  
     247{ 
     248        cherokee_buffer_mrproper (&n->subs); 
     249        free (n); 
     250} 
     251 
     252 
     253#endif /* CHEROKEE_EMBEDDED */ 
     254 
    201255 
    202256ret_t  
    …… 
    297351 
    298352 
    299 static ret_t 
    300 configure_rewrite (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_redir_props_t *props) 
    301 { 
    302         ret_t               ret; 
    303         cint_t              hidden; 
    304         struct cre_list    *n; 
    305         cherokee_buffer_t  *substring; 
    306         pcre               *re         = NULL; 
    307         cherokee_buffer_t  *regex      = NULL; 
    308  
    309         TRACE(ENTRIES, "Converting rewrite rule '%s'\n", conf->key.buf); 
    310  
    311         /* Query conf 
    312          */ 
    313         cherokee_config_node_read_int (conf, "show", &hidden); 
    314         hidden = !hidden; 
    315  
    316         ret = cherokee_config_node_read (conf, "regex", &regex); 
    317         if (ret == ret_ok) { 
    318                 ret = cherokee_regex_table_get (srv->regexs, regex->buf, (void **)&re); 
    319                 if (ret != ret_ok) return ret; 
    320         }  
    321  
    322         ret = cherokee_config_node_read (conf, "substring", &substring); 
    323         if (ret != ret_ok) return ret; 
    324  
    325         /* New RegEx 
    326          */ 
    327         n = (struct cre_list*)malloc(sizeof(struct cre_list)); 
    328  
    329         INIT_LIST_HEAD (&n->item); 
    330         n->re         = re; 
    331         n->hidden     = hidden; 
    332          
    333         cherokee_buffer_init (&n->subs); 
    334         cherokee_buffer_add_buffer (&n->subs, substring); 
    335  
    336         /* Add the list 
    337          */ 
    338         cherokee_list_add_tail (LIST(n), &props->regex_list); 
    339  
    340         return ret_ok; 
    341 } 
    342  
    343  
    344 static void 
    345 cre_entry_free (struct cre_list *n)  
    346 { 
    347         cherokee_buffer_mrproper (&n->subs); 
    348         free (n); 
    349 } 
    350  
    351  
    352353static ret_t  
    353354props_free (cherokee_handler_redir_props_t *props) 
    …… 
    357358        cherokee_buffer_mrproper (&props->url); 
    358359 
     360#ifndef CHEROKEE_EMBEDDED  
    359361        list_for_each_safe (i, tmp, &props->regex_list) { 
    360362                cre_entry_free ((struct cre_list *)i); 
    361363        } 
     364#endif 
    362365 
    363366        return cherokee_module_props_free_base (MODULE_PROPS(props)); 
    …… 
    393396                        cherokee_buffer_add_buffer (&props->url, &subconf->val); 
    394397 
     398#ifndef CHEROKEE_EMBEDDED 
    395399                } else if (equal_buf_str (&subconf->key, "rewrite")) { 
    396400                        cherokee_config_node_foreach (j, subconf) { 
    …… 
    398402                                if (ret != ret_ok) return ret; 
    399403                        } 
     404#endif 
    400405                } 
    401406        } 

  • cherokee/trunk/cherokee/md5crypt.c

    r370 r433  
    4949 
    5050        if (n > 4) 
    51                 return (NULL); 
     51                return NULL; 
    5252 
    5353        memset(buf, '\0', sizeof(buf)); 
    …… 
    5757        } 
    5858 
    59         return (buf); 
     59        return buf; 
    6060} 
    6161 
    …… 
    7070        struct MD5Context ctx, ctx1; 
    7171        unsigned long l; 
     72        cuint_t magic_len; 
    7273 
    7374        /* Refine the salt first.  It's possible we were given an already-hashed 
    …… 
    7778        sp = salt; 
    7879         
    79  
    8080        /* If it starts with the magic string, then skip that. 
    8181         */ 
    82         if(strncmp(sp, magic, strlen(magic)) == 0) 
    83                 sp += strlen(magic); 
     82        magic_len = strlen (magic); 
     83 
     84        if (strncmp(sp, magic, magic_len) == 0) 
     85                sp += magic_len; 
    8486 
    8587        /* It stops at the first '$', max 8 chars  
    …… 
    8789        for (ep = sp; *ep != '$'; ep++) { 
    8890                if (*ep == '\0' || ep >= (sp + 8)) 
    89                         return (NULL); 
     91                        return NULL; 
    9092        } 
    9193 
    …… 
    104106 
    105107        /* Then our magic string */ 
    106         MD5Update(&ctx, (unsigned char *)magic, strlen(magic)); 
     108        MD5Update(&ctx, (unsigned char *)magic, magic_len); 
    107109 
    108110        /* Then the raw salt */ 

  • cherokee/trunk/cherokee/mime.c

    r385 r433  
    5151{ 
    5252        cherokee_list_t *i, *tmp; 
     53 
     54        if (mime == NULL) 
     55                return ret_ok; 
    5356 
    5457        cherokee_table_mrproper (&mime->mime_table); 

  • cherokee/trunk/cherokee/module_loader.c

    r410 r433  
    107107} 
    108108 
     109 
    109110#else  
     111 
    110112 
    111113/* This is the non-embedded implementation 
    …… 
    499501} 
    500502 
     503 
     504#endif /* CHEROKEE_EMBEDDED */ 
     505 
     506 
    501507ret_t  
    502508cherokee_module_loader_get (cherokee_module_loader_t *loader, char *modname, cherokee_module_info_t **info) 
    …… 
    522528        return ret_ok; 
    523529} 
    524  
    525  
    526 #endif 

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

    r384 r433  
    173173         */ 
    174174        cherokee_config_node_t     config; 
    175       char                      *config_file; 
     175//    char                      *config_file; 
    176176        char                      *icons_file; 
    177177 

  • cherokee/trunk/cherokee/server.c

    r421 r433  
    108108        n->fdpoll_method   = cherokee_poll_UNSET; 
    109109 
    110         /* Config files 
    111          */ 
    112         n->config_file     = NULL;       
    113         n->icons_file      = NULL; 
    114          
    115110        /* Mime types 
    116111         */ 
    …… 
    155150        n->sendfile.max    = 2147483647; 
    156151 
     152        n->icons           = NULL; 
    157153        n->regexs          = NULL; 
    158154        n->icons           = NULL; 
    …… 
    187183 
    188184#ifndef CHEROKEE_EMBEDDED 
    189         /* Icons  
    190          */ 
    191         cherokee_icons_new (&n->icons); 
    192         return_if_fail (n->icons != NULL, ret_nomem); 
    193  
    194185        /* IO Cache cache 
    195186         */ 
    …… 
    252243        /* Config 
    253244         */ 
     245#ifndef CHEROKEE_EMBEDDED 
    254246        cherokee_config_node_init (&n->config); 
     247#endif 
    255248         
    256249        /* Return the object 
    …… 
    332325        destroy_all_threads (srv); 
    333326 
     327        /* File descriptors 
     328         */ 
    334329        close (srv->socket); 
    335          
     330 
     331 
     332#ifdef HAVE_TLS 
    336333        if (srv->socket_tls != -1) { 
    337334                close (srv->socket_tls);                 
    338335        } 
    339  
     336        CHEROKEE_MUTEX_DESTROY (&srv->accept_tls_mutex); 
     337#endif 
     338        CHEROKEE_MUTEX_DESTROY (&srv->accept_mutex); 
     339 
     340        /* Attached objects 
     341         */ 
    340342        cherokee_encoder_table_mrproper (&srv->encoders); 
    341343        cherokee_logger_table_free (srv->loggers); 
    342344 
    343 #ifdef HAVE_TLS 
    344         CHEROKEE_MUTEX_DESTROY (&srv->accept_tls_mutex); 
    345 #endif 
    346         CHEROKEE_MUTEX_DESTROY (&srv->accept_mutex); 
    347  
    348345#ifndef CHEROKEE_EMBEDDED 
    349         /* Nonces 
    350          */ 
     346        cherokee_mime_free (srv->mime); 
     347        cherokee_icons_free (srv->icons); 
     348        cherokee_regex_table_free (srv->regexs); 
     349        cherokee_iocache_free_default (srv->iocache); 
     350#endif 
     351 
    351352        cherokee_nonce_table_free (srv->nonces); 
    352         srv->nonces = NULL; 
    353  
    354         /* Icons  
    355          */ 
    356         cherokee_icons_free (srv->icons); 
    357         if (srv->icons_file != NULL) { 
    358                 free (srv->icons_file); 
    359                 srv->icons_file = NULL; 
    360         } 
    361  
    362         /* Mime 
    363          */ 
    364         if (srv->mime != NULL) { 
    365                 cherokee_mime_free (srv->mime); 
    366                 srv->mime = NULL; 
    367         } 
    368  
    369         cherokee_iocache_free_default (srv->iocache); 
    370  
    371         cherokee_regex_table_free (srv->regexs); 
    372 #endif 
    373353         
    374354        /* Virtual servers 
    …… 
    384364        cherokee_buffer_mrproper (&srv->listen_to); 
    385365        cherokee_buffer_mrproper (&srv->chroot); 
    386  
    387         /* Clean config files entries 
    388          */ 
    389         if (srv->config_file != NULL) { 
    390                 free (srv->config_file); 
    391                 srv->config_file = NULL; 
    392         } 
    393  
    394366        cherokee_buffer_mrproper (&srv->pidfile); 
    395367        cherokee_buffer_mrproper (&srv->panic_action); 
    396368 
    397         /* Module loader: 
    398          * It must be the last action to perform because 
    399          * it will close all the opened modules 
     369        /* Module loader: It must be the last action to be performed 
     370         * because it will close all the opened modules. 
    400371         */ 
    401372        cherokee_module_loader_mrproper (&srv->loader); 
    …… 
    11031074         */ 
    11041075        newtime = time (NULL); 
    1105         if (srv->bogo_now <= newtime) 
     1076        if (srv->bogo_now >= newtime)  
    11061077                return; 
    11071078 
    …… 
    12071178} 
    12081179 
     1180 
    12091181static ret_t  
    12101182matching_list_add_deny_cb  (char *val, void *data) 
    …… 
    12121184        return cherokee_matching_list_add_deny (MLIST(data), val); 
    12131185} 
     1186 
    12141187 
    12151188static ret_t  
    …… 
    13071280} 
    13081281 
     1282 
    13091283static ret_t  
    13101284load_mime_file (cherokee_server_t *srv, cherokee_buffer_t *mime_file) 
    …… 
    13121286        ret_t ret; 
    13131287 
     1288#ifndef CHEROKEE_EMBEDDED  
    13141289        if (srv->mime == NULL) { 
    13151290                ret = cherokee_mime_new (&srv->mime); 
    …… 
    13251300                return ret; 
    13261301        } 
     1302#endif 
    13271303 
    13281304        return ret_ok; 
    …… 
    14301406                } 
    14311407 
     1408        } else if (equal_buf_str (&conf->key, "thread_policy")) { 
     1409#ifdef HAVE_PTHREAD 
     1410                if (equal_buf_str (&conf->val, "fifo")) { 
     1411                        srv->thread_policy = SCHED_FIFO; 
     1412                } else if (equal_buf_str (&conf->val, "rr")) { 
     1413                        srv->thread_policy = SCHED_RR; 
     1414                } else if (equal_buf_str (&conf->val, "other")) { 
     1415                        srv->thread_policy = SCHED_OTHER; 
     1416                } else { 
     1417                        PRINT_MSG ("ERROR: Unknown thread policy '%s'\n", conf->val.buf); 
     1418                        return ret_error; 
     1419                } 
     1420#else 
     1421                PRINT_MSG ("WARNING: Ignoring thread_policy entry '%s'\n", conf->val.buf); 
     1422#endif 
     1423 
    14321424        } else if (equal_buf_str (&conf->key, "user")) { 
    14331425                struct passwd *pwd; 
    …… 
    14661458} 
    14671459 
     1460 
    14681461static ret_t 
    14691462configure_server (cherokee_server_t *srv) 
    …… 
    14801473                 */ 
    14811474                ret = cherokee_config_node_get (subconf, "module_dir", &subconf2); 
    1482                 printf ("module_dir %d\n", ret); 
    14831475                if (ret == ret_ok) { 
    14841476                        ret = cherokee_module_loader_set_directory (&srv->loader, &subconf2->val); 
    …… 
    14941486        /* Icons 
    14951487         */ 
     1488#ifndef CHEROKEE_EMBEDDED 
    14961489        TRACE (ENTRIES, "Configuring %s\n", "icons"); 
    14971490        ret = cherokee_config_node_get (&srv->config, "icons", &subconf); 
    …… 
    15031496                if (ret != ret_ok) return ret; 
    15041497        } 
     1498#endif  
    15051499         
    15061500        /* Load the virtual servers 
    …… 
    15371531        return ret_ok; 
    15381532} 
     1533 
    15391534 
    15401535ret_t  

  • cherokee/trunk/cherokee/table.c

    r354 r433  
    3434equal (void *avl_param, void *key, void *val) 
    3535{ 
     36//      printf ("equal (%s, %s) = %d\n", key, val, strcmp((const char *)key, (const char *)val)); 
    3637        return strcmp((const char *)key, (const char *)val); 
    3738} 

  • cherokee/trunk/cherokee/thread.c

    r429 r433  
    861861                        /* 1.- Read the extension configuration 
    862862                         */ 
    863                         if (ventry->exts != NULL) { 
    864                                 ret = cherokee_connection_get_ext_entry (conn, ventry->exts, &entry); 
    865                                 if (unlikely (ret != ret_ok)) { 
    866                                         cherokee_connection_setup_error_handler (conn); 
    867                                         conn->phase = phase_init; 
    868                                         continue; 
    869                                 } 
     863                        ret = cherokee_connection_get_ext_entry (conn, &ventry->exts, &entry); 
     864                        if (unlikely (ret != ret_ok)) { 
     865                                cherokee_connection_setup_error_handler (conn); 
     866                                conn->phase = phase_init; 
     867                                continue; 
    870868                        } 
    871869 

  • cherokee/trunk/cherokee/virtual_entries.c

    r293 r433  
    3232        ret_t ret; 
    3333         
    34         ventry->exts = NULL; 
    35  
    36         ret = cherokee_reqs_list_init (&ventry->reqs); 
     34        ret = cherokee_exts_table_init (&ventry->exts); 
    3735        if (unlikely(ret < ret_ok)) return ret; 
    3836         
    3937        ret = cherokee_dirs_table_init (&ventry->dirs); 
    4038        if (unlikely(ret < ret_ok)) return ret; 
     39 
     40#ifndef CHEROKEE_EMBEDDED 
     41        ret = cherokee_reqs_list_init (&ventry->reqs); 
     42        if (unlikely(ret < ret_ok)) return ret; 
     43#endif 
    4144 
    4245        return ret_ok; 
    …… 
    4851{ 
    4952        cherokee_dirs_table_mrproper (&ventry->dirs); 
     53        cherokee_exts_table_mrproper (&ventry->exts); 
     54 
     55#ifndef CHEROKEE_EMBEDDED 
    5056        cherokee_reqs_list_mrproper (&ventry->reqs); 
    51  
    52         if (ventry->exts != NULL) { 
    53                 cherokee_exts_table_free (ventry->exts); 
    54                 ventry->exts = NULL; 
    55         } 
     57#endif 
    5658 
    5759        return ret_ok; 

  • cherokee/trunk/cherokee/virtual_entries.h

    r269 r433  
    3333 
    3434typedef struct { 
    35         cherokee_dirs_table_t        dirs;            /* Eg: (/public, common) */ 
    36         cherokee_exts_table_t       *exts;            /* Eg: (.php,    phpcgi) */ 
    37         cherokee_reqs_list_t         reqs;            /* Eg: ("*.mp3"  auth{}) */ 
     35        cherokee_dirs_table_t  dirs;            /* Eg: (/public, common) */ 
     36        cherokee_exts_table_t  exts;            /* Eg: (.php,    phpcgi) */ 
     37        cherokee_reqs_list_t   reqs;            /* Eg: ("*.mp3"  auth{}) */ 
    3838} cherokee_virtual_entries_t; 
    3939 

  • cherokee/trunk/cherokee/virtual_server.c

    r423 r433  
    6565        CHEROKEE_MUTEX_INIT(&n->data.tx_mutex, NULL); 
    6666 
    67         n->server_cert     = NULL; 
    68         n->server_key      = NULL; 
    69         n->ca_cert         = NULL; 
     67        cherokee_buffer_init (&n->server_cert); 
     68        cherokee_buffer_init (&n->server_key); 
     69        cherokee_buffer_init (&n->ca_cert); 
    7070 
    7171#ifdef HAVE_TLS 
    …… 
    100100cherokee_virtual_server_free (cherokee_virtual_server_t *vserver) 
    101101{ 
    102         if (vserver->server_cert != NULL) { 
    103                 free (vserver->server_cert); 
    104                 vserver->server_cert = NULL; 
    105         } 
    106          
    107         if (vserver->server_key != NULL) { 
    108                 free (vserver->server_key); 
    109                 vserver->server_key = NULL; 
    110         } 
    111  
    112         if (vserver->ca_cert != NULL) { 
    113                 free (vserver->ca_cert); 
    114                 vserver->ca_cert = NULL; 
    115         } 
     102        cherokee_buffer_mrproper (&vserver->server_cert); 
     103        cherokee_buffer_mrproper (&vserver->server_key); 
     104        cherokee_buffer_mrproper (&vserver->ca_cert); 
    116105 
    117106        if (vserver->error_handler != NULL) { 
    …… 
    204193        return ret_not_found; 
    205194#endif 
    206  
    207         return ((vserver->server_cert != NULL) || 
    208                 (vserver->server_key  != NULL) || 
    209                 (vserver->ca_cert     != NULL)) ? ret_ok : ret_not_found; 
     195        if (cherokee_buffer_is_empty (&vserver->server_cert)) 
     196                return ret_ok; 
     197        if (cherokee_buffer_is_empty (&vserver->server_key)) 
     198                return ret_ok; 
     199        if (cherokee_buffer_is_empty (&vserver->ca_cert)) 
     200                return ret_ok; 
     201 
     202        return ret_not_found; 
    210203} 
    211204 
    …… 
    219212        return ret_ok; 
    220213#endif 
    221  
    222         if ((vsrv->ca_cert     == NULL) && 
    223             (vsrv->server_cert == NULL) && 
    224             (vsrv->server_key  == NULL))  
    225         { 
     214        /* Check if all of them are empty 
     215        */ 
     216        if (cherokee_buffer_is_empty (&vsrv->ca_cert)    && 
     217            cherokee_buffer_is_empty (&vsrv->server_key) && 
     218            cherokee_buffer_is_empty (&vsrv->server_cert)) 
    226219                return ret_not_found; 
    227         } 
    228  
    229         if ((vsrv->ca_cert     == NULL) || 
    230             (vsrv->server_cert == NULL) || <