Changeset 602

Show
Ignore:
Timestamp:
01/13/07 14:40:04 (2 years ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r601 r602  
     12007-01-13  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/buffer.h: 
     4        - added prototype for new function 
     5          cherokee_buffer_add_char(). 
     6 
     7        * cherokee/buffer.c: 
     8        - added new function 
     9          cherokee_buffer_add_char() to add a single char 
     10          to buffer. 
     11 
     12        * cherokee/connection.c: 
     13        - small formatting cleanups; 
     14        - fixed capitalization of header keywords 
     15          (Keep-alive -> Keep-Alive and Close -> close) 
     16          in order to make them to look exactly as written 
     17          in RFC specifications 
     18          (even if header keywords must be read 
     19           in a case insensitive way); 
     20        - substituted a couple of cherokee_buffer_add_str(s) 
     21          with equivalent cherokee_buffer_add_char() calls. 
     22 
     23        * cherokee/nonce.c: 
     24        - substituted a few cherokee_buffer_add_va() 
     25          with equivalent cherokee_buffer_add_*() calls 
     26          (micro speedup). 
     27 
     28        * cherokee/request.c: 
     29        - small cleanups; 
     30        - substituted cherokee_buffer_add(buf, constant_string, len) 
     31          with equivalent cherokee_buffer_add_str() calls; 
     32        - substituted a few cherokee_buffer_add_va() 
     33          with equivalent cherokee_buffer_add_*() calls 
     34          (micro speedup); 
     35        - removed the allocation / deallocation 
     36          of a local new_once buffer in favour of the standard 
     37          THREAD_TMP_BUF1() temporary buffer 
     38          (micro speedup). 
     39 
    1402007-01-11  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    241 

  • cherokee/trunk/cherokee/buffer.c

    r597 r602  
    242242        */ 
    243243        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    244         if (unlikely( newlen >= buf->size )) { 
     244        if (unlikely (newlen >= buf->size)) { 
    245245                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    246246                        return ret_nomem; 
    …… 
    288288        */ 
    289289        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    290         if (unlikely( newlen >= buf->size )) { 
     290        if (unlikely (newlen >= buf->size)) { 
    291291                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    292292                        return ret_nomem; 
    …… 
    322322        */ 
    323323        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    324         if (unlikely( newlen >= buf->size )) { 
     324        if (unlikely (newlen >= buf->size)) { 
    325325                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    326326                        return ret_nomem; 
    …… 
    356356        */ 
    357357        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    358         if (unlikely( newlen >= buf->size )) { 
     358        if (unlikely (newlen >= buf->size)) { 
    359359                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    360360                        return ret_nomem; 
    …… 
    395395        */ 
    396396        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    397         if (unlikely( newlen >= buf->size )) { 
     397        if (unlikely (newlen >= buf->size)) { 
    398398                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    399399                        return ret_nomem; 
    …… 
    434434        */ 
    435435        newlen = buf->len + (int) ((IOS_NUMBUF - 1) - i); 
    436         if (unlikely( newlen >= buf->size )) { 
     436        if (unlikely (newlen >= buf->size)) { 
    437437                if (unlikely (realloc_new_bufsize(buf, newlen)) != ret_ok) 
    438438                        return ret_nomem; 
    …… 
    509509 
    510510 
     511ret_t 
     512cherokee_buffer_add_char (cherokee_buffer_t *buf, char c) 
     513{           
     514        /* Add char (fast path) 
     515         */ 
     516        if (likely (buf->len + 1 < buf->size)) { 
     517                buf->buf[buf->len++] = c; 
     518                buf->buf[buf->len] = '\0'; 
     519                return ret_ok; 
     520        } 
     521 
     522        /* Get memory 
     523         */ 
     524        if (unlikely (realloc_inc_bufsize(buf, 1)) != ret_ok) 
     525                return ret_nomem; 
     526 
     527        /* Add char 
     528         */ 
     529        buf->buf[buf->len++] = c; 
     530        buf->buf[buf->len] = '\0'; 
     531 
     532        return ret_ok; 
     533} 
     534 
     535 
    511536ret_t  
    512537cherokee_buffer_add_char_n (cherokee_buffer_t *buf, char c, int num) 
    …… 
    530555        return ret_ok; 
    531556} 
    532  
    533557 
    534558 
    …… 
    820844         */ 
    821845        ret = cherokee_buffer_ensure_size (buf, buf->len + info.st_size + 1); 
    822         if (unlikely(ret != ret_ok)) 
     846        if (unlikely (ret != ret_ok)) 
    823847                return ret; 
    824848 
    …… 
    10841108         */ 
    10851109        ret = cherokee_buffer_new (maybe_new); 
    1086         if (unlikely(ret != ret_ok)) 
     1110        if (unlikely (ret != ret_ok)) 
    10871111                return ret; 
    10881112 
    10891113        ret = cherokee_buffer_ensure_size (*maybe_new, buf->len + extra + 1); 
    1090         if (unlikely(ret != ret_ok)) 
     1114        if (unlikely (ret != ret_ok)) 
    10911115                return ret; 
    10921116 
    10931117        ret = cherokee_buffer_add_buffer (*maybe_new, buf); 
    1094         if (unlikely(ret != ret_ok)) 
     1118        if (unlikely (ret != ret_ok)) 
    10951119                return ret; 
    10961120 
    …… 
    12991323        cherokee_buffer_ensure_size (buf, 34); 
    13001324 
    1301         for (i=0; i<16; i++) { 
     1325        for (i = 0; i < 16; ++i) { 
    13021326                int tmp; 
    13031327 
    …… 
    13841408        return ret_ok; 
    13851409} 
    1386 #endif 
     1410#endif /* ! CHEROKEE_EMBEDDED */ 
    13871411 
    13881412 
    …… 
    14691493 
    14701494        ret = cherokee_buffer_add_str    (buf, "0x"); 
    1471         if (unlikely(ret < ret_ok)) 
     1495        if (unlikely (ret < ret_ok)) 
    14721496                return ret_ok; 
    14731497 
    14741498        ret = cherokee_buffer_add_ulong16(buf, (culong_t) size); 
    1475         if (unlikely(ret < ret_ok)) 
     1499        if (unlikely (ret < ret_ok)) 
    14761500                return ret_ok; 
    14771501 
    14781502        ret = cherokee_buffer_add_str    (buf, CRLF); 
    1479         if (unlikely(ret < ret_ok)) 
     1503        if (unlikely (ret < ret_ok)) 
    14801504                return ret_ok; 
    14811505 

  • cherokee/trunk/cherokee/buffer.h

    r597 r602  
    7373ret_t cherokee_buffer_add_va_fixed       (cherokee_buffer_t  *buf, char *format, ...); 
    7474ret_t cherokee_buffer_add_va_list        (cherokee_buffer_t  *buf, char *format, va_list args); 
     75ret_t cherokee_buffer_add_char           (cherokee_buffer_t  *buf, char c); 
    7576ret_t cherokee_buffer_add_char_n         (cherokee_buffer_t  *buf, char c, int n); 
    7677ret_t cherokee_buffer_add_buffer         (cherokee_buffer_t  *buf, cherokee_buffer_t *buf2); 

  • cherokee/trunk/cherokee/connection.c

    r597 r602  
    254254        } 
    255255 
    256         if (conn->polling_fd != -1) { 
    257                 close (conn->polling_fd); 
    258                 conn->polling_fd = -1; 
    259         } 
     256       if (conn->polling_fd != -1) { 
     257               close (conn->polling_fd); 
     258               conn->polling_fd = -1; 
     259       } 
    260260 
    261261        cherokee_post_mrproper (&conn->post); 
    …… 
    428428         */ 
    429429        if (conn->auth_type & http_auth_digest) { 
    430                 cherokee_buffer_t new_nonce = CHEROKEE_BUF_INIT; 
     430                cherokee_thread_t *thread = CONN_THREAD(conn); 
     431                cherokee_buffer_t *new_nonce = THREAD_TMP_BUF1(thread); 
    431432 
    432433                cherokee_buffer_ensure_addlen (buffer, 
    …… 
    441442                /* Nonce 
    442443                 */ 
    443                 cherokee_nonce_table_generate (CONN_SRV(conn)->nonces, conn, &new_nonce); 
     444                cherokee_nonce_table_generate (CONN_SRV(conn)->nonces, conn, new_nonce); 
    444445                /* "nonce=\"%s\", " 
    445446                 */ 
    446447                cherokee_buffer_add_str    (buffer, "nonce=\""); 
    447                 cherokee_buffer_add_buffer (buffer, &new_nonce); 
     448                cherokee_buffer_add_buffer (buffer, new_nonce); 
    448449                cherokee_buffer_add_str    (buffer, "\", "); 
    449450                                 
    …… 
    452453                 */ 
    453454                cherokee_buffer_add_str (buffer, "qop=\"auth\", algorithm=\"MD5\""CRLF); 
    454  
    455                 cherokee_buffer_mrproper (&new_nonce); 
    456455        } 
    457456} 
    …… 
    494493 
    495494        } else { 
    496                 cherokee_buffer_add_str (buffer, "Connection: Close"CRLF); 
     495                cherokee_buffer_add_str (buffer, "Connection: close"CRLF); 
    497496        } 
    498497 
    …… 
    12171216         */ 
    12181217        cherokee_buffer_add (&conn->local_directory, pwd.pw_dir, strlen(pwd.pw_dir)); 
    1219         cherokee_buffer_add_str (&conn->local_directory, "/"); 
     1218        cherokee_buffer_add_char   (&conn->local_directory, '/'); 
    12201219        cherokee_buffer_add_buffer (&conn->local_directory, &vsrv->userdir); 
    12211220 
    …… 
    13441343                 */ 
    13451344                cherokee_buffer_add_buffer (&conn->redirect, &conn->request); 
    1346                 cherokee_buffer_add_str    (&conn->redirect, "/"); 
     1345                cherokee_buffer_add_char   (&conn->redirect, '/'); 
    13471346 
    13481347                conn->error_code = http_moved_permanently; 
    …… 
    17971796        cuint_t  ptr_len; 
    17981797 
    1799         /* Look for "Connection: Keep-Alive / Close" 
     1798        /* Look for "Connection: Keep-Alive / close" 
    18001799         */ 
    18011800        ret = cherokee_header_get_known (&conn->header, header_connection, &ptr, &ptr_len); 
    1802         if (ret == ret_ok)  
    1803         { 
     1801        if (ret == ret_ok) { 
     1802 
    18041803                if (strncasecmp (ptr, "close", 5) == 0) { 
    18051804                        conn->keepalive = 0; 

  • cherokee/trunk/cherokee/nonce.c

    r597 r602  
    9494cherokee_nonce_table_generate (cherokee_nonce_table_t *nonces, cherokee_connection_t *conn, cherokee_buffer_t *nonce) 
    9595{ 
    96         cherokee_buffer_t crc = CHEROKEE_BUF_INIT; 
    97  
    9896        /* Generate nonce string 
    9997         */ 
    100         cherokee_buffer_add_va (&crc, "%x", POINTER_TO_INT(conn)); 
    101         cherokee_buffer_add_va (nonce, "%x%x%s", CONN_SRV(conn)->bogo_now, rand(), crc.buf); 
     98        cherokee_buffer_add_ullong16(nonce, (cullong_t) CONN_SRV(conn)->bogo_now); 
     99        cherokee_buffer_add_ulong16 (nonce, (culong_t) rand()); 
     100        cherokee_buffer_add_ulong16 (nonce, (culong_t) POINTER_TO_INT(conn)); 
     101 
     102        /* Compute MD5 and overwrite buffer content without reallocating it ! 
     103         */ 
    102104        cherokee_buffer_encode_md5_digest (nonce); 
    103105 
    …… 
    108110        CHEROKEE_MUTEX_UNLOCK (&nonces->access); 
    109111 
    110         /* Clean up 
     112        /* Return 
    111113         */ 
    112         cherokee_buffer_mrproper (&crc); 
    113114        return ret_ok; 
    114115} 

  • cherokee/trunk/cherokee/request.c

    r597 r602  
    8181        cherokee_url_t *url = REQUEST_URL(request); 
    8282 
    83         /* 100 bytes is enought for a small header 
     83        /* 200 bytes should be enough for a small header 
    8484         */ 
    85         cherokee_buffer_ensure_size (buf, 100); 
     85        cherokee_buffer_ensure_size (buf, 200); 
    8686 
    8787        /* Add main request line:  
    …… 
    9090        switch (request->method) { 
    9191        case http_get: 
    92                 cherokee_buffer_add (buf, "GET ", 4);                  
     92                cherokee_buffer_add_str (buf, "GET ");                 
    9393                break; 
    9494        case http_post: 
    95                 cherokee_buffer_add (buf, "POST ", 5);                 
     95                cherokee_buffer_add_str (buf, "POST ");                
    9696                break; 
    9797        case http_head: 
    98                 cherokee_buffer_add (buf, "HEAD ", 5);                 
     98                cherokee_buffer_add_str (buf, "HEAD ");                
    9999                break; 
    100100        case http_put: 
    101                 cherokee_buffer_add (buf, "PUT ", 4);                  
     101                cherokee_buffer_add_str (buf, "PUT ");                 
    102102                break; 
    103103        default: 
    …… 
    124124         */ 
    125125        if (REQUEST_VERSION(request) == http_version_11) { 
    126                 cherokee_buffer_add (buf, "Host: ", 6); 
     126                cherokee_buffer_add_str    (buf, "Host: "); 
    127127                cherokee_buffer_add_buffer (buf, URL_HOST(url)); 
    128                 cherokee_buffer_add_str (buf, CRLF); 
     128                cherokee_buffer_add_str    (buf, CRLF); 
    129129        } 
    130130 
    …… 
    132132         */ 
    133133        if (request->post_len != 0) { 
    134  
    135                 cherokee_buffer_add_va (buf, "Content-Length: "FMT_OFFSET CRLF, request->post_len); 
     134                /* "Content-Length: " FMT_OFFSET CRLF, request->post_len; 
     135                 */ 
     136                cherokee_buffer_add_str     (buf, "Content-Length: "); 
     137                cherokee_buffer_add_ullong10(buf, (cullong_t) request->post_len); 
     138                cherokee_buffer_add_str     (buf, CRLF); 
    136139        } 
    137140         
    …… 
    139142         */ 
    140143        if (REQUEST_KEEPALIVE(request)) { 
    141                 cherokee_buffer_add_str (buf, "Connection: Keep-alive"CRLF);  
     144                cherokee_buffer_add_str (buf, "Connection: Keep-Alive"CRLF);  
    142145        } else { 
    143                 cherokee_buffer_add_str (buf, "Connection: Close"CRLF);  
     146                cherokee_buffer_add_str (buf, "Connection: close"CRLF);  
    144147        } 
    145148 
    …… 
    147150         */ 
    148151        if (!cherokee_buffer_is_empty(&url->user) || 
    149             !cherokee_buffer_is_empty(&url->passwd))  
    150         { 
     152            !cherokee_buffer_is_empty(&url->passwd)) { 
     153 
    151154                cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; 
    152155 
    …… 
    175178cherokee_request_header_add_header (cherokee_request_header_t *request, char *ptr, cuint_t len) 
    176179{ 
    177         cherokee_buffer_ensure_size (&request->extra_headers, request->extra_headers.len + len + 2); 
     180        cherokee_buffer_ensure_addlen (&request->extra_headers, len + CSZLEN(CRLF)); 
    178181        cherokee_buffer_add (&request->extra_headers, ptr, len); 
    179         cherokee_buffer_add (&request->extra_headers, CRLF, 2); 
     182        cherokee_buffer_add_str (&request->extra_headers, CRLF); 
    180183 
    181184        return ret_ok;