Changeset 277

Show
Ignore:
Timestamp:
04/21/06 14:13:07 (3 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r275 r277  
     12006-04-21  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * themes/Makefile.am, themes/default_theme.css, 
     4        themes/default_header.html, themes/default_footer.html, 
     5        themes/default_entry.html: Added default theme for dirlist. 
     6         
     7        * cherokee/handler_dirlist.c, cherokee/handler_dirlist.c: Almost 
     8        rewritten: removed hardcoded HTML.  Now it supports themes. 
     9         
    1102006-04-17  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     11 
     12        * cherokee/config_entry.c (cherokee_config_entry_set_handler_prop) 
     13        (cherokee_config_entry_set_validator_prop): Removed. Not longer 
     14        needed. 
    215 
    316        * cherokee/thread.c (process_active_connections): There was an 

  • cherokee/trunk/Makefile.am

    r269 r277  
    11## Cherokee: Makefile.am  -*- makefile -*- 
    22 
    3 SUBDIRS = m4 contrib www doc icons qa cherokee cget windows 
     3SUBDIRS = m4 contrib www doc icons themes qa cherokee cget windows 
    44bin_SCRIPTS = cherokee-config 
    55SUFFIXES = .sample.pre .sample 

  • cherokee/trunk/admin/index.php

    r257 r277  
    1 <?php 
    2            echo "<h1>hi</h1>"; 
     1<?php /* -*- Mode: PHP; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ 
     2 
     3/* Cherokee 
     4 * 
     5 * Authors: 
     6 *      Alvaro Lopez Ortega <alvaro@alobbs.com> 
     7 * 
     8 * Copyright (C) 2001-2006 Alvaro Lopez Ortega 
     9 * 
     10 * This program is free software; you can redistribute it and/or 
     11 * modify it under the terms of version 2 of the GNU General Public 
     12 * License as published by the Free Software Foundation. 
     13 * 
     14 * This program is distributed in the hope that it will be useful, 
     15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     17 * GNU General Public License for more details. 
     18 * 
     19 * You should have received a copy of the GNU General Public License 
     20 * along with this program; if not, write to the Free Software 
     21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 
     22 * USA 
     23 */ 
     24 
     25class Configuration  
     26{ 
     27        function Configuration() 
     28        { 
     29        } 
     30 
     31        function Load ($filename) 
     32        { 
     33                echo "".$filename; 
     34        } 
     35} 
     36 
     37function main()  
     38{ 
     39        $default_config = '/etc/cherokee/cherokee.conf'; 
     40 
     41        session_start(); 
     42 
     43        echo "session es: " . $_SESSION["config"] . "<br />"; 
     44 
     45        if ($_SESSION["config"] == null)  
     46        { 
     47                $conf = new Configuration(); 
     48                $conf->Load ($default_config); 
     49 
     50                $_SESSION["config"] = $conf; 
     51        } 
     52 
     53        session_write_close(); 
     54} 
     55 
     56main(); 
    357?> 

  • cherokee/trunk/cherokee/Makefile.am

    r269 r277  
    1010-DCHEROKEE_DATADIR=\""$(cherokeedatadir)"\" \ 
    1111-DCHEROKEE_CONFDIR=\""$(sysconfdir)/cherokee"\" \ 
    12 -DCHEROKEE_ICONSDIR=\""$(prefix)/share/cherokee/icons"\" 
     12-DCHEROKEE_ICONSDIR=\""$(prefix)/share/cherokee/icons"\" \ 
     13-DCHEROKEE_THEMEDIR=\""$(prefix)/share/cherokee/themes"\" 
    1314 
    1415# 

  • cherokee/trunk/cherokee/config_entry.c

    r269 r277  
    7676{ 
    7777        if (entry->handler_properties != NULL) { 
    78                 cherokee_typed_table_free (entry->handler_properties); 
     78                if (entry->handler_properties->free == NULL) { 
     79                        SHOULDNT_HAPPEN; 
     80                } 
     81                         
     82                entry->handler_properties->free (entry->handler_properties); 
    7983                entry->handler_properties = NULL; 
    8084        } 
    …… 
    108112        free (entry); 
    109113        return ret_ok; 
    110 } 
    111  
    112  
    113 static ret_t  
    114 entry_set_prop (prop_table_types_t table_type, cherokee_config_entry_t *entry, char *prop_name, cherokee_typed_table_types_t type, void *value, cherokee_table_free_item_t free_func) 
    115 { 
    116         ret_t              ret; 
    117         cherokee_table_t **table; 
    118  
    119         /* Choose the table 
    120          */ 
    121         switch (table_type) { 
    122         case table_handler: 
    123                 table = &entry->handler_properties; 
    124                 break; 
    125         case table_validator: 
    126                 table = &entry->validator_properties; 
    127                 break; 
    128         } 
    129          
    130         /* Create the table on demand to save memory 
    131          */ 
    132         if (*table == NULL) { 
    133                 ret = cherokee_table_new (table); 
    134                 if (unlikely(ret != ret_ok)) return ret; 
    135         } 
    136  
    137         /* Add the property 
    138          */ 
    139         switch (type) { 
    140         case typed_int: 
    141                 return cherokee_typed_table_add_int (*table, prop_name, POINTER_TO_INT(value)); 
    142         case typed_str: 
    143                 return cherokee_typed_table_add_str (*table, prop_name, value); 
    144         case typed_data: 
    145                 return cherokee_typed_table_add_data (*table, prop_name, value, free_func); 
    146         case typed_list: 
    147                 return cherokee_typed_table_add_list (*table, prop_name, value, free_func); 
    148         default: 
    149                 SHOULDNT_HAPPEN; 
    150         } 
    151          
    152         return ret_error; 
    153 } 
    154  
    155  
    156 ret_t  
    157 cherokee_config_entry_set_handler_prop (cherokee_config_entry_t *entry, char *prop_name, cherokee_typed_table_types_t type, void *value, cherokee_table_free_item_t free_func) 
    158 { 
    159         return entry_set_prop (table_handler, entry, prop_name, type, value, free_func); 
    160 } 
    161  
    162  
    163 ret_t  
    164 cherokee_config_entry_set_validator_prop (cherokee_config_entry_t *entry, char *prop_name, cherokee_typed_table_types_t type, void *value, cherokee_table_free_item_t free_func) 
    165 { 
    166         return entry_set_prop (table_validator, entry, prop_name, type, value, free_func); 
    167114} 
    168115 

  • cherokee/trunk/cherokee/config_entry.h

    r269 r277  
    4141        /* Parent table_entry 
    4242         */ 
    43         void                   *parent; 
    44         cuint_t                 priority; 
     43        void                     *parent; 
     44        cuint_t                   priority; 
    4545 
    4646        /* Properties 
    4747         */ 
    48         cherokee_buffer_t      *document_root; 
    49         cherokee_boolean_t      only_secure; 
    50         void                   *access; 
     48        cherokee_buffer_t        *document_root; 
     49        cherokee_boolean_t        only_secure; 
     50        void                     *access; 
    5151 
    5252        /* Handler 
    5353         */ 
    54         handler_func_new_t      handler_new_func; 
    55         cherokee_http_method_t  handler_methods; 
    56         cherokee_table_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_table_t         *validator_properties;  
    6262 
    63         cherokee_buffer_t      *auth_realm; 
    64         cherokee_http_auth_t    authentication; 
    65         cherokee_table_t       *users; 
    66  
     63        cherokee_buffer_t        *auth_realm; 
     64        cherokee_http_auth_t      authentication; 
     65        cherokee_table_t         *users; 
    6766} cherokee_config_entry_t;  
    6867 

  • cherokee/trunk/cherokee/config_node.c

    r272 r277  
    2626#include "config_node.h" 
    2727#include "util.h" 
     28#include "list_ext.h" 
    2829 
    2930#define ENTRIES "config" 
    …… 
    415416} 
    416417 
     418 
     419static ret_t 
     420convert_to_list_step (char *entry, void *data) 
     421{ 
     422        return cherokee_list_add_tail ((list_t *)data, strdup(entry)); 
     423} 
     424 
     425ret_t 
     426cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, list_t *list) 
     427{ 
     428        return cherokee_config_node_read_list (conf, key, convert_to_list_step, list); 
     429} 

  • cherokee/trunk/cherokee/config_node.h

    r272 r277  
    7171/* Convenience functions: value retrieving 
    7272 */ 
    73 ret_t cherokee_config_node_read      (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t **buf); 
    74 ret_t cherokee_config_node_read_path (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t **buf); 
    75 ret_t cherokee_config_node_read_int  (cherokee_config_node_t *conf, const char *key, int *num); 
    76 ret_t cherokee_config_node_read_list (cherokee_config_node_t *conf, const char *key,  
    77                                       cherokee_config_node_list_func_t func, void *param); 
     73ret_t cherokee_config_node_read       (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t **buf); 
     74ret_t cherokee_config_node_read_path  (cherokee_config_node_t *conf, const char *key, cherokee_buffer_t **buf); 
     75ret_t cherokee_config_node_read_int   (cherokee_config_node_t *conf, const char *key, int *num); 
     76ret_t cherokee_config_node_read_list  (cherokee_config_node_t *conf, const char *key,  
     77                                       cherokee_config_node_list_func_t func, void *param); 
     78 
     79ret_t cherokee_config_node_convert_list (cherokee_config_node_t *conf, const char *key, list_t *list); 
    7880 
    7981CHEROKEE_END_DECLS 

  • cherokee/trunk/cherokee/handler.h

    r251 r277  
    7777        void                      *connection; 
    7878        cherokee_handler_support_t support; 
     79} cherokee_handler_t; 
    7980 
    80 } cherokee_handler_t; 
     81typedef struct { 
     82        void (*free) (void *itself); 
     83} cherokee_handler_props_t; 
     84 
    8185 
    8286#define HANDLER(x)                         ((cherokee_handler_t *)(x)) 

  • cherokee/trunk/cherokee/handler_dirlist.c

    r273 r277  
    6363 
    6464 
    65 static ret_t  
    66 config_add_header_file (char *key, void *param) 
    67 { 
    68         return cherokee_list_add_tail (LIST(param), strdup(key)); 
    69 } 
     65 
     66static ret_t 
     67load_theme_load_file (cherokee_buffer_t *theme_path, char *file, cherokee_buffer_t *output) 
     68{ 
     69        cherokee_buffer_t path = CHEROKEE_BUF_INIT; 
     70 
     71        cherokee_buffer_add_buffer (&path, theme_path); 
     72        cherokee_buffer_add (&path, file, strlen(file)); 
     73         
     74        cherokee_buffer_clean (output); 
     75        cherokee_buffer_read_file (output, path.buf); 
     76 
     77        cherokee_buffer_mrproper (&path); 
     78        return ret_ok; 
     79} 
     80 
     81static ret_t 
     82parse_if (cherokee_buffer_t *buf, char *if_entry, cherokee_boolean_t show) 
     83{ 
     84        char              *begin; 
     85        char              *end; 
     86        cherokee_buffer_t  token = CHEROKEE_BUF_INIT; 
     87         
     88        cherokee_buffer_add_str (&token, "%if "); 
     89        cherokee_buffer_add (&token, if_entry, strlen(if_entry)); 
     90        cherokee_buffer_add_str (&token, "%"); 
     91 
     92        begin = strstr (buf->buf, token.buf); 
     93        if (begin == NULL) goto error; 
     94         
     95        end = strstr (begin, "%fi%"); 
     96        if (end == NULL) goto error; 
     97 
     98        if (show) { 
     99                cherokee_buffer_remove_chunk (buf, end - buf->buf, 4);           
     100                cherokee_buffer_remove_chunk (buf, begin - buf->buf, token.len); 
     101        } else { 
     102                cherokee_buffer_remove_chunk (buf, begin - buf->buf, (end+4) - begin); 
     103        } 
     104 
     105        cherokee_buffer_mrproper (&token); 
     106        return ret_ok;   
     107error: 
     108        cherokee_buffer_mrproper (&token); 
     109        return ret_error;        
     110} 
     111 
     112static ret_t 
     113parse_macros_in_buffer (cherokee_buffer_t *buf, cherokee_handler_dirlist_props_t *props) 
     114{ 
     115        parse_if (buf, "size",  props->show_size); 
     116        parse_if (buf, "date",  props->show_date); 
     117        parse_if (buf, "user",  props->show_user); 
     118        parse_if (buf, "group", props->show_group); 
     119 
     120        return ret_ok; 
     121} 
     122 
     123static ret_t 
     124load_theme (cherokee_buffer_t *theme_path, cherokee_handler_dirlist_props_t *props) 
     125{ 
     126        load_theme_load_file (theme_path, "header.html", &props->header); 
     127        load_theme_load_file (theme_path, "footer.html", &props->footer); 
     128        load_theme_load_file (theme_path, "entry.html", &props->entry); 
     129        load_theme_load_file (theme_path, "theme.css", &props->css); 
     130 
     131        /* Check it 
     132         */ 
     133        if ((cherokee_buffer_is_empty (&props->header) || 
     134             cherokee_buffer_is_empty (&props->entry) ||  
     135             cherokee_buffer_is_empty (&props->footer))) 
     136            return ret_error; 
     137 
     138        /* Parse conditional blocks 
     139         */ 
     140        parse_macros_in_buffer (&props->header, props); 
     141        parse_macros_in_buffer (&props->footer, props); 
     142        parse_macros_in_buffer (&props->entry,  props); 
     143 
     144        return ret_ok; 
     145} 
     146 
     147static void 
     148cherokee_handler_dirlist_props_free (void *props) 
     149{ 
     150        // TODO 
     151        ; 
     152} 
     153 
    70154 
    71155ret_t  
    72 cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_table_t **props) 
    73 { 
    74         ret_t   ret; 
    75         list_t *i; 
     156cherokee_handler_dirlist_configure (cherokee_config_node_t *conf, cherokee_server_t *srv, cherokee_handler_dirlist_props_t **_props) 
     157{ 
     158        ret_t                             ret; 
     159        list_t                           *i; 
     160        cherokee_handler_dirlist_props_t *props; 
     161        char                             *theme      = NULL; 
     162        cherokee_buffer_t                 theme_path = CHEROKEE_BUF_INIT; 
     163 
     164        if (*_props == NULL) { 
     165                CHEROKEE_NEW_STRUCT (n,handler_dirlist_props); 
     166                 
     167                n->props.free  = cherokee_handler_dirlist_props_free; 
     168                n->show_size   = true; 
     169                n->show_date   = true; 
     170                n->show_user   = false; 
     171                n->show_group  = false; 
     172 
     173                cherokee_buffer_init (&n->header); 
     174                cherokee_buffer_init (&n->footer); 
     175                cherokee_buffer_init (&n->entry); 
     176                cherokee_buffer_init (&n->css); 
     177 
     178                INIT_LIST_HEAD (&n->notice_files); 
     179                 
     180                *_props = n; 
     181        } 
     182         
     183        props = *_props; 
    76184 
    77185        cherokee_config_node_foreach (i, conf) { 
    78186                cherokee_config_node_t *subconf = CONFIG_NODE(i); 
    79187 
    80                 ret = cherokee_typed_table_instance (props); 
    81                 if (ret != ret_ok) return ret; 
    82  
    83                 if (equal_buf_str (&subconf->key, "bgcolor") || 
    84                     equal_buf_str (&subconf->key, "text")    || 
    85                     equal_buf_str (&subconf->key, "link")    || 
    86                     equal_buf_str (&subconf->key, "vlink")   || 
    87                     equal_buf_str (&subconf->key, "alink")   || 
    88                     equal_buf_str (&subconf->key, "background")) 
    89                 { 
    90                         ret = cherokee_typed_table_add_str (*props, subconf->key.buf, strdup(subconf->val.buf)); 
    91                         if (ret != ret_ok) return ret; 
    92                          
    93                 } else if (equal_buf_str (&subconf->key, "size")  || 
    94                            equal_buf_str (&subconf->key, "date")  || 
    95                            equal_buf_str (&subconf->key, "owner") || 
    96                            equal_buf_str (&subconf->key, "group")) 
    97                 { 
    98                         ret = cherokee_typed_table_add_str (*props, subconf->key.buf, strdup(subconf->val.buf)); 
    99                         if (ret != ret_ok) return ret; 
    100  
    101                 } else if (equal_buf_str (&subconf->key, "header_file")) { 
    102                         list_t list = LIST_HEAD_INIT(list); 
    103  
    104                         ret = cherokee_config_node_read_list (subconf, NULL, config_add_header_file, &list); 
    105                         if (ret != ret_ok) return ret; 
    106  
    107                         ret = cherokee_typed_table_add_list (*props, subconf->key.buf, &list, free); 
    108                         if (ret != ret_ok) return ret;                   
    109  
    110                 } else if (equal_buf_str (&subconf->key, "show_header_file")) { 
    111                         ret = cherokee_typed_table_add_int (*props, subconf->key.buf, atoi(subconf->val.buf)); 
    112                         if (ret != ret_ok) return ret; 
    113                 }  
    114         } 
    115  
    116         return ret_ok; 
     188                /* Convert the properties 
     189                 */ 
     190                if (equal_buf_str (&subconf->key, "size")) { 
     191                        props->show_size = atoi (subconf->val.buf); 
     192                } else if (equal_buf_str (&subconf->key, "date")) { 
     193                        props->show_date = atoi (subconf->val.buf); 
     194                } else if (equal_buf_str (&subconf->key, "user")) { 
     195                        props->show_user = atoi (subconf->val.buf); 
     196                } else if (equal_buf_str (&subconf->key, "group")) { 
     197                        props->show_group = atoi (subconf->val.buf); 
     198 
     199                } else if (equal_buf_str (&subconf->key, "theme")) { 
     200                        theme = subconf->val.buf; 
     201                 
     202                } else if (equal_buf_str (&subconf->key, "notice_files")) { 
     203                        ret = cherokee_config_node_convert_list (subconf, NULL, &props->notice_files); 
     204                        if (unlikely (ret != ret_ok)) return ret; 
     205                } 
     206        } 
     207 
     208        /* Load the theme 
     209         */ 
     210        if (theme == NULL) 
     211                theme = "default"; 
     212 
     213        ret = cherokee_buffer_add_va (&theme_path, CHEROKEE_THEMEDIR"/%s/", theme); 
     214        if (ret != ret_ok) return ret; 
     215         
     216        ret = load_theme (&theme_path, props); 
     217        if (ret != ret_ok) { 
     218                PRINT_MSG ("Couldn't load theme '%s': %s\n", theme, theme_path.buf); 
     219                return ret; 
     220        } 
     221         
     222        cherokee_buffer_mrproper (&theme_path); 
     223        return ret_ok; 
     224} 
     225 
     226 
     227static cherokee_boolean_t 
     228is_header_file (cherokee_handler_dirlist_t *dhdl, char *filename) 
     229{ 
     230        list_t *i; 
     231 
     232        list_for_each (i, &dhdl->props->notice_files)  
     233        { 
     234                if (strcmp (filename, LIST_ITEM_INFO(i)) == 0) 
     235                        return true; 
     236        } 
     237 
     238        return false; 
    117239} 
    118240 
    119241 
    120242ret_t 
    121 generate_file_entry (DIR *dir, cherokee_buffer_t *path, cherokee_handler_dirlist_t *dhdl, file_entry_t **ret_entry) 
     243generate_file_entry (cherokee_handler_dirlist_t *dhdl, DIR *dir, cherokee_buffer_t *path, file_entry_t **ret_entry) 
    122244{ 
    123245        int            re; 
    …… 
    127249        struct dirent *entry; 
    128250         
    129         /* Get the memory 
    130          */ 
    131251#ifdef _PC_NAME_MAX 
    132252        extra = pathconf(path->buf, _PC_NAME_MAX); 
    …… 
    134254        extra = PATH_MAX; 
    135255#endif 
     256 
     257        /* New object 
     258         */ 
    136259        n = (file_entry_t *) malloc (sizeof(file_entry_t) + path->len + extra + 3); 
    137260        if (unlikely(n == NULL)) return ret_nomem; 
    138261 
    139         /* Read a new directory entry 
    140          */ 
    141         cherokee_readdir (dir, &n->info, &entry); 
    142         if (entry == NULL) return ret_eof; 
    143  
    144         /* Initialization 
    145          */ 
    146262        INIT_LIST_HEAD(&n->list_entry); 
    147263 
    148         /* Build the local path, stat and clean 
    149          */ 
    150         name = (char *)entry->d_name; 
    151         n->name_len = strlen(name); 
    152         cherokee_buffer_add (path, name, n->name_len); 
    153  
    154         /* Check the filename size 
    155          */ 
    156         if (n->name_len > dhdl->longest_filename) 
    157                 dhdl->longest_filename = n->name_len; 
    158  
    159         /* Path 
    160          */ 
    161         re = cherokee_stat (path->buf, &n->stat); 
    162         if (re < 0) { 
     264        for (;;) { 
     265                /* Read a new directory entry 
     266                 */ 
     267                cherokee_readdir (dir, &n->info, &entry); 
     268                if (entry == NULL) { 
     269                        free (n); 
     270                        return ret_eof; 
     271                } 
     272 
     273                name = (char *)entry->d_name; 
     274                n->name_len = strlen(name); 
     275 
     276                /* Skip some files 
     277                 */ 
     278                if ((name[0] == '.') || 
     279                    (name[0] == '#') || 
     280                    (name[n->name_len-1] == '~') || 
     281                    is_header_file (dhdl, name)) 
     282                { 
     283                        continue; 
     284                } 
     285                 
     286                /* Build the local path, stat and clean 
     287                 */ 
     288                cherokee_buffer_add (path, name, n->name_len); 
     289                 
     290                /* Check the filename size 
     291                 */ 
     292                if (n->name_len > dhdl->longest_filename) 
     293                        dhdl->longest_filename = n->name_len; 
     294                 
     295                /* Path  
     296                 */ 
     297                re = cherokee_stat (path->buf, &n->stat); 
     298                if (re < 0) { 
     299                        cherokee_buffer_drop_endding (path, n->name_len); 
     300 
     301                        free (n); 
     302                        return ret_error; 
     303                } 
     304 
     305                /* Clean up and exit 
     306                 */ 
    163307                cherokee_buffer_drop_endding (path, n->name_len); 
    164                 free (n); 
    165  
    166                 return ret_error; 
    167         } 
    168  
    169         /* Clean up and exit 
    170          */ 
    171         cherokee_buffer_drop_endding (path, n->name_len); 
    172  
    173         *ret_entry = n; 
    174         return ret_ok; 
     308 
     309                *ret_entry = n; 
     310                return ret_ok; 
     311        } 
     312 
     313        return ret_eof; 
    175314} 
    176315 
    177316 
    178317ret_t 
    179 cherokee_handler_dirlist_new  (cherokee_handler_t **hdl, void *cnt, cherokee_table_t *properties) 
     318cherokee_handler_dirlist_new  (cherokee_handler_t **hdl, void *cnt, cherokee_handler_props_t *properties) 
    180319{        
    181320        ret_t  ret; 
    …… 
    206345        INIT_LIST_HEAD (&n->dirs); 
    207346 
     347        /* State 
     348         */ 
     349        n->dir_ptr          = NULL; 
     350        n->file_ptr         = NULL; 
     351        n->longest_filename = 0; 
     352        n->serve_css        = false; 
     353 
    208354        /* Choose the sorting key 
    209355         */ 
    210         n->sort = Name_Down; 
     356        n->phase = dirlist_phase_add_header; 
     357        n->sort  = Name_Down; 
    211358        ret = cherokee_table_get (HANDLER_CONN(n)->arguments, "order", (void **) &value); 
    212359        if (ret == ret_ok) { 
    …… 
    219366        } 
    220367 
    221         /* State 
    222          */ 
    223         n->page_header      = false; 
    224         n->dir_ptr          = NULL; 
    225         n->file_ptr         = NULL; 
    226         n->longest_filename = 0; 
     368        ret = cherokee_table_get (HANDLER_CONN(n)->arguments, "css", (void **) &value); 
     369        if (ret == ret_ok) { 
     370                n->serve_css = true; 
     371        } 
    227372 
    228373        /* Properties 
    229374         */ 
    230         n->show_size        = 1; 
    231         n->show_date        = 1; 
    232         n->show_owner       = 0; 
    233         n->show_group       = 0; 
    234          
    235         /* Eyecandy 
    236          */ 
    237         n->bgcolor          = "FFFFFF"; 
    238         n->text             = "000000"; 
    239         n->link             = "0000AA"; 
    240         n->vlink            = "0000CC"; 
    241         n->alink            = "0022EE"; 
    242         n->background       = NULL; 
    243         n->header_file      = NULL; 
    244         n->header_file_ref  = NULL; 
    245         n->build_headers    = true; 
     375        n->props = (cherokee_handler_dirlist_props_t *) properties; 
    246376 
    247377        cherokee_buffer_init (&n->header); 
    248  
    249         /* Read the properties 
    250          */ 
    251         if (properties) { 
    252                 cherokee_typed_table_get_str (properties, "bgcolor", &n->bgcolor); 
    253                 cherokee_typed_table_get_str (properties, "text", &n->text); 
    254                 cherokee_typed_table_get_str (properties, "link", &n->link); 
    255                 cherokee_typed_table_get_str (properties, "vlink", &n->vlink); 
    256                 cherokee_typed_table_get_str (properties, "alink", &n->alink); 
    257                 cherokee_typed_table_get_str (properties, "background", &n->background); 
    258  
    259                 cherokee_typed_table_get_int (properties, "size", &n->show_size); 
    260                 cherokee_typed_table_get_int (properties, "date", &n->show_date); 
    261                 cherokee_typed_table_get_int (properties, "owner", &n->show_owner); 
    262                 cherokee_typed_table_get_int (properties, "group", &n->show_group); 
    263  
    264                 cherokee_typed_table_get_list (properties, "header_file", &n->header_file); 
    265  
    266                 cherokee_typed_table_get_int (properties, "show_header_file", &n->build_headers); 
     378        cherokee_buffer_init (&n->public_dir); 
     379        cherokee_buffer_init (&n->server_software); 
     380 
     381        /* Check the theme 
     382         */ 
     383        if (cherokee_buffer_is_empty (&n->props->header) || 
     384            cherokee_buffer_is_empty (&n->props->entry)  || 
     385            cherokee_buffer_is_empty (&n->props->footer)) 
     386        { 
     387                PRINT_ERROR_S ("The theme is incomplete\n"); 
     388                return ret_error; 
    267389        } 
    268390 
    …… 
    278400 
    279401        cherokee_buffer_mrproper (&dhdl->header); 
     402        cherokee_buffer_mrproper (&dhdl->public_dir); 
     403        cherokee_buffer_mrproper (&dhdl->server_software); 
    280404 
    281405        list_for_each_safe (i, tmp, &dhdl->dirs) { 
    …… 
    319443} 
    320444 
    321 static void 
    322 read_header_file (cherokee_handler_dirlist_t *dhdl) 
    323 { 
    324         ret_t                  ret; 
    325         list_t                *i; 
    326         cherokee_connection_t *conn = HANDLER_CONN(dhdl); 
    327  
    328         list_for_each (i, dhdl->header_file) { 
    329                 cuint_t  filename_len; 
    330                 char    *filename = LIST_ITEM_INFO(i); 
    331  
    332                 filename_len = strlen(filename); 
    333                 cherokee_buffer_clean (&dhdl->header); 
    334                  
    335                 if (filename[0] != '/') { 
    336                         cherokee_buffer_add_buffer (&conn->local_directory, &conn->request);                     /* do   */ 
    337                         cherokee_buffer_add (&conn->local_directory, filename, filename_len); 
    338          
    339                         ret = cherokee_buffer_read_file (&dhdl->header, conn->local_directory.buf); 
    340                          
    341                         cherokee_buffer_drop_endding (&conn->local_directory, conn->request.len + filename_len); /* undo */      
    342                 } else { 
    343                         ret = cherokee_buffer_read_file (&dhdl->header, filename); 
    344                 } 
    345  
    346                 if (ret == ret_ok) { 
    347                         dhdl->header_file_ref = filename; 
    348                         return; 
    349                 } 
    350         } 
    351 } 
    352  
    353  
    354445static int  
    355446cmp_name_down (list_t *a, list_t *b) 
    …… 
    407498 
    408499static void 
    409 list_sort_by_type (list_t *list, cherokee_sort_t sort) 
     500list_sort_by_type (list_t *list, cherokee_dirlist_sort_t sort) 
    410501{ 
    411502        switch (sort) { 
    …… 
    454545                ret_t ret; 
    455546                 
    456                 ret = generate_file_entry (dir, &conn->local_directory, dhdl, &item); 
    457                 if (ret == ret_eof) break; 
    458                 if (ret == ret_error) continue; 
     547                ret = generate_file_entry (dhdl, dir, &conn->local_directory, &item); 
     548                if (ret == ret_eof)  
     549                        break; 
     550                if ((ret == ret_nomem) || 
     551                    (ret == ret_error)) 
     552                        continue; 
    459553 
    460554                if (S_ISDIR(item->stat.st_mode)) { 
    …… 
    481575         */ 
    482576        if (! list_empty(&dhdl->dirs)) { 
    483                 cherokee_sort_t sort = dhdl->sort; 
     577                cherokee_dirlist_sort_t sort = dhdl->sort; 
    484578 
    485579                if (sort == Size_Down) sort = Name_Down; 
    …… 
    491585 
    492586        return ret_ok; 
    493 } 
    494  
    495  
    496  
    497 ret_t 
    498 cherokee_handler_dirlist_init (cherokee_handler_dirlist_t *dhdl) 
    499 { 
    500         ret_t ret; 
    501  
    502         /* The request must end with a slash.. 
    503          */ 
    504         ret = check_request_finish_with_slash (dhdl); 
    505         if (ret != ret_ok) return ret; 
    506  
    507         /* Maybe read the header file 
    508          */ 
    509         if (dhdl->header_file != NULL) { 
    510                 read_header_file (dhdl); 
    511         } 
    512  
    513         /* Build de local request 
    514          */ 
    515         ret = build_file_list (dhdl); 
    516         if (unlikely(ret < ret_ok)) return ret; 
    517          
    518         return ret_ok; 
    519587} 
    520588 
    …… 
    542610 
    543611static ret_t 
    544 render_page_header (cherokee_handler_dirlist_t *dhdl, cherokee_buffer_t *buffer) 
    545 { 
    546         cherokee_connection_t *conn; 
    547         cherokee_icons_t      *icons; 
    548         cherokee_buffer_t      path = CHEROKEE_BUF_INIT; 
    549          
    550 //      CHEROKEE_NEW(path,buffer); 
    551  
    552         conn  = HANDLER_CONN(dhdl); 
    553         icons = HANDLER_SRV(dhdl)->icons; 
    554          
    555         if (dhdl->build_headers) { 
    556                 cherokee_buffer_add_str (buffer, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 3.2 Final//EN\">" CRLF); 
    557          
    558                 /* Step 1: 
    559                  * Build the public path 
    560                  */ 
    561                 build_public_path (dhdl, &path); 
    562          
    563                 /* Add some HTML: title and body begin 
    564                  */ 
    565                 cherokee_buffer_add_str (buffer, "<html><head><title>Index of "); 
    566                 cherokee_buffer_add_buffer (buffer, &path); 
    567                 cherokee_buffer_add_str (buffer, "</title></head><body"); 
    568          
    569                 cherokee_buffer_add_va (buffer, " bgcolor=\"%s\" text=\"%s\" link=\"%s\" vlink=\"%s\" alink=\"%s\"",  
    570                                         dhdl->bgcolor, dhdl->text, dhdl->link, dhdl->vlink, dhdl->alink); 
    571          
    572                 if (dhdl->background) { 
    573                         cherokee_buffer_add_va (buffer, " background=\"%s\"", dhdl->background); 
     612read_notice_file (cherokee_handler_dirlist_t *dhdl) 
     613{ 
     614        ret_t                  ret; 
     615        list_t                *i; 
     616        cherokee_connection_t *conn = HANDLER_CONN(dhdl); 
     617 
     618        list_for_each (i, &dhdl->props->notice_files) { 
     619                cuint_t  filename_len; 
     620                char    *filename = LIST_ITEM_INFO(i); 
     621 
     622                filename_len = strlen(filename); 
     623                cherokee_buffer_clean (&dhdl->header); 
     624                 
     625                if (filename[0] != '/') { 
     626                        cherokee_buffer_add_buffer (&conn->local_directory, &conn->request);                     /* do   */ 
     627                        cherokee_buffer_add (&conn->local_directory, filename, filename_len); 
     628                         
     629                        ret = cherokee_buffer_read_file (&dhdl->header, conn->local_directory.buf); 
     630                        cherokee_buffer_drop_endding (&conn->local_directory, conn->request.len + filename_len); /* undo */ 
     631                } else { 
     632                        ret = cherokee_buffer_read_file (&dhdl->header, filename); 
    574633                } 
    575          
    576                 cherokee_buffer_add_str (buffer, "><h1>Index of "); 
    577                 cherokee_buffer_add_buffer (buffer, &path); 
    578                 cherokee_buffer_add_str (buffer, "</h1>"); 
    579  
     634 
     635                if (ret == ret_ok) 
     636                        break; 
     637        } 
     638 
     639        return ret_ok; 
     640} 
     641 
     642 
     643ret_t 
     644cherokee_handler_dirlist_init (cherokee_handler_dirlist_t *dhdl) 
     645{ 
     646        ret_t                  ret; 
     647        cuint_t                port; 
     648        cherokee_connection_t *conn = HANDLER_CONN(dhdl); 
     649        cherokee_server_t     *srv  = HANDLER_SRV(dhdl); 
     650 
     651        /* The request must end with a slash.. 
     652         */ 
     653        ret = check_request_finish_with_slash (dhdl); 
     654        if (ret != ret_ok) return ret; 
     655         
     656        if (! list_empty (&dhdl->props->notice_files)) { 
     657                ret = read_notice_file (dhdl); 
     658                if (ret != ret_ok) return ret; 
     659        } 
     660 
     661        /* Build de local request 
     662         */ 
     663        ret = build_file_list (dhdl); 
     664        if (unlikely(ret < ret_ok)) return ret; 
     665         
     666        /* Build public dir string 
     667         */ 
     668        ret = build_public_path (dhdl, &dhdl->public_dir); 
     669        if (unlikely (ret != ret_ok)) return ret; 
     670         
     671        /* Server software string 
     672         */ 
     673        if (conn->socket.is_tls == non_TLS) 
     674                port = srv->port; 
     675        else 
     676                port = srv->port_tls; 
     677         
     678        switch (srv->server_token) { 
     679        case cherokee_version_product: 
     680                cherokee_buffer_add_version (&dhdl->server_software, port, ver_full_html); 
     681        case cherokee_version_minor: 
     682        case cherokee_version_minimal: 
     683        case cherokee_version_os: 
     684        case cherokee_version_full: 
     6