Changeset 835

Show
Ignore:
Timestamp:
07/17/07 14:15:32 (1 year ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r834 r835  
     12007-07-17  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * qa/run-tests.py: Count down fixed. 
     4 
     5        * cherokee/util.h, cherokee/util.c, cherokee/connection.c, 
     6        cherokee/connection-protected.h, cherokee/validator.c, 
     7        cherokee/nonce.c, cherokee/nonce.h: cherokee_table replaced by 
     8        cherokee_avl. 
     9 
     10        * cherokee/handler_dirlist.c (render_file): Adapted to the last 
     11        icons.c change. 
     12 
     13        * cherokee/icons.h, cherokee/icons.c: Added a new property 
     14        blank_icon that is returned when nothing else matches. 
     15 
    1162007-07-16  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    217 

  • cherokee/trunk/cherokee/avl.c

    r834 r835  
    6868 
    6969 
    70 /* Tree 
     70 
     71/* Tree constructor / destructor  
    7172 */ 
     73 
    7274ret_t  
    7375cherokee_avl_init (cherokee_avl_t *avl) 
    …… 
    7981} 
    8082 
    81  
    82 ret_t  
    83 cherokee_avl_set_case (cherokee_avl_t *avl, cherokee_boolean_t case_insensitive) 
    84 { 
    85         avl->case_insensitive = case_insensitive; 
    86         return ret_ok; 
    87 } 
    88  
    89  
    90 ret_t  
    91 cherokee_avl_mrproper (cherokee_avl_t *avl) 
    92 { 
    93         // TODO ! 
    94         return ret_ok; 
    95 } 
     83CHEROKEE_ADD_FUNC_NEW (avl); 
    9684 
    9785 
    …… 
    10189        cherokee_avl_value_free_func_t free_func = param; 
    10290 
    103         free_func(value); 
    104         return ret_ok; 
    105 } 
    106  
    107 ret_t  
    108 cherokee_avl_mrproper2 (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func) 
    109 { 
     91        if (free_func) { 
     92                free_func(value); 
     93        } 
     94 
     95        return ret_ok; 
     96} 
     97 
     98ret_t  
     99cherokee_avl_mrproper (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func) 
     100{ 
     101        /* Free all the entries 
     102         */ 
    110103        cherokee_avl_while (avl, mrproper2_while, free_func, NULL, NULL); 
    111         return cherokee_avl_mrproper (avl); 
    112 } 
    113  
     104 
     105        /* Clean the entries as well 
     106         */ 
     107//      TODO ! 
     108 
     109        return ret_ok; 
     110} 
     111 
     112ret_t  
     113cherokee_avl_free (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func) 
     114{ 
     115        cherokee_avl_mrproper (avl, free_func); 
     116        free (avl); 
     117        return ret_ok; 
     118} 
     119 
     120 
     121/* Tree methods 
     122 */ 
    114123 
    115124static int  
    …… 
    128137                        return strcmp (A->buf, B->buf); 
    129138        } 
     139} 
     140 
     141 
     142 
     143ret_t  
     144cherokee_avl_set_case (cherokee_avl_t *avl, cherokee_boolean_t case_insensitive) 
     145{ 
     146        avl->case_insensitive = case_insensitive; 
     147        return ret_ok; 
    130148} 
    131149 

  • cherokee/trunk/cherokee/avl.h

    r834 r835  
    4747typedef void  (* cherokee_avl_value_free_func_t) (void *param); 
    4848 
    49 ret_t cherokee_avl_init      (cherokee_avl_t *avl); 
    50 ret_t cherokee_avl_mrproper  (cherokee_avl_t *avl); 
    51 ret_t cherokee_avl_mrproper2 (cherokee_avl_t *avl, cherokee_avl_value_free_func_t free_func); 
     49ret_t cherokee_avl_new       (cherokee_avl_t **avl); 
     50ret_t cherokee_avl_free      (cherokee_avl_t  *avl, cherokee_avl_value_free_func_t free_func); 
     51 
     52ret_t cherokee_avl_init      (cherokee_avl_t  *avl); 
     53ret_t cherokee_avl_mrproper  (cherokee_avl_t  *avl, cherokee_avl_value_free_func_t free_func); 
    5254 
    5355ret_t cherokee_avl_add       (cherokee_avl_t *avl, cherokee_buffer_t *key, void  *value); 

  • cherokee/trunk/cherokee/config_entry.c

    r690 r835  
    9595 
    9696        if (entry->users != NULL) { 
    97                 cherokee_table_free (entry->users); 
     97                cherokee_avl_free (entry->users, free); 
    9898                entry->users = NULL; 
    9999        } 

  • cherokee/trunk/cherokee/config_entry.h

    r597 r835  
    2828#include "common-internal.h" 
    2929 
    30 #include "table.h" 
     30#include "avl.h" 
    3131#include "handler.h" 
    3232#include "http.h" 
    …… 
    3838 
    3939typedef struct { 
    40         /* Parent table_entry 
     40        /* Parent entry 
    4141         */ 
    4242        void                       *parent; 
    …… 
    6262        cherokee_buffer_t          *auth_realm; 
    6363        cherokee_http_auth_t        authentication; 
    64         cherokee_table_t           *users; 
     64        cherokee_avl_t             *users; 
    6565} cherokee_config_entry_t;  
    6666 

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

    r646 r835  
    5252#include "http.h" 
    5353#include "list.h" 
    54 #include "table.h" 
     54#include "avl.h" 
    5555#include "buffer_escape.h" 
    5656#include "socket.h" 
    …… 
    143143        cherokee_buffer_t             userdir;             /* 'alo' in http://www.alobbs.com/~alo/thing */ 
    144144        cherokee_buffer_t             query_string;      
    145         cherokee_table_t             *arguments; 
     145        cherokee_avl_t               *arguments; 
    146146 
    147147        cherokee_buffer_t             host; 

  • cherokee/trunk/cherokee/connection.c

    r804 r835  
    194194 
    195195        if (conn->arguments != NULL) { 
    196                 cherokee_table_free2 (conn->arguments, free); 
     196                cherokee_avl_free (conn->arguments, free); 
    197197                conn->arguments = NULL; 
    198198        } 
    …… 
    287287 
    288288        if (conn->arguments != NULL) { 
    289                 cherokee_table_free2 (conn->arguments, free); 
     289                cherokee_avl_free (conn->arguments, free); 
    290290                conn->arguments = NULL; 
    291291        } 
    …… 
    17001700                } 
    17011701 
    1702                 ret = cherokee_table_get (config_entry->users, conn->validator->user.buf, &foo); 
     1702                ret = cherokee_avl_get (config_entry->users, &conn->validator->user, &foo); 
    17031703                if (ret != ret_ok) { 
    17041704                        goto unauthorized; 
    …… 
    18671867        /* Build a new table  
    18681868         */ 
    1869         ret = cherokee_table_new (&conn->arguments); 
     1869        ret = cherokee_avl_new (&conn->arguments); 
    18701870        if (unlikely(ret < ret_ok)) return ret; 
    18711871 

  • cherokee/trunk/cherokee/dirs_table.c

    r834 r835  
    4545 
    4646 
    47 static ret_t  
    48 mrproper_each (cherokee_buffer_t *key, void *value, void *param) 
    49 { 
    50         cherokee_config_entry_free (CONF_ENTRY(value)); 
    51         return ret_ok; 
    52 } 
    53  
    5447ret_t  
    5548cherokee_dirs_table_mrproper (cherokee_dirs_table_t *pt) 
    5649{ 
    57         cherokee_avl_while (AVL(pt), 
    58                             mrproper_each, 
    59                             NULL, NULL, NULL); 
    60         return cherokee_avl_mrproper (AVL(pt)); 
     50        return cherokee_avl_mrproper (AVL(pt),  
     51                                      (cherokee_avl_value_free_func_t) cherokee_config_entry_free); 
    6152} 
    6253 

  • cherokee/trunk/cherokee/encoder_table.c

    r834 r835  
    3939cherokee_encoder_table_mrproper (cherokee_encoder_table_t *et) 
    4040{ 
    41         return cherokee_avl_mrproper2 (et, (cherokee_table_free_item_t)  
    42                                        cherokee_encoder_table_entry_free); 
     41        return cherokee_avl_mrproper (et, (cherokee_table_free_item_t) cherokee_encoder_table_entry_free); 
    4342} 
    4443 

  • cherokee/trunk/cherokee/exts_table.c

    r834 r835  
    4646{ 
    4747        cherokee_list_content_free (&et->list, (cherokee_list_free_func) cherokee_config_entry_free); 
    48         cherokee_avl_mrproper (&et->avl); 
    49  
     48        cherokee_avl_mrproper (&et->avl, NULL); 
    5049        return ret_ok; 
    5150} 

  • cherokee/trunk/cherokee/handler_dirlist.c

    r834 r835  
    371371        n->sort  = Name_Down; 
    372372 
    373         ret = cherokee_table_get (HANDLER_CONN(n)->arguments, "order", (void **) &value); 
     373        ret = cherokee_avl_get_ptr (HANDLER_CONN(n)->arguments, "order", (void **) &value); 
    374374        if (ret == ret_ok) { 
    375375                if      (value[0] == 'N') n->sort = Name_Up; 
    …… 
    769769                        cherokee_buffer_fake (&name_buf, name, strlen(name)); 
    770770                        ret = cherokee_icons_get_icon (icons, &name_buf, &icon); 
    771                         if (ret != ret_ok)  
    772                                 icon = "blank.png"; 
     771                        if (ret != ret_ok) return ret; 
    773772                } 
    774773        } 
    775774#endif 
    776775 
     776        if (icons && (icon == NULL)) 
     777                icon = &icons->blank_icon; 
     778 
    777779        VTMP_SUBSTITUTE_TOKEN ("%icon_alt%", alt); 
    778         VTMP_SUBSTITUTE_TOKEN ("%icon%", icon); 
     780        if (icon && icon->buf) 
     781                VTMP_SUBSTITUTE_TOKEN ("%icon%", icon->buf); 
     782        else 
     783                VTMP_SUBSTITUTE_TOKEN ("%icon%", ""); 
    779784 
    780785        /* File 

  • cherokee/trunk/cherokee/handler_server_info.c

    r764 r835  
    441441cherokee_handler_server_info_init (cherokee_handler_server_info_t *hdl) 
    442442{ 
    443         ret_t  ret; 
    444         void  *param; 
    445         int    web_interface = 1; 
     443        ret_t  ret; 
     444        void  *param; 
     445        cint_t  web_interface = 1; 
    446446 
    447447        cherokee_connection_parse_args (HANDLER_CONN(hdl)); 
    448                  
    449         ret = cherokee_table_get (HANDLER_CONN(hdl)->arguments, "logo", &param); 
     448 
     449        ret = cherokee_avl_get_ptr (HANDLER_CONN(hdl)->arguments, "logo", &param); 
    450450        if (ret == ret_ok) { 
    451451                 

  • cherokee/trunk/cherokee/icons.c

    r834 r835  
    5454        /* Defaults 
    5555         */ 
     56        cherokee_buffer_init (&n->blank_icon); 
    5657        cherokee_buffer_init (&n->default_icon); 
    5758        cherokee_buffer_init (&n->directory_icon); 
    5859        cherokee_buffer_init (&n->parentdir_icon); 
    59          
     60 
    6061        *icons = n; 
    6162        return ret_ok; 
    …… 
    7576        /* It stores buffers as values, 
    7677         */ 
    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); 
    80  
     78        cherokee_avl_mrproper (&icons->files, free_entry); 
     79        cherokee_avl_mrproper (&icons->suffixes, free_entry); 
     80        cherokee_avl_mrproper (&icons->files_matching, free_entry); 
     81 
     82        cherokee_buffer_mrproper (&icons->blank_icon); 
    8183        cherokee_buffer_mrproper (&icons->default_icon); 
    8284        cherokee_buffer_mrproper (&icons->directory_icon); 
    …… 
    193195        } 
    194196 
    195         return ret_not_found; 
     197        *icon_ret = &icons->blank_icon; 
     198        return ret_ok; 
    196199} 
    197200 

  • cherokee/trunk/cherokee/icons.h

    r834 r835  
    3838        cherokee_avl_t    files_matching;        
    3939 
     40        cherokee_buffer_t blank_icon; 
    4041        cherokee_buffer_t default_icon; 
    4142        cherokee_buffer_t directory_icon; 

  • cherokee/trunk/cherokee/mime.c

    r834 r835  
    5757                return ret_ok; 
    5858 
    59         cherokee_avl_mrproper (&mime->mime_table); 
     59        cherokee_avl_mrproper (&mime->mime_table, NULL); 
    6060 
    6161        list_for_each_safe (i, tmp, &mime->mime_list) { 

  • cherokee/trunk/cherokee/nonce.c

    r606 r835  
    2525#include "common-internal.h" 
    2626#include "nonce.h" 
     27#include "avl.h" 
    2728#include "connection-protected.h" 
    2829#include "server-protected.h" 
    2930 
    3031struct cherokee_nonce_table { 
    31         cherokee_table_t  table; 
     32        cherokee_avl_t    table; 
    3233        CHEROKEE_MUTEX_T (access); 
    3334}; 
    …… 
    3940        CHEROKEE_NEW_STRUCT(n, nonce_table); 
    4041 
    41         cherokee_table_init (TABLE(n)); 
     42        cherokee_avl_init (&n->table); 
    4243        CHEROKEE_MUTEX_INIT (&n->access, NULL); 
    4344 
    …… 
    5152{ 
    5253        CHEROKEE_MUTEX_DESTROY (&nonces->access); 
    53         cherokee_table_free2 (TABLE(nonces), free); 
     54        cherokee_avl_free (&nonces->table, free); 
    5455 
    5556        return ret_ok; 
    …… 
    6465 
    6566        CHEROKEE_MUTEX_LOCK (&nonces->access); 
    66         ret = cherokee_table_get (TABLE(nonces), nonce->buf, &non); 
     67        ret = cherokee_avl_get (&nonces->table, nonce, &non); 
    6768        if (ret == ret_ok) { 
    68                 cherokee_table_del (TABLE(nonces), nonce->buf, NULL); 
     69                cherokee_avl_del (&nonces->table, nonce, NULL); 
    6970        } 
    7071        CHEROKEE_MUTEX_UNLOCK (&nonces->access); 
    …… 
    8283 
    8384        CHEROKEE_MUTEX_LOCK (&nonces->access); 
    84         ret = cherokee_table_get (TABLE(nonces), nonce->buf, &non); 
     85        ret = cherokee_avl_get (&nonces->table, nonce, &non); 
    8586        CHEROKEE_MUTEX_UNLOCK (&nonces->access); 
    8687 
    …… 
    108109         */ 
    109110        CHEROKEE_MUTEX_LOCK (&nonces->access); 
    110         cherokee_table_add (TABLE(nonces), nonce->buf, NULL); 
     111        cherokee_avl_add (&nonces->table, nonce, NULL); 
    111112        CHEROKEE_MUTEX_UNLOCK (&nonces->access); 
    112113 

  • cherokee/trunk/cherokee/nonce.h

    r597 r835  
    3131 
    3232#include <cherokee/common.h> 
    33 #include <cherokee/table.h> 
    3433#include <cherokee/connection.h> 
    3534 

  • cherokee/trunk/cherokee/regex.c

    r834 r835  
    5757        CHEROKEE_RWLOCK_DESTROY (&table->rwlock); 
    5858 
    59         cherokee_avl_mrproper2 (&table->cache, free); 
     59        cherokee_avl_mrproper (&table->cache, free); 
    6060        return ret_ok; 
    6161} 

  • cherokee/trunk/cherokee/util.c

    r784 r835  
    10631063 
    10641064ret_t  
    1065 cherokee_parse_query_string (cherokee_buffer_t *qstring, cherokee_table_t *arguments) 
     1065cherokee_parse_query_string (cherokee_buffer_t *qstring, cherokee_avl_t *arguments) 
    10661066{ 
    10671067        char *string; 
    …… 
    10841084                        val = equ+1; 
    10851085 
    1086                         cherokee_table_add (arguments, key, strdup(val)); 
     1086                        cherokee_avl_add_ptr (arguments, key, strdup(val)); 
    10871087 
    10881088                        *equ = '='; 
    10891089                } else { 
    1090                         cherokee_table_add (arguments, token, NULL); 
     1090                        cherokee_avl_add_ptr (arguments, token, NULL); 
    10911091                } 
    10921092 

  • cherokee/trunk/cherokee/util.h

    r784 r835  
    3131 
    3232#include <cherokee/common.h> 
    33 #include <cherokee/table.h> 
     33#include <cherokee/avl.h> 
    3434 
    3535#ifdef HAVE_NETINET_IN_H 
    …… 
    126126 
    127127ret_t cherokee_parse_query_string (cherokee_buffer_t *qstring,  
    128                                    cherokee_table_t  *arguments); 
     128                                   cherokee_avl_t  *arguments); 
    129129 
    130130 

  • cherokee/trunk/cherokee/validator.c

    r782 r835  
    423423                } else if (equal_buf_str (&subconf->key, "users")) { 
    424424                        if (entry->users == NULL) { 
    425                                 cherokee_table_new (&entry->users); 
     425                                cherokee_avl_new (&entry->users); 
    426426                        } 
    427427 

  • cherokee/trunk/qa/run-tests.py

    r829 r835  
    2727thds     = 1 
    2828pause    = 0 
    29 delay    = 0 
    3029tpause   = 0.0 
    3130ssl      = False 
    …… 
    4342 
    4443server   = CHEROKEE_PATH 
     44delay    = SERVER_DELAY 
    4545 
    4646# Make the DocumentRoot directory 
    …… 
    239239 
    240240        for s in range(delay): 
    241            sys.stdout.write ("Tests will start in %d secs\r" % (SERVER_DELAY + delay - s - 1)) 
     241           sys.stdout.write ("Tests will start in %d secs\r" % (delay - s - 1)) 
    242242           sys.stdout.flush() 
    243243           time.sleep(1)