Changeset 587

Show
Ignore:
Timestamp:
01/05/07 14:11:49 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r586 r587  
     12007-01-05  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/buffer.c:  
     4        - cleanups, one instruction per line, 
     5          put each "return xxx;" on its own line; 
     6 
     7        - cleanups, remove unneeded braces { } when 
     8          there is only one instruction after an if; 
     9 
     10        - cherokee_buffer_read_from_fd(), 
     11          remove the usage of the temporary local buffer, 
     12          declared as char tmp[size+1];  this has the following 
     13          advantages: 
     14          - as "size+1" is not a constant the change restores 
     15            pure C language rules (i.e. no gcc / C++ extensions); 
     16          - data is read directly into destination buf, 
     17            avoiding a data copy; 
     18            NOTE: for best performances caller should pass an 
     19                  empty buffer (where buf->buf address 
     20                  is aligned on a page boundary or 
     21                  at least on a sizeof(int)); 
     22 
     23        - cherokee_buffer_read_from_fd(), 
     24          add EWOULDBLOCK for those rare OS where it is different 
     25          from EAGAIN; 
     26 
     27        - cherokee_buffer_add_chunked(), 
     28          substitute slow cherokee_buffer_add_va() with 
     29          equivalent fast cherokee_buffer_add_*() calls; 
     30          NOTE: this is a win because chunks can be 
     31                as small as 1 - 8 KB and 
     32                so at Gigabits speed this improvement matters; 
     33         
    1342007-01-04  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    235 

  • cherokee/trunk/cherokee/Makefile.am

    r529 r587  
    849849server.h \ 
    850850server.c \ 
     851virtual_server_list.h \ 
     852virtual_server_list.c \ 
    851853virtual_server.h \ 
    852854virtual_server.c \ 

  • cherokee/trunk/cherokee/buffer.c

    r580 r587  
    809809         */ 
    810810        r = stat (filename, &info); 
    811         if (r != 0) return ret_error; 
     811        if (r != 0) 
     812                return ret_error; 
    812813 
    813814        /* Is a regular file? 
    814815         */ 
    815         if (S_ISREG(info.st_mode) == 0) { 
     816        if (S_ISREG(info.st_mode) == 0) 
    816817                return ret_error; 
    817         } 
    818818 
    819819        /* Maybe get memory 
    820820         */ 
    821821        ret = cherokee_buffer_ensure_size (buf, buf->len + info.st_size + 1); 
    822         if (unlikely(ret != ret_ok)) return ret; 
     822        if (unlikely(ret != ret_ok)) 
     823                return ret; 
    823824 
    824825        /* Open the file 
    825826         */ 
    826827        f = open (filename, CHE_O_READ); 
    827         if (f < 0) return ret_error; 
     828        if (f < 0) 
     829                return ret_error; 
    828830 
    829831        /* Read the content 
    …… 
    852854{ 
    853855        int  len; 
    854         char tmp[size+1]; 
    855  
    856         len = read (fd, tmp, size); 
     856 
     857        /* Ensure there is enough space in buffer 
     858         * NOTE: usually the caller should have already allocated 
     859         *       enough space for the buffer, so this is a security measure 
     860         */ 
     861        cherokee_buffer_ensure_addlen(buf, size); 
     862 
     863        /* Read data at the end of the buffer 
     864         */ 
     865        len = read (fd, &(buf->buf[buf->len]), size); 
    857866        if (len < 0) { 
    858867                /* On error 
    …… 
    861870                case EINTR:      return ret_eagain; 
    862871                case EAGAIN:     return ret_eagain; 
     872#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN) 
     873                case EWOULDBLOCK:return ret_eagain; 
     874#endif 
    863875                case EPIPE:      return ret_eof; 
    864876                case ECONNRESET: return ret_eof; 
    …… 
    875887        } 
    876888 
    877         /* Add readed information 
    878          */ 
    879         cherokee_buffer_add (buf, tmp, len); 
     889        /* Add readed length, terminate buffer and return 
     890         */ 
    880891        *ret_size = len; 
     892        buf->len += len; 
     893 
     894        buf->buf[buf->len] = '\0'; 
    881895 
    882896        return ret_ok; 
    …… 
    983997#define hex2dec_m2(c1, c2)      ( hex2dec_m(c1) * 16 + hex2dec_m(c2)  ) 
    984998 
    985         if (unlikely (buffer->buf == NULL)) { 
     999        if (unlikely (buffer->buf == NULL)) 
    9861000                return ret_error; 
    987         } 
    9881001 
    9891002        /* Verify if unescaping is needed. 
    …… 
    10711084         */ 
    10721085        ret = cherokee_buffer_new (maybe_new); 
    1073         if (unlikely(ret != ret_ok)) return ret; 
     1086        if (unlikely(ret != ret_ok)) 
     1087                return ret; 
    10741088 
    10751089        ret = cherokee_buffer_ensure_size (*maybe_new, buf->len + extra + 1); 
    1076         if (unlikely(ret != ret_ok)) return ret; 
     1090        if (unlikely(ret != ret_ok)) 
     1091                return ret; 
    10771092 
    10781093        ret = cherokee_buffer_add_buffer (*maybe_new, buf); 
    1079         if (unlikely(ret != ret_ok)) return ret; 
     1094        if (unlikely(ret != ret_ok)) 
     1095                return ret; 
    10801096 
    10811097        buf = *maybe_new; 
    …… 
    12161232         */ 
    12171233        ret = cherokee_buffer_ensure_size (&new_buf, (buf->len+4)*4/3 + 1); 
    1218         if (unlikely (ret != ret_ok)) return ret; 
     1234        if (unlikely (ret != ret_ok)) 
     1235                return ret; 
    12191236 
    12201237        /* Encode 
    …… 
    14511468        ret_t ret; 
    14521469 
    1453         ret = cherokee_buffer_add_va (buf, "0x%x"CRLF, size); 
    1454         if (unlikely(ret < ret_ok)) return ret_ok; 
     1470        ret = cherokee_buffer_add_str    (buf, "0x"); 
     1471        if (unlikely(ret < ret_ok)) 
     1472                return ret_ok; 
     1473 
     1474        ret = cherokee_buffer_add_ulong16(buf, (culong_t) size); 
     1475        if (unlikely(ret < ret_ok)) 
     1476                return ret_ok; 
     1477 
     1478        ret = cherokee_buffer_add_str    (buf, CRLF); 
     1479        if (unlikely(ret < ret_ok)) 
     1480                return ret_ok; 
    14551481 
    14561482        return cherokee_buffer_add (buf, txt, size); 
    …… 
    14631489        return cherokee_buffer_add_chunked (buf, buf2->buf, buf2->len); 
    14641490} 
     1491 
    14651492 
    14661493char   
    14671494cherokee_buffer_end_char (cherokee_buffer_t *buf) 
    14681495{ 
    1469         if ((buf->buf == NULL) || (buf->len <= 0)) { 
     1496        if ((buf->buf == NULL) || (buf->len <= 0)) 
    14701497                return '\0'; 
    1471         } 
    14721498 
    14731499        return buf->buf[buf->len-1]; 

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

    r557 r587  
    5757#include "config_node.h" 
    5858#include "version.h" 
     59#include "list_wildcards.h" 
    5960 
    6061 
    …… 
    7778        /* Virtual servers 
    7879         */ 
    79         cherokee_list_t            vservers; 
    80         cherokee_table_t           vservers_ref; 
     80//      cherokee_list_t            vservers; 
     81//      cherokee_table_t           vservers_ref; 
     82        cherokee_list_wildcards_t *vservers; 
     83        cherokee_list_t            vservers_list; 
    8184        cherokee_virtual_server_t *vserver_default; 
    8285         

  • cherokee/trunk/cherokee/server.c

    r557 r587  
    213213         */ 
    214214        INIT_LIST_HEAD (&n->vservers); 
    215  
    216         cherokee_table_init (&n->vservers_ref); 
     215        INIT_LIST_HEAD (&n->vservers_list); 
     216 
     217//      cherokee_table_init (&n->vservers_ref); 
    217218 
    218219        cherokee_virtual_server_new (&n->vserver_default, n); 
    …… 
    278279        cherokee_list_t *i, *j; 
    279280 
    280         list_for_each_safe (i, j, &srv->vservers) { 
     281        list_for_each_safe (i, j, &srv->vservers_list) { 
    281282                cherokee_virtual_server_free (VSERVER(i)); 
    282283        } 
    283284 
    284         cherokee_table_mrproper (&srv->vservers_ref); 
     285         
     286        cherokee_list_wildcards_clean (&srv->vservers, cherokee_virtual_server_free); 
     287//      cherokee_table_mrproper (&srv->vservers_ref); 
    285288} 
    286289 
    …… 
    783786 
    784787static void 
    785 for_each_vserver_init_tls_func (const char *key, void *value) 
     788vserver_init_tls (cherokee_virtual_server_t *vserver) 
    786789{ 
    787790        ret_t ret; 
    788         cherokee_virtual_server_t *vserver = VSERVER(value); 
     791        = VSERVER(value); 
    789792 
    790793        ret = cherokee_virtual_server_init_tls (vserver); 
    …… 
    810813{ 
    811814#ifdef HAVE_TLS 
    812         ret_t ret; 
     815        ret_t   ret; 
     816        list_t *i; 
    813817 
    814818        /* Initialize the server TLS socket 
    …… 
    827831        } 
    828832 
    829         cherokee_table_foreach (&srv->vservers_ref, for_each_vserver_init_tls_func); 
     833        list_for_each (i, &srv->vservers) { 
     834                vserver_init_tls (LIST_WILDCARDS_ENTRY(i)->value); 
     835        } 
     836//      cherokee_table_foreach (&srv->vservers_ref, for_each_vserver_init_tls_func); 
    830837#endif 
    831838 
    …… 
    920927 
    921928        if (srv->tls_enabled == false) { 
    922                 ret = cherokee_table_while (&srv->vservers_ref, while_vserver_check_tls_func, NULL, NULL, NULL); 
    923                 srv->tls_enabled = (ret == ret_ok); 
     929                list_t                    *i; 
     930                cherokee_virtual_server_t *vsrv; 
     931 
     932                list_for_each (i, &srv->vservers) { 
     933                        vsrv = LIST_WILDCARDS_ENTRY(i)->value; 
     934 
     935                        ret = cherokee_virtual_server_have_tls (vsrv); 
     936                        if (ret == ret_ok)  
     937                                srv->tls_enabled = true; 
     938                } 
     939//              ret = cherokee_table_while (&srv->vservers_ref, while_vserver_check_tls_func, NULL, NULL, NULL); 
     940//              srv->tls_enabled = (ret == ret_ok); 
    924941        } 
    925942 
    …… 
    10001017 
    10011018 
    1002 static void 
    1003 flush_vserver (const char *key, void *value) 
    1004 { 
    1005         /* There's no logger in this virtual server 
    1006         */ 
    1007         if ((value == NULL) || (VSERVER_LOGGER(value) == NULL)) 
    1008                 return; 
    1009  
    1010         cherokee_logger_flush (VSERVER_LOGGER(value)); 
    1011 } 
     1019/* static void */ 
     1020/* flush_vserver (const char *key, void *value) */ 
     1021/* { */ 
     1022/*      /\* There's no logger in this virtual server */ 
     1023/*      *\/ */ 
     1024/*      if ((value == NULL) || (VSERVER_LOGGER(value) == NULL)) */ 
     1025/*              return; */ 
     1026 
     1027/*      cherokee_logger_flush (VSERVER_LOGGER(value)); */ 
     1028/* } */ 
    10121029 
    10131030 
    …… 
    10151032flush_logs (cherokee_server_t *srv) 
    10161033{ 
     1034        list_t                    *i; 
     1035        cherokee_virtual_server_t *vsrv; 
     1036 
    10171037        flush_vserver (NULL, srv->vserver_default); 
    1018         cherokee_table_foreach (&srv->vservers_ref, flush_vserver); 
     1038//      cherokee_table_foreach (&srv->vservers_ref, flush_vserver); 
     1039 
     1040        list_for_each (i, &srv->vservers) { 
     1041                vsrv = LIST_WILDCARDS_ENTRY(i)->value; 
     1042 
     1043                if (VSERVER_LOGGER(vsrv)) { 
     1044                        cherokee_logger_flush (VSERVER_LOGGER(vsrv)); 
     1045                } 
     1046        } 
    10191047} 
    10201048 
    …… 
    12781306                if (ret != ret_ok) return ret; 
    12791307 
    1280                 cherokee_list_add (LIST(vsrv), &srv->vservers); 
     1308                cherokee_list_add (LIST(vsrv), &srv->vservers_list); 
    12811309 
    12821310                param[0] = srv;