Changeset 834

Show
Ignore:
Timestamp:
07/17/07 08:47:22 (1 year ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r833 r834  
     12007-07-16  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/icons.c: Converted to use cherokee_buffer_t * instead 
     4        of char *. 
     5 
     6        * cherokee/avl.c (cherokee_avl_mrproper2): Added new method. 
     7 
     8        * cherokee/exts_table.c, cherokee/regex.c, cherokee/mime.c, 
     9        cherokee/encoder_table.c: cherokee_table_t replaced by a 
     10        cherokee_avl_t. 
     11 
     12        * cherokee/avl.c (cherokee_avl_get_ptr): Added new method. 
     13        (cherokee_avl_add_ptr): Added new method. 
     14 
     15        * cherokee/table.c (cherokee_table_add, cherokee_table_get) 
     16        (cherokee_table_del): Optimized to use cherokee_buffer_fake 
     17        instead of allocating and freeing memory. It should improve the 
     18        performance a little bit. 
     19 
     20        * cherokee/buffer.h (cherokee_buffer_fake): Added new method. 
     21 
     22        * cherokee/handler_common.c (stat_file): Fixed to handle 
     23        ret_no_sys. It's returned when the iocache reaches its limit. 
     24 
     25        * cherokee/table.c (cherokee_table_get_val): Removed. It was a 
     26        mitake to add that method; we should rather use 
     27        cherokee_table_get(). 
     28 
     29        * cherokee/exts_table.c (cherokee_exts_table_has), 
     30        cherokee/regex.c (cherokee_regex_table_get, _add): We shouldn't 
     31        use cherokee_table_get_val(). Moved to use cherokee_table_get(). 
     32  
     33        * cherokee/dirs_table.c, cherokee/dirs_table.h: This class used to 
     34        be based on cherokee_table. Switch to cherokee_avl in order to 
     35        improve the performance. 
     36 
     37        * cherokee/iocache.c: Added a new TRACE entries. 
     38 
     39        * cherokee/handler_file.c (cherokee_handler_file_init): There was 
     40        an invalid call to cherokee_iocache_mmap_release() that was the 
     41        cause of the infamous 'iocache bug' that has been bothering us for 
     42        a couple of weeks. As soon as I have removed it, everything began 
     43        to work just fine. 
     44 
    1452007-07-16  Brian Rosner  <brosner@gmail.com> 
    246         

  • cherokee/trunk/cherokee/avl.c

    r826 r834  
    7373cherokee_avl_init (cherokee_avl_t *avl) 
    7474{ 
    75         avl->root = NULL; 
     75        avl->root             = NULL; 
     76        avl->case_insensitive = false; 
     77 
     78        return ret_ok; 
     79} 
     80 
     81 
     82ret_t  
     83cherokee_avl_set_case (cherokee_avl_t *avl, cherokee_boolean_t case_insensitive) 
     84{ 
     85        avl->case_insensitive = case_insensitive; 
    7686        return ret_ok; 
    7787} 
    …… 
    8191cherokee_avl_mrproper (cherokee_avl_t *avl) 
    8292{ 
    83         return ret_ok; 
     93        // TODO ! 
     94        return ret_ok; 
     95} 
     96 
     97 
     98static ret_t 
     99mrproper2_while (cherokee_buffer_t *key, void *value, void *param) 
     100{ 
     101        cherokee_avl_value_free_func_t free_func = param; 
     102 
     103        free_func(value); 
     104        return ret_ok; 
     105} 
     106 
     107ret_t  
     108cherokee_avl_mrproper2 (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func) 
     109{ 
     110        cherokee_avl_while (avl, mrproper2_while, free_func, NULL, NULL); 
     111        return cherokee_avl_mrproper (avl); 
    84112} 
    85113 
    …… 
    87115static int  
    88116compare_buffers (cherokee_buffer_t *A, 
    89                  cherokee_buffer_t *B) 
     117                 cherokee_buffer_t *B, 
     118                 cherokee_boolean_t case_insensitive) 
    90119{ 
    91120        if (A->len > B->len) 
    …… 
    93122        else if (B->len > A->len) 
    94123                return - (B->len - A->len); 
    95         else 
    96                 return strcmp (A->buf, B->buf); 
     124        else { 
     125                if (unlikely(case_insensitive)) 
     126                        return strcasecmp (A->buf, B->buf); 
     127                else 
     128                        return strcmp (A->buf, B->buf); 
     129        } 
    97130} 
    98131 
    …… 
    254287         */ 
    255288        while (true) { 
    256                 re = compare_buffers (&child->id, &node->id); 
     289                re = compare_buffers (&child->id, &node->id, tree->case_insensitive); 
    257290 
    258291                if (re < 0) { 
    …… 
    357390 
    358391        while (true) { 
    359                 re = compare_buffers (key, &node->id); 
     392                re = compare_buffers (key, &node->id, avl->case_insensitive); 
    360393                if (re == 0) { 
    361394                        if (value)  
    …… 
    516549 
    517550        while (true) { 
    518                 re = compare_buffers (key, &node->id); 
     551                re = compare_buffers (key, &node->id, avl->case_insensitive); 
    519552                if (re == 0) { 
    520553                        if (value) 
    …… 
    541574/* Commodity methods 
    542575 */ 
     576 
     577ret_t  
     578cherokee_avl_get_ptr (cherokee_avl_t *avl, const char *key, void **value) 
     579{ 
     580        cherokee_buffer_t tmp_key; 
     581 
     582        cherokee_buffer_fake (&tmp_key, (const char *)key, strlen(key)); 
     583        return cherokee_avl_get (avl, &tmp_key, value); 
     584} 
     585 
     586 
     587ret_t  
     588cherokee_avl_add_ptr (cherokee_avl_t *avl, const char *key, void *value) 
     589{ 
     590        cherokee_buffer_t tmp_key; 
     591 
     592        cherokee_buffer_fake (&tmp_key, (const char *)key, strlen(key)); 
     593        return cherokee_avl_add (avl, &tmp_key, value); 
     594} 
     595 
    543596 
    544597ret_t  
    …… 
    684737        return node_check (avl->root); 
    685738} 
     739 
     740 

  • cherokee/trunk/cherokee/avl.h

    r807 r834  
    3939typedef struct { 
    4040        cherokee_avl_node_t *root; 
     41        cherokee_boolean_t   case_insensitive; 
    4142} cherokee_avl_t; 
    4243 
    4344#define AVL(a) ((cherokee_avl_t *)(a)) 
    4445 
    45 typedef ret_t (* cherokee_avl_while_func_t) (cherokee_buffer_t *key, void *value, void *param); 
    46  
     46typedef ret_t (* cherokee_avl_while_func_t)      (cherokee_buffer_t *key, void *value, void *param); 
     47typedef void  (* cherokee_avl_value_free_func_t) (void *param); 
    4748 
    4849ret_t cherokee_avl_init      (cherokee_avl_t *avl); 
    4950ret_t cherokee_avl_mrproper  (cherokee_avl_t *avl); 
     51ret_t cherokee_avl_mrproper2 (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func); 
    5052 
     53ret_t cherokee_avl_add       (cherokee_avl_t *avl, cherokee_buffer_t *key, void  *value); 
     54ret_t cherokee_avl_add_ptr   (cherokee_avl_t *avl,        const char *key, void  *value); 
     55ret_t cherokee_avl_del       (cherokee_avl_t *avl, cherokee_buffer_t *key, void **value); 
    5156ret_t cherokee_avl_get       (cherokee_avl_t *avl, cherokee_buffer_t *key, void **value); 
    52 ret_t cherokee_avl_add       (cherokee_avl_t *avl, cherokee_buffer_t *key, void  *value); 
    53 ret_t cherokee_avl_del       (cherokee_avl_t *avl, cherokee_buffer_t *key, void **value); 
     57ret_t cherokee_avl_get_ptr   (cherokee_avl_t *avl,        const char *key, void **value); 
    5458 
    5559ret_t cherokee_avl_len       (cherokee_avl_t *avl, size_t *len); 
    5660ret_t cherokee_avl_while     (cherokee_avl_t *avl, cherokee_avl_while_func_t func, void *param, cherokee_buffer_t **key, void **value); 
    5761 
     62ret_t cherokee_avl_set_case  (cherokee_avl_t *avl, cherokee_boolean_t case_sensitive); 
    5863ret_t cherokee_avl_check     (cherokee_avl_t *avl); 
    5964ret_t cherokee_avl_print     (cherokee_avl_t *avl); 

  • cherokee/trunk/cherokee/buffer.c

    r784 r834  
    6262        return ret_ok; 
    6363} 
     64 
     65void 
     66cherokee_buffer_fake (cherokee_buffer_t *buf, const char *str, cuint_t len) 
     67{ 
     68        buf->buf  = (char *)str; 
     69        buf->len  = len; 
     70        buf->size = len + 1; 
     71} 
     72 
    6473 
    6574ret_t  

  • cherokee/trunk/cherokee/buffer.h

    r690 r834  
    4646 
    4747#define BUF(x) ((cherokee_buffer_t *)(x)) 
    48 #define CHEROKEE_BUF_INIT  {NULL, 0, 0} 
     48#define CHEROKEE_BUF_INIT      {NULL, 0, 0} 
    4949 
    5050#define cherokee_buffer_is_empty(b)        (BUF(b)->len == 0) 
    …… 
    5353#define cherokee_buffer_case_cmp_str(b,s)  cherokee_buffer_case_cmp (b, s, sizeof(s)) 
    5454 
    55  
    5655ret_t cherokee_buffer_new                (cherokee_buffer_t **buf); 
    5756ret_t cherokee_buffer_free               (cherokee_buffer_t  *buf); 
    5857ret_t cherokee_buffer_init               (cherokee_buffer_t  *buf); 
    5958ret_t cherokee_buffer_mrproper           (cherokee_buffer_t  *buf); 
     59void  cherokee_buffer_fake               (cherokee_buffer_t  *buf, const char *str, cuint_t len); 
    6060 
    6161ret_t cherokee_buffer_clean              (cherokee_buffer_t  *buf); 

  • cherokee/trunk/cherokee/connection_info.c

    r773 r834  
    7777cherokee_connection_info_fill_up (cherokee_connection_info_t *info, cherokee_connection_t *conn) 
    7878{ 
     79        ret_t                        ret; 
    7980        const char                  *handler_name = NULL; 
    8081        cherokee_icons_t            *icons        = CONN_SRV(conn)->icons; 
    …… 
    197198        { 
    198199                char              *tmp; 
    199                 char              *icon; 
     200                cherokee_buffer_t *icon; 
    200201                cherokee_buffer_t  name = CHEROKEE_BUF_INIT; 
    201202 
    …… 
    210211                        cherokee_buffer_move_to_begin (&name, tmp - name.buf); 
    211212                 
    212                 cherokee_icons_get_icon (icons, name.buf, &icon); 
    213                 if (icon != NULL) 
    214                         cherokee_buffer_add (&info->icon, icon, strlen(icon)); 
     213                ret = cherokee_icons_get_icon (icons, &name, &icon); 
     214                if (ret == ret_ok) 
     215                        cherokee_buffer_add_buffer (&info->icon, icon); 
    215216 
    216217                cherokee_buffer_mrproper (&name); 

  • cherokee/trunk/cherokee/dirs_table.c

    r690 r834  
    4141cherokee_dirs_table_init (cherokee_dirs_table_t *pt) 
    4242{ 
    43         return cherokee_table_init (pt); 
     43        return cherokee_avl_init (pt); 
    4444} 
    4545 
     46 
     47static ret_t  
     48mrproper_each (cherokee_buffer_t *key, void *value, void *param) 
     49{ 
     50        cherokee_config_entry_free (CONF_ENTRY(value)); 
     51        return ret_ok; 
     52} 
    4653 
    4754ret_t  
    4855cherokee_dirs_table_mrproper (cherokee_dirs_table_t *pt) 
    4956{ 
    50         return cherokee_table_mrproper2 ( 
    51                 TABLE(pt),  
    52                 (cherokee_table_free_item_t) cherokee_config_entry_free); 
     57        cherokee_avl_while (AVL(pt), 
     58                            mrproper_each, 
     59                            NULL, NULL, NULL); 
     60        return cherokee_avl_mrproper (AVL(pt)); 
    5361} 
    5462 
    …… 
    6573 
    6674        do { 
    67                 ret = cherokee_table_get (pt, web_directory->buf, (void **)&entry); 
     75                ret = cherokee_avl_get (AVL(pt), web_directory, (void **)&entry); 
    6876                 
    6977                /* Found 
    …… 
    155163                } 
    156164 
    157                 ret = cherokee_table_get (table, key.buf, &parent); 
     165                ret = cherokee_avl_get (table, &key, &parent); 
    158166                if (ret == ret_ok) { 
    159167                        entry->parent = parent; 

  • cherokee/trunk/cherokee/dirs_table.h

    r690 r834  
    2727 
    2828#include "common.h" 
    29 #include "table.h" 
     29#include "avl.h" 
    3030#include "config_entry.h" 
    3131 
    3232 
    33 typedef cherokee_table_t cherokee_dirs_table_t;  /* Web_directory -> config_entry */ 
     33typedef cherokee_avl_t cherokee_dirs_table_t;  /* Web_directory -> config_entry */ 
    3434#define DTABLE(x) ((cherokee_dirs_table_t *)(x)) 
    3535 

  • cherokee/trunk/cherokee/encoder_table.c

    r597 r834  
    3232cherokee_encoder_table_init  (cherokee_encoder_table_t *et) 
    3333{ 
    34         return cherokee_table_init (et); 
     34        return cherokee_avl_init (et); 
    3535} 
    3636 
    …… 
    3939cherokee_encoder_table_mrproper (cherokee_encoder_table_t *et) 
    4040{ 
    41         return cherokee_table_mrproper2 (et, (cherokee_table_free_item_t)  
    42                                         cherokee_encoder_table_entry_free); 
     41        return cherokee_avl_mrproper2 (et, (cherokee_table_free_item_t)  
     42                                      cherokee_encoder_table_entry_free); 
    4343} 
    4444 
    4545 
    4646ret_t  
    47 cherokee_encoder_table_set (cherokee_encoder_table_t *et, char *encoder, cherokee_encoder_table_entry_t *entry) 
     47cherokee_encoder_table_set (cherokee_encoder_table_t *et, cherokee_buffer_t *encoder, cherokee_encoder_table_entry_t *entry) 
    4848{ 
    49         return cherokee_table_add (et, encoder, entry); 
     49        return cherokee_avl_add (et, encoder, entry); 
    5050} 
    5151 
    …… 
    5454cherokee_encoder_table_get (cherokee_encoder_table_t *et, char *encoder, cherokee_encoder_table_entry_t **entry)  
    5555{ 
    56         return cherokee_table_get (et, encoder, (void **)entry); 
     56        return cherokee_avl_get_ptr (et, encoder, (void **)entry); 
    5757} 
    5858 

  • cherokee/trunk/cherokee/encoder_table.h

    r597 r834  
    2828#include "common-internal.h" 
    2929 
    30 #include "table.h" 
     30#include "avl.h" 
    3131#include "encoder.h" 
    3232#include "matching_list.h" 
    …… 
    3939 
    4040 
    41 typedef cherokee_table_t cherokee_encoder_table_t; 
     41typedef cherokee_avl_t cherokee_encoder_table_t; 
    4242#define ETABLE(x) ((cherokee_encoder_table_t *)(x)) 
    4343 
    …… 
    4848ret_t cherokee_encoder_table_mrproper          (cherokee_encoder_table_t *et); 
    4949 
     50ret_t cherokee_encoder_table_set               (cherokee_encoder_table_t *et, cherokee_buffer_t *encoder, cherokee_encoder_table_entry_t  *entry); 
    5051ret_t cherokee_encoder_table_get               (cherokee_encoder_table_t *et, char *encoder, cherokee_encoder_table_entry_t **entry); 
    51 ret_t cherokee_encoder_table_set               (cherokee_encoder_table_t *et, char *encoder, cherokee_encoder_table_entry_t  *entry); 
    5252ret_t cherokee_encoder_table_new_encoder       (cherokee_encoder_table_t *et, char *encoder, char *ext, cherokee_encoder_t **new_encoder); 
    5353 

  • cherokee/trunk/cherokee/exts_table.c

    r597 r834  
    3333        ret_t ret; 
    3434 
    35         ret = cherokee_table_init(&et->table); 
     35        ret = cherokee_avl_init(&et->avl); 
    3636        if (unlikely (ret != ret_ok)) return ret; 
    3737 
    …… 
    4646{ 
    4747        cherokee_list_content_free (&et->list, (cherokee_list_free_func) cherokee_config_entry_free); 
    48         cherokee_table_mrproper (&et->table); 
     48        cherokee_avl_mrproper (&et->avl); 
    4949 
    5050        return ret_ok; 
    …… 
    6161        if (dot == NULL) return ret_not_found; 
    6262 
    63         ret = cherokee_table_get (&et->table, dot+1, (void **)&entry); 
     63        ret = cherokee_avl_get_ptr (&et->avl, dot+1, (void **)&entry); 
    6464        if (ret != ret_ok) return ret; 
    6565 
    …… 
    9090         * plugin entry object. 
    9191         */ 
    92         TRACE ("ADD: et %p table %p ext %s\n", et, &et->table, ext); 
     92        TRACE ("ADD: et %p avl %p ext %s\n", et, &et->avl, ext); 
    9393 
    94         return cherokee_table_add (&et->table, ext, plugin_entry); 
     94        return cherokee_avl_add_ptr (&et->avl, ext, plugin_entry); 
    9595} 
    9696 
    …… 
    9898cherokee_exts_table_has (cherokee_exts_table_t *et, char *ext) 
    9999{ 
    100         return (cherokee_table_get_val (&et->table, ext) == NULL) ? ret_not_found : ret_ok; 
     100        void *foo; 
     101        return cherokee_avl_get_ptr (&et->avl, ext, &foo); 
    101102} 

  • cherokee/trunk/cherokee/exts_table.h

    r597 r834  
    3030#include "config_entry.h" 
    3131#include "list.h" 
    32 #include "table.h" 
     32#include "avl.h" 
    3333 
    3434 
    3535typedef struct { 
    36         cherokee_table_t table; 
     36        cherokee_avl_t   avl; 
    3737        cherokee_list_t  list; 
    3838} cherokee_exts_table_t; 

  • cherokee/trunk/cherokee/handler_common.c

    r827 r834  
    104104        int   re  = -1; 
    105105 
    106         /* Without cache 
    107          */ 
    108         if (!useit) { 
    109                 re = cherokee_stat (path->buf, nocache_info); 
    110  
    111                 TRACE (ENTRIES, "%s, use_iocache=%d re=%d\n", path->buf, useit, re); 
    112  
    113                 if (re < 0) { 
    114                         switch (errno) { 
    115                         case ENOENT:  
    116                                 return ret_not_found; 
    117                         case EACCES:  
    118                                 return ret_deny; 
    119                         default: 
    120                                 return ret_error; 
    121                         } 
    122                 } 
    123  
    124                 *info = nocache_info; 
    125                 return ret_ok; 
    126         } 
    127  
    128106        /* I/O cache 
    129107         */ 
    130108#ifndef CHEROKEE_EMBEDDED 
    131         ret = cherokee_iocache_get_or_create_w_stat (iocache, path, io_entry); 
    132  
    133         TRACE (ENTRIES, "%s, use_iocache=%d re=%d\n", path->buf, useit, re); 
    134  
    135         if (ret != ret_ok) { 
     109        if (useit) { 
     110                ret = cherokee_iocache_get_or_create_w_stat (iocache, path, io_entry);           
     111                TRACE (ENTRIES, "%s, use_iocache=1 rer=%d\n", path->buf, ret); 
     112 
    136113                switch (ret) { 
     114                case ret_ok: 
     115                        *info = &(*io_entry)->state; 
     116                        return ret_ok; 
     117 
    137118                case ret_not_found: 
    138119                        return ret_not_found; 
     120 
     121                case ret_no_sys: 
     122                        goto without; 
    139123                case ret_deny: 
    140124                        return ret_deny; 
    …… 
    142126                        return ret_error; 
    143127                } 
    144         } 
    145  
    146         *info = &(*io_entry)->state; 
    147         return ret_ok; 
    148 #endif 
     128                 
     129        } 
     130#endif 
     131 
     132 
     133        /* Without cache 
     134         */ 
     135without: 
     136        re = cherokee_stat (path->buf, nocache_info); 
     137        TRACE (ENTRIES, "%s, use_iocache=0 re=%d\n", path->buf, re); 
     138 
     139        if (re >= 0) { 
     140                *info = nocache_info; 
     141                return ret_ok; 
     142        } 
     143         
     144        switch (errno) { 
     145        case ENOENT:  
     146                return ret_not_found; 
     147        case EACCES:  
     148                return ret_deny; 
     149        default: 
     150                return ret_error; 
     151        } 
    149152 
    150153        return ret_error; 

  • cherokee/trunk/cherokee/handler_dirlist.c

    r597 r834  
    738738render_file (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer, file_entry_t *file) 
    739739{ 
     740        ret_t                             ret; 
    740741        cherokee_boolean_t                is_dir; 
    741742        cherokee_buffer_t                *vtmp[2]; 
    742743        char                             *alt      = NULL; 
    743         char                             *icon     = NULL; 
     744        cherokee_buffer_t                *icon     = NULL; 
    744745        char                             *name     = (char *) &file->info.d_name; 
    745746        cherokee_icons_t                 *icons    = HANDLER_SRV(dhdl)->icons; 
    …… 
    762763        if (icons != NULL) { 
    763764                if (is_dir) { 
    764                         icon = icons->directory_icon.buf; 
     765                        icon = &icons->directory_icon; 
    765766                } else { 
    766                         cherokee_icons_get_icon (icons, name, &icon); 
    767                         if (icon == NULL) icon = "blank.png"; 
     767                        cherokee_buffer_t name_buf; 
     768                         
     769                        cherokee_buffer_fake (&name_buf, name, strlen(name)); 
     770                        ret = cherokee_icons_get_icon (icons, &name_buf, &icon); 
     771                        if (ret != ret_ok)  
     772                                icon = "blank.png"; 
    768773                } 
    769774        } 

  • cherokee/trunk/cherokee/handler_file.c

    r824 r834  
    319319        if (HDL_FILE_PROP(fhdl)->use_cache) { 
    320320                ret = cherokee_iocache_get_or_create_w_stat (srv->iocache, &conn->local_directory, io_entry); 
     321                TRACE (ENTRIES, "%s, use_iocache=1 ret=%d\n", conn->local_directory.buf, ret); 
     322 
    321323                switch (ret) { 
    322324                case ret_ok: 
    …… 
    345347without: 
    346348        re = stat (conn->local_directory.buf, &fhdl->cache_info); 
     349        TRACE (ENTRIES, "%s, use_iocache=0 ret=%d\n", conn->local_directory.buf, re); 
     350 
    347351        if (re >= 0) { 
    348352                *info = &fhdl->cache_info;               
    …… 
    421425         */ 
    422426#ifndef CHEROKEE_EMBEDDED 
    423         use_io = ((HDL_FILE_PROP(fhdl)->use_cache) && 
    424                   (conn->encoder == NULL) && 
     427        use_io = ((conn->encoder == NULL) && 
     428                  (HDL_FILE_PROP(fhdl)->use_cache) && 
    425429                  (conn->socket.is_tls == non_TLS) && 
    426430                  (fhdl->info->st_size <= IOCACHE_MAX_FILE_SIZE) && 
    …… 
    431435         
    432436        if (use_io) { 
    433                 if (conn->io_entry_ref) 
    434                         cherokee_iocache_mmap_release (srv->iocache, conn->io_entry_ref); 
    435437                ret = cherokee_iocache_get_or_create_w_mmap (srv->iocache, 
    436438                                                             &conn->local_directory, 

  • cherokee/trunk/cherokee/icons.c

    r597 r834  
    3838        CHEROKEE_NEW_STRUCT(n, icons); 
    3939 
    40         ret = cherokee_table_init_case (&n->files); 
     40        ret = cherokee_avl_init (&n->files); 
    4141        if (unlikely(ret < ret_ok)) return ret; 
    4242 
    43         ret = cherokee_table_init (&n->files_matching); 
     43        ret = cherokee_avl_init (&n->files_matching); 
    4444        if (unlikely(ret < ret_ok)) return ret; 
    4545 
    46         ret = cherokee_table_init_case (&n->suffixes); 
     46        ret = cherokee_avl_init (&n->suffixes); 
    4747        if (unlikely(ret < ret_ok)) return ret; 
    4848 
     49        /* Files and Suffixes are case insensitive 
     50         */ 
     51        cherokee_avl_set_case (&n->files, true); 
     52        cherokee_avl_set_case (&n->suffixes, true); 
     53 
     54        /* Defaults 
     55         */ 
    4956        cherokee_buffer_init (&n->default_icon); 
    5057        cherokee_buffer_init (&n->directory_icon); 
    …… 
    5663 
    5764 
     65static void 
     66free_entry (void *param) 
     67{ 
     68        cherokee_buffer_free (BUF(param)); 
     69} 
     70 
     71 
    5872ret_t 
    5973cherokee_icons_free (cherokee_icons_t *icons) 
    6074{ 
    61         /* TODO: Set a free_item function. 
    62          */ 
    63         cherokee_table_mrproper2 (&icons->files, free); 
    64         cherokee_table_mrproper2 (&icons->suffixes, free); 
    65         cherokee_table_mrproper2 (&icons->files_matching, free); 
     75        /* It stores buffers as values, 
     76         */ 
     77        cherokee_avl_mrproper2 (&icons->files, free_entry); 
     78        cherokee_avl_mrproper2 (&icons->suffixes, free_entry); 
     79        cherokee_avl_mrproper2 (&icons->files_matching, free_entry); 
    6680 
    6781        cherokee_buffer_mrproper (&icons->default_icon); 
    …… 
    7589 
    7690ret_t  
    77 cherokee_icons_add_file (cherokee_icons_t *icons, cherokee_buffer_t *icon, const char *file) 
    78 { 
    79         if ((strchr(file, '*') != NULL) || 
    80             (strchr(file, '?') != NULL))  
     91cherokee_icons_add_file (cherokee_icons_t *icons, cherokee_buffer_t *icon, cherokee_buffer_t *file) 
     92{ 
     93        ret_t              ret; 
     94        cherokee_buffer_t *tmp = NULL; 
     95 
     96        ret = cherokee_buffer_dup (icon, &tmp); 
     97        if (unlikely (ret != ret_ok)) return ret; 
     98 
     99        if ((strchr (file->buf, '*') != NULL) || 
     100            (strchr (file->buf, '?') != NULL))  
    81101        { 
    82                 cherokee_table_add (&icons->files_matching, (char *)file, strdup(icon->buf)); 
     102                return cherokee_avl_add (&icons->files_matching, file, tmp); 
     103        } 
     104         
     105        return cherokee_avl_add (&icons->files, file, tmp); 
     106} 
     107 
     108 
     109ret_t  
     110cherokee_icons_add_suffix (cherokee_icons_t *icons, cherokee_buffer_t *icon, cherokee_buffer_t *suffix) 
     111{ 
     112        ret_t              ret; 
     113        cherokee_buffer_t *tmp = NULL; 
     114 
     115        ret = cherokee_buffer_dup (icon, &tmp); 
     116        if (unlikely (ret != ret_ok)) return ret; 
     117 
     118        cherokee_avl_add (&icons->suffixes, suffix, tmp); 
     119        return ret_ok; 
     120} 
     121 
     122 
     123ret_t  
     124cherokee_icons_set_directory (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
     125{ 
     126        cherokee_buffer_clean (&icons->directory_icon); 
     127        return cherokee_buffer_add_buffer (&icons->directory_icon, icon); 
     128} 
     129 
     130 
     131ret_t  
     132cherokee_icons_set_parentdir (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
     133{ 
     134        cherokee_buffer_clean (&icons->parentdir_icon); 
     135        return cherokee_buffer_add_buffer (&icons->parentdir_icon, icon); 
     136} 
     137 
     138 
     139ret_t  
     140cherokee_icons_set_default (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
     141{ 
     142        cherokee_buffer_clean (&icons->default_icon); 
     143        return cherokee_buffer_add_buffer (&icons->default_icon, icon); 
     144} 
     145 
     146 
     147ret_t  
     148match_file (cherokee_buffer_t *key, void *value, void *param) 
     149{ 
     150        ret_t              ret; 
     151        cherokee_buffer_t *param_file = param; 
     152 
     153        ret = cherokee_wildcard_match (key->buf, param_file->buf); 
     154        if (ret == ret_ok)  
     155                return ret_deny; 
     156 
     157        return ret_ok; 
     158} 
     159 
     160 
     161ret_t  
     162cherokee_icons_get_icon (cherokee_icons_t   *icons,  
     163                         cherokee_buffer_t  *file, 
     164                         cherokee_buffer_t **icon_ret) 
     165{ 
     166        ret_t  ret; 
     167        char  *suffix; 
     168 
     169        /* Look for the filename 
     170         */ 
     171        ret = cherokee_avl_get (&icons->files, file, (void **)icon_ret); 
     172        if (ret == ret_ok) return ret_ok; 
     173 
     174        /* Look for the suffix 
     175         */ 
     176        suffix = strrchr (file->buf, '.'); 
     177        if (suffix != NULL) { 
     178                ret = cherokee_avl_get_ptr (&icons->suffixes, suffix+1, (void **)icon_ret); 
     179                if (ret == ret_ok) return ret_ok; 
     180        } 
     181         
     182        /* Look for the wildcat matching 
     183         */ 
     184        ret = cherokee_avl_while (&icons->files_matching, match_file,  
     185                                  file, NULL, (void **)icon_ret); 
     186        if (ret == ret_ok) return ret_ok; 
     187 
     188        /* Default one 
     189         */ 
     190        if (! cherokee_buffer_is_empty (&icons->default_icon)) { 
     191                *icon_ret = &icons->default_icon; 
    83192                return ret_ok; 
    84193        } 
    85          
    86         cherokee_table_add (&icons->files, (char *)file, strdup(icon->buf)); 
    87         return ret_ok; 
    88 } 
    89  
    90  
    91 ret_t  
    92 cherokee_icons_add_suffix (cherokee_icons_t *icons, cherokee_buffer_t *icon, const char *suffix) 
    93 { 
    94         cherokee_table_add (&icons->suffixes, (char *)suffix, strdup(icon->buf)); 
    95         return ret_ok; 
    96 } 
    97  
    98  
    99 ret_t  
    100 cherokee_icons_set_directory (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
    101 { 
    102         cherokee_buffer_clean (&icons->directory_icon); 
    103         cherokee_buffer_add_buffer (&icons->directory_icon, icon); 
    104         return ret_ok; 
    105 } 
    106  
    107  
    108 ret_t  
    109 cherokee_icons_set_parentdir (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
    110 { 
    111         cherokee_buffer_clean (&icons->parentdir_icon); 
    112         cherokee_buffer_add_buffer (&icons->parentdir_icon, icon); 
    113         return ret_ok; 
    114 } 
    115  
    116  
    117 ret_t  
    118 cherokee_icons_set_default (cherokee_icons_t *icons, cherokee_buffer_t *icon) 
    119 { 
    120         cherokee_buffer_clean (&icons->default_icon); 
    121         cherokee_buffer_add_buffer (&icons->default_icon, icon); 
    122         return ret_ok; 
    123 } 
    124  
    125  
    126 static int 
    127 match_file (const char *pattern,  
    128             void       *icon, 
    129             void       *param_file) 
    130 { 
    131         ret_t ret; 
    132  
    133         ret = cherokee_wildcard_match (pattern, (char *)param_file); 
    134         return (ret == ret_ok); 
    135 } 
    136  
    137  
    138 ret_t  
    139 cherokee_icons_get_icon (cherokee_icons_t *icons, char *file, char **icon_ret) 
    140 { 
    141         ret_t   ret; 
    142         char   *suffix, *match_string; 
    143  
    144         /* Look for the filename 
    145          */ 
    146         ret = cherokee_table_get (&icons->files, file, (void **)icon_ret); 
    147         if (ret == ret_ok) return ret_ok; 
    148  
    149         /* Look for the suffix 
    150          */ 
    151         suffix = strrchr (file, '.'); 
    152         if (suffix != NULL) { 
    153                 ret = cherokee_table_get (&icons->suffixes, suffix+1, (void **)icon_ret); 
    154                 if (ret == ret_ok) return ret_ok; 
    155         } 
    156          
    157         /* Look for the wildcat matching 
    158          */ 
    159         ret = cherokee_table_while (&icons->files_matching, match_file,  
    160                                     file, &match_string, (void **)icon_ret); 
    161         if (ret == ret_ok) return ret_ok; 
    162  
    163         /* Default one 
    164          */ 
    165         if (icons->default_icon.len > 0) { 
    166                 *icon_ret = icons->default_icon.buf; 
    167         } 
    168  
    169         return ret_ok; 
     194 
     195        return ret_not_found; 
    170196} 
    171197 
    …… 
    174200add_file (char *file, void *data) 
    175201{ 
     202        cherokee_buffer_t  file_buf; 
     203        cherokee_icons_t  *icons    = ((void **)data)[0]; 
     204        cherokee_buffer_t *key      = ((void **)data)[1]; 
     205 
     206        TRACE(ENTRIES, "Adding file icon '%s' -> '%s'\n", key->buf, file); 
     207 
     208        cherokee_buffer_fake (&file_buf, file, strlen(file)); 
     209        return cherokee_icons_add_file (icons, key, &file_buf); 
     210} 
     211 
     212static ret_t  
     213add_suffix (char *file, void *data) 
     214{ 
     215        cherokee_buffer_t  file_buf; 
    176216        cherokee_icons_t  *icons = ((void **)data)[0]; 
    177217        cherokee_buffer_t *key   = ((void **)data)[1]; 
    178          
    179         TRACE(ENTRIES, "Adding file icon '%s' -> '%s'\n", key->buf, file); 
    180  
    181         return cherokee_icons_add_file (icons, key, file); 
    182 } 
    183  
    184 static ret_t  
    185 add_suffix (char *file, void *data) 
    186 { 
    187         cherokee_icons_t  *icons = ((void **)data)[0]; 
    188         cherokee_buffer_t *key   = ((void **)data)[1]; 
    189218 
    190219        TRACE(ENTRIES, "Adding suffix icon '%s' -> '%s'\n", key->buf, file); 
    191220         
    192         return cherokee_icons_add_suffix (icons, key, file); 
     221        cherokee_buffer_fake (&file_buf, file, strlen(file)); 
     222        return cherokee_icons_add_suffix (icons, key, &file_buf); 
    193223} 
    194224 

  • cherokee/trunk/cherokee/icons.h

    r597 r834  
    2727 
    2828#include "common.h" 
    29 #include "table.h" 
     29#include "avl.h" 
    3030#include "list.h" 
    3131#include "buffer.h" 
    …… 
    3434 
    3535typedef struct { 
    36         cherokee_table_t files; 
    37         cherokee_table_t suffixes; 
    38         cherokee_table_t files_matching;       
     36        cherokee_avl_t    files; 
     37        cherokee_avl_t    suffixes; 
     38        cherokee_avl_t    files_matching;      
    3939 
    4040        cherokee_buffer_t default_icon; 
    …… 
    5151 
    5252ret_t cherokee_icons_configure (cherokee_icons_t *icons, cherokee_config_node_t *config);  
    53 ret_t cherokee_icons_get_icon  (cherokee_icons_t *icons, char *file, char **icon); 
     53ret_t cherokee_icons_get_icon  (cherokee_icons_t *icons, cherokee_buffer_t *file, cherokee_buffer_t **icon); 
    5454