Changeset 455

Show
Ignore:
Timestamp:
11/13/06 13:13:07 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r454 r455  
     12006-11-13  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/buffer.c: 
     4        - remove redundant spaces in blank lines; 
     5 
     6        - add a couple of unlikely(pbuf == NULL) 
     7          for failed allocations; 
     8 
     9        - fix realloc() handling in order to avoid a memory leak; 
     10          if realloc returns NULL then the original pointer 
     11          to memory content is not touched and it is still valid 
     12          (no free happens); 
     13          NOTE: I don't think this is a real issue because 
     14          usually it never happens on PCs, anyway as in theory 
     15          it _may_ happen (maybe only on some micro-embedded-system), 
     16          it's better to handle it properly; 
     17 
     18        - remove cherokee_buffer_replace(), 
     19          it looks like a stub function and it is not used by anybody; 
     20 
     21        - optimize cherokee_buffer_replace_string(), 
     22          if substring is not found in "buf" or if resulting length is 0 
     23          then there is no need to do something (copy / alloc memory).   
     24 
     25        * cherokee/sendfile.c: 
     26        - add a new constant MAX_SF_BLK_SIZE 
     27          (max. sendfile block size) 
     28          to limit size of data sent by each sendfile call 
     29          because this can improve a lot things on small 
     30          or old systems (FreeBSD 4.x, Linux 2.2, etc.); 
     31          NOTE: right now default is set to 4 MB 
     32                which should be good even for monster systems 
     33                (i.e. up to 10-100 GB / sec. of disk I/O). 
     34          NOTE: maybe in the near future we will add a new parameter 
     35                in configuration file to set the value 
     36                at runtime / startup; 
     37 
     38        - cherokee_socket_sendfile(): 
     39          - if size of data to be sent is 0 then return 
     40            without calling sendfile; 
     41 
     42          - limit size of data to MAX_SF_BLK_SIZE; 
     43 
     44          - fix FreeBSD return error handling, 
     45            only (re) variable has to be tested for error value, 
     46            return ret_eagain only if errno == EAGAIN && *sent == 0. 
     47         
    1482006-11-08  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    249 

  • cherokee/trunk/cherokee/buffer.c

    r440 r455  
    5252        n->size = 0; 
    5353        n->len  = 0; 
    54             
     54 
    5555        *buf = n; 
    5656        return ret_ok; 
    …… 
    6565                buf->buf = NULL; 
    6666        } 
    67          
     67 
    6868        free (buf);      
    6969        return ret_ok; 
    …… 
    8787                free (buf->buf); 
    8888        } 
    89          
     89 
    9090        return cherokee_buffer_init (buf); 
    9191} 
    …… 
    9494cherokee_buffer_clean (cherokee_buffer_t *buf) 
    9595{ 
    96         if (likely ((buf->buf != NULL) && (buf->len != 0)) ) 
    97         { 
     96        if (likely ((buf->buf != NULL) && (buf->len != 0)) ) { 
    9897                buf->buf[0] = '\0'; 
    9998        } 
    …… 
    154153         */ 
    155154        if (free < (size+1)) { 
    156                 buf->buf = (char *) realloc(buf->buf, buf->size + size - free + 1); 
    157                 if (unlikely (buf->buf == NULL))  
     155                char *pbuf; 
     156                pbuf = (char *) realloc(buf->buf, buf->size + size - free + 1); 
     157                if (unlikely (pbuf == NULL))  
    158158                        return ret_nomem; 
    159  
     159                buf->buf = pbuf; 
    160160                buf->size += size - free + 1; 
    161161        } 
    162             
     162 
    163163        /* Copy  
    164164         */ 
    …… 
    167167        buf->len += size; 
    168168        buf->buf[buf->len] = '\0'; 
    169             
     169 
    170170        return ret_ok; 
    171171} 
    …… 
    250250         */ 
    251251        if (free < (num+1)) { 
    252                 buf->buf = (char *) realloc(buf->buf, buf->size + num - free + 1); 
    253                 return_if_fail (buf->buf, ret_nomem); 
    254  
     252                char *pbuf; 
     253                pbuf = (char *) realloc(buf->buf, buf->size + num - free + 1); 
     254                if (unlikely (pbuf == NULL)) 
     255                        return ret_nomem; 
     256                buf->buf = pbuf; 
    255257                buf->size += num - free + 1; 
    256258        } 
    …… 
    272274        /* Get memory 
    273275         */ 
    274         if (free <= size) { 
    275                 buf->buf = (char *) realloc(buf->buf, buf->size + size - free + 1); 
    276                 return_if_fail (buf->buf, ret_nomem); 
    277                     
     276        if (free < (size+1)) { 
     277                char *pbuf; 
     278                pbuf = (char *) realloc(buf->buf, buf->size + size - free + 1); 
     279                if (unlikely (pbuf == NULL)) 
     280                        return ret_nomem; 
     281                buf->buf = pbuf; 
    278282                buf->size += size - free + 1; 
    279283        } 
    …… 
    284288        buf->len += size; 
    285289        buf->buf[buf->len] = '\0'; 
    286            
     290  
    287291        return ret_ok; 
    288292} 
    …… 
    328332cherokee_buffer_ensure_size (cherokee_buffer_t *buf, size_t size) 
    329333{ 
     334        char *pbuf; 
     335 
    330336        /* Maybe it doesn't need it 
    331337         */ 
    …… 
    337343        if (buf->buf == NULL) { 
    338344                buf->buf = (char *) malloc (size); 
    339                 if (unlikely (buf->buf == NULL)) return ret_nomem; 
     345                if (unlikely (buf->buf == NULL)) 
     346                        return ret_nomem; 
    340347                buf->size = size; 
    341348                return ret_ok; 
    …… 
    344351        /* It already has memory, but it needs more.. 
    345352         */ 
    346         buf->buf = (char *) realloc(buf->buf, size); 
    347         if (unlikely (buf->buf == NULL)) return ret_nomem; 
     353        pbuf = (char *) realloc(buf->buf, size); 
     354        if (unlikely (pbuf == NULL)) 
     355                return ret_nomem; 
     356 
     357        buf->buf = pbuf; 
    348358        buf->size = size; 
    349             
     359 
    350360        return ret_ok; 
    351361} 
    …… 
    394404        char *a      = buffer->buf; 
    395405        int   offset = 0; 
    396          
     406 
    397407        if (buffer->len < 2) { 
    398408                return ret_ok; 
    …… 
    536546        ret = cherokee_buffer_ensure_size (buf, buf->len + info.st_size + 1); 
    537547        if (unlikely(ret != ret_ok)) return ret; 
    538          
     548 
    539549        /* Open the file 
    540550         */ 
    …… 
    551561                return ret_error; 
    552562        } 
    553          
     563 
    554564        /* Close it and exit 
    555565         */ 
    …… 
    594604        cherokee_buffer_add (buf, tmp, len); 
    595605        *ret_size = len; 
    596          
     606 
    597607        return ret_ok; 
    598608} 
    …… 
    623633        char*         ascii_text; 
    624634        unsigned char tmp; 
    625           
     635 
    626636        if ((len == -1) || (buf->len <= len)) { 
    627637                length = buf->len; 
    …… 
    629639                length = len; 
    630640        } 
    631           
     641 
    632642        if (length <= 0) 
    633643                return ret_ok; 
    634          
     644 
    635645        memset(text, 0, 67); 
    636646        for (i=0; i < length; i++) { 
    …… 
    643653                        ascii_text = text + 49; 
    644654                } 
    645                   
     655 
    646656                tmp = buf->buf[i]; 
    647657                sprintf (hex_text, "%02x",  tmp & 0xFF); 
    …… 
    651661                        hex_text++; 
    652662                } 
    653                   
     663 
    654664                if ((tmp > ' ') &&  (tmp < 128)) 
    655665                        *ascii_text = tmp; 
    …… 
    738748                return ret_error; 
    739749        } 
    740          
     750 
    741751        /* Verify if unescaping is needed. 
    742752         */ 
    …… 
    10271037        struct MD5Context context; 
    10281038        unsigned char digest[16]; 
    1029          
     1039 
    10301040        MD5Init (&context); 
    10311041        MD5Update (&context, (md5byte *)buf->buf, buf->len); 
    …… 
    10541064{ 
    10551065        struct MD5Context context; 
    1056          
     1066 
    10571067        cherokee_buffer_ensure_size (encoded, 17); 
    10581068 
    …… 
    11991209 
    12001210ret_t  
    1201 cherokee_buffer_replace (cherokee_buffer_t *buf, char *string1, int len1, char *string2, int len2) 
    1202 { 
    1203         char *p = buf->buf; 
    1204  
    1205         do { 
    1206                 p = strstr(p, string1); 
    1207                 if (p != NULL) { 
    1208                         if (len1 < len2) { 
    1209                                  
    1210                         } else { 
    1211  
    1212                         } 
    1213                 } 
    1214         } while (p); 
    1215  
    1216         return ret_ok; 
    1217 } 
    1218  
    1219  
    1220 ret_t  
    12211211cherokee_buffer_add_chunked (cherokee_buffer_t *buf, char *txt, size_t size) 
    12221212{ 
    12231213        ret_t ret; 
    1224          
     1214 
    12251215        ret = cherokee_buffer_add_va (buf, "0x%x"CRLF, size); 
    12261216        if (unlikely(ret < ret_ok)) return ret_ok; 
    …… 
    12591249        const char *substring_position; 
    12601250 
     1251        /* Verify formal parameters 
     1252         * (those which are not tested should raise a segment violation). 
     1253         */ 
     1254        if (buf->buf == NULL || 
     1255            substring == NULL || substring_length < 1 || 
     1256                replacement == NULL || replacement_length < 0) 
     1257                return ret_deny; 
     1258 
    12611259        /* Calculate the new size 
    12621260         */ 
    …… 
    12711269        }  
    12721270 
     1271        /* If no substring have been found, then return now. 
     1272         */ 
     1273        if (p == buf->buf) 
     1274                return ret_ok; 
     1275 
     1276        /* If resulting length is zero, then return now. 
     1277         */ 
     1278        if (result_length < 1) { 
     1279                buf->buf[0] = '\0'; 
     1280                buf->len = 0; 
     1281                return ret_ok; 
     1282        } 
     1283 
    12731284        /* Take the new memory chunk 
    12741285         */ 
    12751286        result = (char *) malloc (result_length + 1); 
    1276         if (result == NULL) return ret_nomem; 
    1277          
     1287        if (result == NULL) 
     1288                return ret_nomem; 
     1289 
    12781290        /* Build the new string 
    12791291         */ 
    …… 
    13301342        } 
    13311343 
    1332         for (i=0; i<num; i++) { 
     1344        for (i = 0; i < num; i++) { 
    13331345                int len = (buf->buf + buf->len) - p; 
    13341346                memmove(p+1, p, len); 
    13351347                *p = ','; 
    1336                 p+=4; 
     1348                p +=4; 
    13371349                buf->len++; 
    13381350        } 

  • cherokee/trunk/cherokee/socket.c

    r454 r455  
    9595 
    9696 
     97/* Max. sendfile block size (bytes): limiting size of data sent by 
     98 * each sendfile call may improve responsiveness, reduce memory 
     99 * pressure, prevent blocking calls, etc. 
     100 *  
     101 * NOTE: try to reduce block size (down to 64 KB) on small or old 
     102 * systems and see if something improves under heavy load. 
     103 */ 
     104#define MAX_SF_BLK_SIZE         (65536 * 64)    /* limit size of block size */ 
     105 
     106 
    97107ret_t 
    98108cherokee_socket_init (cherokee_socket_t *socket) 
    …… 
    686696                break; 
    687697#endif 
     698#ifdef AF_LOCAL 
     699        case AF_LOCAL: 
     700                memset (&sock->client_addr, 0, sizeof (struct sockaddr_un)); 
     701                break; 
     702#endif           
    688703        default: 
    689704                SHOULDNT_HAPPEN; 
    …… 
    742757 
    743758 
    744 ret_t  
    745 cherokee_socket_listen (cherokee_socket_t *socket, int backlog) 
     759static ret_t 
     760cherokee_bind_local (cherokee_socket_t *sock, cherokee_buffer_t *listen_to) 
    746761{ 
    747762        int re; 
    748763 
    749         re = listen (SOCKET_FD(socket), backlog); 
    750         if (re < 0) return ret_error; 
     764        strncpy (SOCKET_SUN_PATH (socket), listen_to->buf, sizeof(SOCKET_SUN_PATH (socket)) -1); 
     765        sock->client_addr_len = sizeof(SOCKET_ADDR_UNIX(sock)->sun_family) + listen_to->len; 
     766 
     767        mktemp (SOCKET_SUN_PATH (socket)); 
     768 
     769        re = bind (SOCKET_FD(sock), SOCKET_ADDR_UNIX(sock), sock->client_addr_len); 
     770        if (re != 0) return ret_error; 
    751771 
    752772        return ret_ok; 
    …… 
    766786                return cherokee_bind_v6 (sock, port, listen_to); 
    767787#endif 
     788#ifdef AF_LOCAL 
     789        case AF_LOCAL: 
     790                return cherokee_bind_local (sock, listen_to); 
     791#endif 
    768792        default: 
    769793                break; 
    …… 
    772796        SHOULDNT_HAPPEN; 
    773797        return ret_error; 
     798} 
     799 
     800 
     801ret_t  
     802cherokee_socket_listen (cherokee_socket_t *socket, int backlog) 
     803{ 
     804        int re; 
     805 
     806        re = listen (SOCKET_FD(socket), backlog); 
     807        if (re < 0) return ret_error; 
     808 
     809        return ret_ok; 
    774810} 
    775811 
    …… 
    10741110cherokee_socket_sendfile (cherokee_socket_t *socket, int fd, size_t size, off_t *offset, ssize_t *sent) 
    10751111{ 
     1112        /* If there is nothing to send then return now, 
     1113         * this maybe needed in some systems (i.e. *BSD) 
     1114         * because value 0 may have special meanings. 
     1115         */ 
     1116        if (size == 0) 
     1117                return ret_ok; 
     1118 
     1119        /* Limit size of data that has to be sent. 
     1120         */ 
     1121        if (size > MAX_SF_BLK_SIZE) 
     1122                size = MAX_SF_BLK_SIZE; 
     1123 
    10761124#if defined(LINUX_SENDFILE_API) || defined(HAVE_SENDFILE64) 
    10771125 
    …… 
    11031151#elif HAVE_SENDFILE_BROKEN 
    11041152 
    1105         /* Some Linux 2.4 kernels doesn't support sendfile in a LFS 
     1153        /* Some Linux 2.4 kernels don't support sendfile in a LFS 
    11061154         * environment. 
    11071155         */ 
    …… 
    11271175        hdtrl.iov_len  = 0; 
    11281176 
     1177        *sent = 0; 
    11291178 
    11301179        /* FreeBSD sendfile: in_fd and out_fd are reversed 
    …… 
    11451194        }  while (re == -1 && errno == EINTR); 
    11461195 
    1147         if (*sent < 0) { 
    1148                 if (errno == EAGAIN) { 
    1149                         return ret_eagain; 
     1196        if (re == -1) { 
     1197                switch (errno) { 
     1198                case ENOSYS: 
     1199                        return ret_no_sys; 
     1200                case EAGAIN: 
     1201                        if (*sent < 1) 
     1202                                return ret_eagain; 
     1203 
     1204                        /* else it's ok, something has been sent. 
     1205                         */ 
     1206                        break; 
     1207                default: 
     1208                        return ret_error; 
    11501209                } 
    1151                 return ret_error; 
    11521210        } 
    11531211        *offset = *offset + *sent; 
    …… 
    11991257                return ret_no_sys; 
    12001258#else 
    1201                 SOCKET_ADDR_UNIX(socket).sun_family = AF_UNIX; 
    12021259                memset ((char*) SOCKET_SUN_PATH (socket), 0, sizeof (SOCKET_ADDR_UNIX(socket))); 
     1260 
     1261                SOCKET_ADDR_UNIX(socket)->sun_family = AF_UNIX; 
    12031262                strncpy (SOCKET_SUN_PATH (socket), hostname->buf, hostname->len); 
     1263 
    12041264                return ret_ok; 
    12051265#endif 
    …… 
    12171277        if (SOCKET_AF(socket) == AF_UNIX) { 
    12181278#ifndef _WIN32 
    1219                 r = connect (SOCKET_FD(socket), (struct sockaddr *) &SOCKET_ADDR_UNIX(socket), sizeof(SOCKET_ADDR_UNIX(socket))); 
     1279                r = connect (SOCKET_FD(socket), (struct sockaddr *) SOCKET_ADDR_UNIX(socket), sizeof(SOCKET_ADDR_UNIX(socket))); 
    12201280#else 
    12211281                SHOULDNT_HAPPEN;