Changeset 606

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

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r603 r606  
     12007-01-14  A.D.F  <adefacc@tin.it> 
     2 
     3        * cherokee/buffer.h: 
     4        - changed prototypes of: 
     5          - cherokee_buffer_encode_base64(); 
     6          - cherokee_buffer_encode_sha1_base64(); 
     7          - cherokee_buffer_encode_hex(); 
     8          to add a second destination buffer in order 
     9          to avoid unneeded allocations / reallocations. 
     10 
     11        * cherokee/buffer.c: 
     12        - added a second parameter to: 
     13          - cherokee_buffer_encode_base64(); 
     14          - cherokee_buffer_encode_sha1_base64(); 
     15          - cherokee_buffer_encode_hex(). 
     16 
     17        * cherokee/downloader.h: 
     18        - changed prototype of cherokee_downloader_step() 
     19          in order to pass two temporary buffers; 
     20 
     21        * cherokee/downloader.c: 
     22        - changed cherokee_downloader_step() in order 
     23          to use two temporary buffers to avoid 
     24          allocations / reallocations when handling buffers 
     25          in called functions 
     26          (i.e. cherokee_request_header_build_string()); 
     27 
     28        * cherokee/handler_proxy.h: 
     29        - added new macros; 
     30 
     31        * cherokee/handler_proxy.c: 
     32        - passed two temporary buffers to cherokee_downloader_step(); 
     33 
     34        * cherokee/request.h: 
     35        - changed prototype of cherokee_request_header_build_string(); 
     36 
     37        * cherokee/request.c: 
     38        - cherokee_request_header_build_string(). 
     39          now it uses two permanent temporary buffers in order 
     40          to avoid reallocations. 
     41 
     42        * cherokee/admin_client.c: 
     43        - sparse fixes to improve readability and performances 
     44          (new two temporary buffers for cherokee_downloader_step()); 
     45 
     46        * cherokee/handler_common.c: 
     47        - use THREAD_TMP_BUF[12]() to avoid reallocations; 
     48 
    1492007-01-13  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    250 

  • cherokee/trunk/cherokee/admin_client.c

    r597 r606  
    3535 
    3636typedef enum { 
    37         phase_init, 
    38         phase_stepping, 
    39         phase_finished 
    40 } phase_t; 
     37        admin_phase_init, 
     38        admin_phase_stepping, 
     39        admin_phase_finished 
     40} admin_phase_t; 
    4141 
    4242 
    4343struct cherokee_admin_client { 
     44        cherokee_post_t          *post; 
    4445        cherokee_buffer_t        *url_ref; 
    4546        cherokee_buffer_t         request; 
    4647        cherokee_buffer_t         reply; 
    47  
    48         phase_t                   phase; 
     48        cherokee_buffer_t         tmp1; 
     49        cherokee_buffer_t         tmp2; 
     50 
     51        admin_phase_t             phase; 
    4952        cherokee_fdpoll_t        *poll_ref; 
    5053        cherokee_downloader_t     downloader; 
    …… 
    6265        /* Init 
    6366         */ 
    64         n->phase        = phase_init; 
     67        n->phase        = admin_phase_init; 
    6568 
    6669        n->poll_ref     = NULL; 
    6770        n->url_ref      = NULL; 
     71        n->post         = NULL; 
    6872 
    6973        cherokee_downloader_init (&n->downloader); 
    7074        cherokee_buffer_init (&n->request); 
    7175        cherokee_buffer_init (&n->reply); 
     76        cherokee_buffer_init (&n->tmp1); 
     77        cherokee_buffer_init (&n->tmp2); 
     78 
     79        cherokee_buffer_ensure_size(&n->tmp1, 512); 
     80        cherokee_buffer_ensure_size(&n->tmp2, 512); 
    7281 
    7382        /* Return the object 
    …… 
    8392        cherokee_buffer_mrproper (&admin->request); 
    8493        cherokee_buffer_mrproper (&admin->reply); 
     94        cherokee_buffer_mrproper (&admin->tmp1); 
     95        cherokee_buffer_mrproper (&admin->tmp2); 
    8596 
    8697        cherokee_downloader_mrproper (&admin->downloader); 
    …… 
    96107        cherokee_admin_client_t *admin = _param; 
    97108 
    98         admin->phase = phase_finished; 
     109        admin->phase = admin_phase_finished; 
    99110        return ret_ok; 
    100111} 
    …… 
    107118        cherokee_downloader_t *downloader = &admin->downloader; 
    108119 
    109         admin->phase    = phase_init; 
     120        admin->phase    = admin_phase_init; 
    110121 
    111122        admin->poll_ref = poll; 
    …… 
    160171        cherokee_buffer_clean (&admin->request); 
    161172        cherokee_buffer_clean (&admin->reply); 
    162  
    163         admin->phase = phase_init; 
     173        cherokee_buffer_clean (&admin->tmp1); 
     174        cherokee_buffer_clean (&admin->tmp2); 
     175 
     176        admin->phase = admin_phase_init; 
    164177        return ret_ok; 
    165178} 
    …… 
    174187        /* Has it finished? 
    175188         */ 
    176         if (admin->phase == phase_finished)  
     189        if (admin->phase == admin_phase_finished)  
    177190                return ret_ok; 
    178191 
    179192        /* Sanity check 
    180193         */ 
    181         if (admin->phase != phase_stepping)  
     194        if (admin->phase != admin_phase_stepping)  
    182195                return ret_error; 
    183196 
    184197        /* It's stepping 
    185198         */ 
    186         ret = cherokee_downloader_step (downloader); 
     199        ret = cherokee_downloader_step (downloader, &admin->tmp1, &admin->tmp2); 
    187200        switch (ret) { 
    188201        case ret_eof: 
    …… 
    210223        cherokee_downloader_reuse (downloader);  
    211224        cherokee_downloader_set_url (downloader, admin->url_ref);  
     225        /* Fixme 
    212226        cherokee_downloader_post_set (downloader, &admin->request);  
    213  
    214         admin->phase = phase_stepping; 
     227         */ 
     228        cherokee_downloader_post_set (downloader, &admin->post);  
     229 
     230        admin->phase = admin_phase_stepping; 
    215231} 
    216232 
    …… 
    237253 
    238254        switch (admin->phase) { 
    239         case phase_init: 
     255        case admin_phase_init: 
    240256                conf_request_func (admin, argument); 
    241257                return ret_eagain; 
    242         case phase_stepping: 
     258        case admin_phase_stepping: 
    243259                ret = cherokee_admin_client_internal_step (admin); 
    244260                return ret; 
    245         case phase_finished: 
     261        case admin_phase_finished: 
    246262                return ret_ok; 
    247263        default: 

  • cherokee/trunk/cherokee/buffer.c

    r602 r606  
    12401240 
    12411241 
    1242 ret_t  
    1243 cherokee_buffer_encode_base64 (cherokee_buffer_t *buf) 
     1242/* Encode base64 from source (buf) to destination (encoded). 
     1243 * NOTE: resulting (encoded) content is always longer than source (buf). 
     1244 * Source (buf) is not touched (rewritten or reallocated). 
     1245 */ 
     1246ret_t  
     1247cherokee_buffer_encode_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) 
    12441248{ 
    12451249        cuchar_t         *in; 
    …… 
    12481252        int               i, j; 
    12491253        cuint_t           inlen   = buf->len; 
    1250         cherokee_buffer_t new_buf = CHEROKEE_BUF_INIT; 
    1251                  
     1254 
    12521255        static const char base64tab[]= 
    12531256                "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 
    …… 
    12551258        /* Get memory 
    12561259         */ 
    1257         ret = cherokee_buffer_ensure_size (&new_buf, (buf->len+4)*4/3 + 1); 
     1260        ret = cherokee_buffer_ensure_size (encoded, (buf->len+4)*4/3 + 1); 
    12581261        if (unlikely (ret != ret_ok)) 
    12591262                return ret; 
    12601263 
    1261         /* Encode 
     1264        /* Cleanup destination buffer 
     1265         */ 
     1266        cherokee_buffer_clean (encoded); 
     1267 
     1268        /* Encode source to destination 
    12621269         */ 
    12631270        in  = (cuchar_t *) buf->buf; 
    1264         out = (cuchar_t *) new_buf.buf; 
     1271        out = (cuchar_t *) encoded->buf; 
    12651272 
    12661273        for (i=0, j=0; i < inlen; i += 3) { 
    …… 
    12871294 
    12881295        out[j]  = '\0'; 
    1289         new_buf.len = j; 
    1290  
    1291         /* Set the encoded string 
    1292          */ 
    1293         free (buf->buf); 
    1294  
    1295         buf->buf  = new_buf.buf; 
    1296         buf->len  = new_buf.len;         
    1297         buf->size = new_buf.size; 
     1296        encoded->len = j; 
    12981297 
    12991298        return ret_ok; 
    …… 
    13581357 
    13591358#ifndef CHEROKEE_EMBEDDED 
     1359 
     1360/* Encode sha1, source buffer (buf) is not touched, 
     1361 * whereas destination buffer (encoded) is overwritten 
     1362 * but possibly not reallocated. 
     1363 */ 
    13601364ret_t  
    13611365cherokee_buffer_encode_sha1 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) 
    …… 
    13761380 
    13771381 
    1378 ret_t  
    1379 cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf)  
    1380 { 
    1381         cuint_t           ntmp; 
    1382         char             *ctmp; 
    1383         cherokee_buffer_t encoded = CHEROKEE_BUF_INIT; 
    1384  
    1385         cherokee_buffer_ensure_size (&encoded, (SHA1_DIGEST_SIZE * 2) + 1);      
    1386  
    1387         cherokee_buffer_encode_sha1 (buf, &encoded); 
    1388         cherokee_buffer_encode_base64 (&encoded); 
    1389  
    1390         /* Swap buffers 
    1391          */ 
    1392         ctmp = buf->buf; 
    1393         buf->buf = encoded.buf; 
    1394         encoded.buf = ctmp; 
    1395  
    1396         ntmp = buf->len; 
    1397         buf->len = encoded.len; 
    1398         encoded.len = ntmp; 
    1399  
    1400         ntmp = buf->size; 
    1401         buf->size = encoded.size; 
    1402         encoded.size = ntmp; 
    1403  
    1404         /* Clean and return 
    1405          */ 
    1406         cherokee_buffer_mrproper (&encoded); 
     1382/* Encode sha1 in base64, both source (buf) and destination (encoded) 
     1383 * buffers are overwritten, but possibly not reallocated. 
     1384 */ 
     1385ret_t  
     1386cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t *buf, cherokee_buffer_t *encoded)  
     1387{ 
     1388        /* Prepare destination buffer 
     1389         */ 
     1390        cherokee_buffer_ensure_size (encoded, (SHA1_DIGEST_SIZE * 2) + 1);       
     1391        cherokee_buffer_clean (encoded); 
     1392 
     1393        /* Encode sha1 + base64 
     1394         */ 
     1395        cherokee_buffer_encode_sha1 (buf, encoded); 
     1396        cherokee_buffer_encode_base64 (encoded, buf); 
     1397 
     1398        /* Copy result to destination buffer 
     1399         */ 
     1400        cherokee_buffer_clean (encoded); 
     1401        cherokee_buffer_add_buffer (encoded, buf); 
    14071402 
    14081403        return ret_ok; 
    …… 
    14111406 
    14121407 
    1413 ret_t  
    1414 cherokee_buffer_encode_hex (cherokee_buffer_t *buf) 
    1415 { 
    1416         unsigned int  i; 
    1417         unsigned char j; 
    1418         char *new_buf; 
    1419  
    1420         new_buf = (char *) malloc((buf->len * 2)+1); 
    1421         if (unlikely (new_buf == NULL)) { 
    1422                return ret_error; 
    1423         } 
    1424  
    1425         for (i = 0; i < buf->len; i++) { 
    1426                j = (buf->buf[i] >> 4) & 0xf; 
    1427                if (j <= 9) 
    1428                        new_buf[i*2] = (j + '0'); 
    1429                else 
    1430                         new_buf[i*2] = (j + 'a' - 10); 
    1431  
    1432                j = buf->buf[i] & 0xf; 
    1433                if (j <= 9) 
    1434                        new_buf[i*2+1] = (j + '0'); 
    1435                 else 
    1436                        new_buf[i*2+1] = (j + 'a' - 10); 
    1437         } 
    1438  
    1439         new_buf[buf->len*2] = '\0'; 
    1440  
    1441         free (buf->buf); 
    1442  
    1443         buf->len *= 2; 
    1444         buf->size = buf->len + 1; 
    1445         buf->buf  = new_buf; 
     1408/* Encode in hexadecimal characters, source buffer (buf) is not touched, 
     1409 * whereas destination buffer (encoded) is overwritten 
     1410 * but possibly not reallocated. 
     1411 */ 
     1412ret_t  
     1413cherokee_buffer_encode_hex (cherokee_buffer_t *buf, cherokee_buffer_t *encoded) 
     1414{ 
     1415        cuchar_t        *in; 
     1416        cuchar_t        *out; 
     1417        cuint_t         j; 
     1418        cuint_t         i; 
     1419        cuint_t         inlen = buf->len; 
     1420 
     1421        /* Prepare destination buffer 
     1422        */ 
     1423        cherokee_buffer_ensure_size (encoded, (inlen * 2 + 1));         
     1424        cherokee_buffer_clean (encoded); 
     1425 
     1426        /* Encode source to destination 
     1427        */ 
     1428        in  = (cuchar_t *) buf->buf; 
     1429        out = (cuchar_t *) encoded->buf; 
     1430 
     1431        for (i = 0; i != inlen; ++i) { 
     1432               j = ( (*in >> 4) & 0xf ); 
     1433                *out++ = (cuchar_t) TO_HEX(j); 
     1434 
     1435                j =   (*in++ & 0xf); 
     1436               *out++ = (cuchar_t) TO_HEX(j); 
     1437        } 
     1438 
     1439        *out = '\0'; 
     1440        encoded->len = (int) (inlen * 2); 
    14461441 
    14471442        return ret_ok; 

  • cherokee/trunk/cherokee/buffer.h

    r602 r606  
    108108 
    109109crc_t cherokee_buffer_crc32              (cherokee_buffer_t  *buf); 
    110 ret_t cherokee_buffer_encode_base64      (cherokee_buffer_t  *buf); 
     110ret_t cherokee_buffer_encode_base64      (cherokee_buffer_t  *buf, cherokee_buffer_t *encoded); 
    111111ret_t cherokee_buffer_decode_base64      (cherokee_buffer_t  *buf); 
    112112ret_t cherokee_buffer_encode_md5         (cherokee_buffer_t  *buf, cherokee_buffer_t *encoded); 
    113113ret_t cherokee_buffer_encode_md5_digest  (cherokee_buffer_t  *buf); 
    114114ret_t cherokee_buffer_encode_sha1        (cherokee_buffer_t  *buf, cherokee_buffer_t *encoded); 
    115 ret_t cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t  *buf); 
    116 ret_t cherokee_buffer_encode_hex         (cherokee_buffer_t  *buf); 
     115ret_t cherokee_buffer_encode_sha1_base64 (cherokee_buffer_t  *buf, cherokee_buffer_t *encoded); 
     116ret_t cherokee_buffer_encode_hex         (cherokee_buffer_t  *buf, cherokee_buffer_t *encoded); 
    117117ret_t cherokee_buffer_decode_hex         (cherokee_buffer_t  *buf); 
    118118ret_t cherokee_buffer_unescape_uri       (cherokee_buffer_t  *buf); 

  • cherokee/trunk/cherokee/downloader.c

    r597 r606  
    380380 
    381381ret_t  
    382 cherokee_downloader_step (cherokee_downloader_t *downloader) 
     382cherokee_downloader_step (cherokee_downloader_t *downloader, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2) 
    383383{ 
    384384        ret_t ret; 
    …… 
    399399                /* Build the request header 
    400400                 */ 
    401                 ret = cherokee_request_header_build_string (req, &downloader->request_header); 
    402                 if (unlikely(ret < ret_ok)) return ret; 
     401                ret = cherokee_request_header_build_string (req, &downloader->request_header, tmp1, tmp2); 
     402                if (unlikely(ret < ret_ok)) 
     403                        return ret; 
    403404 
    404405                /* Deal with the connection 

  • cherokee/trunk/cherokee/downloader.h

    r597 r606  
    6161ret_t cherokee_downloader_post_reset      (cherokee_downloader_t *downloader); 
    6262 
    63 ret_t cherokee_downloader_step            (cherokee_downloader_t *downloader); 
     63ret_t cherokee_downloader_step            (cherokee_downloader_t *downloader, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2); 
    6464ret_t cherokee_downloader_reuse           (cherokee_downloader_t *downloader); 
    6565ret_t cherokee_downloader_connect         (cherokee_downloader_t *downloader); 

  • cherokee/trunk/cherokee/handler_common.c

    r597 r606  
    230230         */ 
    231231        if (S_ISDIR(info->st_mode)) { 
     232                cherokee_thread_t        *thread      = CONN_THREAD(conn); 
    232233                cherokee_list_t *i; 
    233234 
    …… 
    255256                         */ 
    256257                        if (*index == '/') { 
    257                                 cherokee_buffer_t new_local_dir = CHEROKEE_BUF_INIT;  
     258                                cherokee_buffer_t *new_local_dir = THREAD_TMP_BUF1(thread); 
    258259 
    259260                                /* This means there is a configuration entry like: 
    …… 
    268269                                /* Lets reconstruct the local directory 
    269270                                 */ 
    270                                 cherokee_buffer_add_buffer (&new_local_dir, &CONN_VSRV(conn)->root); 
    271                                 cherokee_buffer_add (&new_local_dir, index, index_len); 
     271                                cherokee_buffer_clean (new_local_dir); 
     272                                cherokee_buffer_add_buffer (new_local_dir, &CONN_VSRV(conn)->root); 
     273                                cherokee_buffer_add (new_local_dir, index, index_len); 
    272274                                 
    273                                 ret = stat_file (use_iocache, iocache, &nocache_info, new_local_dir.buf, &file, &info); 
     275                                ret = stat_file (use_iocache, iocache, &nocache_info, new_local_dir->buf, &file, &info); 
    274276                                exists = (ret == ret_ok); 
    275277                                cherokee_iocache_mmap_release (iocache, file); 
    276278 
    277                                 cherokee_buffer_mrproper (&new_local_dir); 
    278                                 if (!exists) continue; 
     279                                if (!exists) 
     280                                       continue; 
    279281 
    280282                                /* Build the new request before respin 

  • cherokee/trunk/cherokee/handler_nn.c

    r597 r606  
    3131#include <dirent.h> 
    3232 
     33#include "thread.h" 
    3334#include "connection.h" 
    3435#include "connection-protected.h" 
    …… 
    5758 
    5859        dir = opendir(directory); 
    59         if (dir == NULL) goto go_out; 
     60        if (dir == NULL) 
     61                goto go_out; 
    6062 
    6163        while ((entry = readdir (dir)) != NULL) 
    …… 
    8385 
    8486 
    85 ret_t 
    86 get_nearest (cherokee_buffer_t *local_dir, 
    87              cherokee_buffer_t *request, 
    88              cherokee_buffer_t *output) 
     87static ret_t 
     88get_nearest_name ( 
     89                        cherokee_connection_t *conn, 
     90                        cherokee_buffer_t *local_dir, 
     91                        cherokee_buffer_t *request, 
     92                        cherokee_buffer_t *output) 
    8993{ 
    9094        char              *rest; 
    9195        ret_t              ret = ret_ok; 
    92         cherokee_buffer_t  req = CHEROKEE_BUF_INIT;       /* Request w/o last word */ 
     96        cherokee_thread_t *thread = CONN_THREAD(conn); 
     97        cherokee_buffer_t *req = THREAD_TMP_BUF1(thread);/* Request w/o last word */ 
    9398 
    9499        /* Build the local request path 
    …… 
    100105        rest++; 
    101106 
    102         cherokee_buffer_add_buffer (&req, local_dir); 
    103         cherokee_buffer_add (&req, request->buf, rest - request->buf); 
     107        cherokee_buffer_clean (req); 
     108        cherokee_buffer_add_buffer (req, local_dir); 
     109        cherokee_buffer_add (req, request->buf, rest - request->buf); 
    104110         
    105111        /* Copy the new filename to the output buffer 
    106112         */ 
    107         ret = get_nearest_from_directory (req.buf, rest, output); 
    108         cherokee_buffer_mrproper (&req); 
     113        ret = get_nearest_from_directory (req->buf, rest, output); 
    109114 
    110115        if (unlikely (ret != ret_ok)) { 
    …… 
    125130        struct stat            info; 
    126131        int                    stat_ret; 
    127         cherokee_connection_t *conn; 
    128  
    129         conn = CONN(cnt); 
     132        cherokee_connection_t *conn   = CONN(cnt); 
    130133 
    131134        cherokee_buffer_add (&conn->local_directory, conn->request.buf, conn->request.len); 
    …… 
    139142        }  
    140143 
    141         /* It doesn't exit, lets redirect it.. 
     144        /* It doesn't exists, let's redirect it.. 
    142145         */ 
    143146        cherokee_buffer_clean (&conn->redirect); 
    144147 
    145         ret = get_nearest (&conn->local_directory, &conn->request, &conn->redirect); 
     148        ret = get_nearest_name (conn, &conn->local_directory, &conn->request, &conn->redirect); 
    146149        if (unlikely (ret != ret_ok)) { 
    147                 CONN(cnt)->error_code = http_not_found; 
     150                conn->error_code = http_not_found; 
    148151                return ret_error; 
    149152        } 

  • cherokee/trunk/cherokee/handler_proxy.c

    r597 r606  
    249249        cherokee_boolean_t rw; 
    250250        cherokee_buffer_t *reply_header = &phdl->client.reply_header; 
    251  
    252         ret = cherokee_downloader_step (&phdl->client); 
     251        cherokee_thread_t *thread = HANDLER_THREAD(HDL_PROXY_HANDLER(phdl)); 
     252        cherokee_buffer_t *tmp1 = THREAD_TMP_BUF1(thread); 
     253        cherokee_buffer_t *tmp2 = THREAD_TMP_BUF2(thread); 
     254 
     255        ret = cherokee_downloader_step (&phdl->client, tmp1, tmp2); 
    253256 
    254257        switch (ret) { 
    …… 
    293296{ 
    294297        ret_t ret; 
    295  
    296         ret = cherokee_downloader_step (&phdl->client); 
     298        cherokee_thread_t *thread = HANDLER_THREAD(HDL_PROXY_HANDLER(phdl)); 
     299        cherokee_buffer_t *tmp1 = THREAD_TMP_BUF1(thread); 
     300        cherokee_buffer_t *tmp2 = THREAD_TMP_BUF2(thread); 
     301 
     302        ret = cherokee_downloader_step (&phdl->client, tmp1, tmp2); 
    297303 
    298304        switch (ret) { 

  • cherokee/trunk/cherokee/handler_proxy.h

    r597 r606  
    5454 
    5555#define PROP_PROXY(x)      ((cherokee_handler_proxy_props_t *)(x)) 
    56 #define HDL_PROXY(x)       ((cherokee_handler_proxy_t *)(p)) 
     56#define HDL_PROXY(x)       ((cherokee_handler_proxy_t *)(x)) 
    5757#define HDL_PROXY_PROPS(x) (PROP_PROXY(HANDLER(x)->props)) 
     58#define HDL_PROXY_HANDLER(x)  ( &((x)->handler) ) 
    5859 
    5960 

  • cherokee/trunk/cherokee/nonce.c

    r602 r606  
    9696        /* Generate nonce string 
    9797         */ 
     98        cherokee_buffer_clean (nonce); 
    9899        cherokee_buffer_add_ullong16(nonce, (cullong_t) CONN_SRV(conn)->bogo_now); 
    99100        cherokee_buffer_add_ulong16 (nonce, (culong_t) rand()); 

  • cherokee/trunk/cherokee/request.c

    r602 r606  
    7777 
    7878ret_t  
    79 cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf) 
     79cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2) 
    8080{ 
    8181        cherokee_url_t *url = REQUEST_URL(request); 
    …… 
    152152            !cherokee_buffer_is_empty(&url->passwd)) { 
    153153 
    154                 cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; 
     154                cherokee_buffer_clean (tmp1); 
     155                cherokee_buffer_clean (tmp2); 
    155156 
    156                 cherokee_buffer_add_va (&tmp, "%s:%s", url->user.buf, url->passwd.buf); 
    157                 cherokee_buffer_encode_base64 (&tmp); 
     157                cherokee_buffer_add_buffer (tmp1, &url->user); 
     158                cherokee_buffer_add_char   (tmp1, ':'); 
     159                cherokee_buffer_add_buffer (tmp1, &url->passwd); 
     160 
     161                cherokee_buffer_encode_base64 (tmp1, tmp2); 
    158162                 
    159                 cherokee_buffer_add_va (buf, "Authorization: Basic %s"CRLF, tmp.buf); 
    160  
    161                 cherokee_buffer_mrproper (&tmp); 
     163                cherokee_buffer_add_str    (buf, "Authorization: Basic "); 
     164                cherokee_buffer_add_buffer (buf, tmp2); 
     165                cherokee_buffer_add_str    (buf, CRLF); 
    162166        } 
    163167 

  • cherokee/trunk/cherokee/request.h

    r597 r606  
    3636        cherokee_list_t         list_entry; 
    3737        cherokee_url_t          url; 
    38          
     38 
    3939        uint16_t                pipeline; 
    4040        cherokee_boolean_t      keepalive; 
    …… 
    6060 
    6161ret_t cherokee_request_header_add_header   (cherokee_request_header_t *request, char *ptr, cuint_t len); 
    62 ret_t cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf); 
     62ret_t cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2); 
    6363 
    6464#endif /* CHEROKEE_REQUEST_H */ 

  • cherokee/trunk/cherokee/validator_htpasswd.c

    r597 r606  
    3131 
    3232#include "plugin_loader.h" 
     33#include "thread.h" 
    3334#include "connection.h" 
    3435#include "connection-protected.h" 
    …… 
    211212validate_non_salted_sha (cherokee_connection_t *conn, char *crypted) 
    212213{        
    213         cherokee_buffer_t sha1_client = CHEROKEE_BUF_INIT; 
    214214        cuint_t           c_len       = strlen (crypted); 
     215        cherokee_thread_t *thread = CONN_THREAD(conn); 
     216        cherokee_buffer_t *sha1_buf1 = THREAD_TMP_BUF1(thread); 
     217        cherokee_buffer_t *sha1_buf2 = THREAD_TMP_BUF2(thread); 
    215218 
    216219        /* Check the size. It should be: "{SHA1}" + Base64(SHA1(info)) 
    …… 
    223226  
    224227        /* Decode user 
    225          */  
    226         cherokee_buffer_add_buffer (&sha1_client, &conn->validator->passwd); 
    227         cherokee_buffer_encode_sha1_base64 (&sha1_client); 
    228  
    229         if (strcmp (sha1_client.buf, crypted) == 0) 
     228         */ 
     229        cherokee_buffer_clean (sha1_buf1); 
     230        cherokee_buffer_clean (sha1_buf2); 
     231        cherokee_buffer_add_buffer (sha1_buf1, &conn->validator->passwd); 
     232        cherokee_buffer_encode_sha1_base64 (sha1_buf1, sha1_buf2); 
     233 
     234        if (strcmp (sha1_buf2->buf, crypted) == 0) 
    230235                return ret_ok; 
    231236