Changeset 1433

Show
Ignore:
Timestamp:
05/17/08 12:40:48 (5 months ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r1432 r1433  
     12008-05-17  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * downloader.c, downloader.h, handler.h, handler_proxy.c, 
     4        handler_proxy.h, connection.c: Fixes a number of problems with the 
     5        alpha proxy handler. After these changes I have been able to point 
     6        my browser to Cherokee and browse the Internet successfully. 
     7 
    182008-05-04  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    29 

  • cherokee/trunk/cherokee/connection.c

    r1394 r1433  
    462462        cherokee_buffer_add_str (buffer, CRLF); 
    463463 
     464        /* Exit now if the handler already added all the headers 
     465         */ 
     466        if (HANDLER_SUPPORTS (conn->handler, hsupport_full_headers))  
     467                return ret_ok; 
     468 
    464469        /* Add the "Connection:" header 
    465470         */ 

  • cherokee/trunk/cherokee/downloader.c

    r1175 r1433  
    224224        } 
    225225 
    226         TRACE(ENTRIES, "Exists socket=%p\n", sock); 
     226        TRACE(ENTRIES, "Exits ok; socket=%p\n", sock); 
    227227        return ret_ok; 
    228228} 
    …… 
    621621        return ret_ok; 
    622622} 
     623 
     624 
     625ret_t  
     626cherokee_downloader_get_reply_hdr (cherokee_downloader_t *downloader, cherokee_buffer_t **header) 
     627{ 
     628        if (header != NULL) { 
     629                *header = &downloader->reply_header; 
     630        } 
     631 
     632        return ret_ok; 
     633} 

  • cherokee/trunk/cherokee/downloader.h

    r1131 r1433  
    6060 
    6161ret_t cherokee_downloader_get_reply_code  (cherokee_downloader_t *downloader, cherokee_http_t *code); 
     62ret_t cherokee_downloader_get_reply_hdr   (cherokee_downloader_t *downloader, cherokee_buffer_t **header); 
    6263 
    6364ret_t cherokee_downloader_post_set        (cherokee_downloader_t *downloader, cherokee_post_t *post); 

  • cherokee/trunk/cherokee/handler.h

    r1131 r1433  
    5151        hsupport_range         = 1 << 2,    /* Can handle "Range: bytes=" requests     */ 
    5252        hsupport_error         = 1 << 3,    /* It is an error handler                  */ 
    53         hsupport_skip_headers  = 1 << 4     /* The server shouldn't add any headers    */ 
     53        hsupport_full_headers  = 1 << 4,    /* Handler adds the full header stack      */ 
     54        hsupport_skip_headers  = 1 << 5     /* The server shouldn't add any headers    */ 
    5455} cherokee_handler_support_t; 
    5556 

  • cherokee/trunk/cherokee/handler_proxy.c

    r1131 r1433  
    119119        /* Supported features 
    120120         */ 
    121         HANDLER(n)->support     = hsupport_length | hsupport_range | hsupport_skip_headers; 
     121        HANDLER(n)->support     = hsupport_length | hsupport_range | hsupport_full_headers; 
    122122 
    123123        /* Init 
    124124         */ 
    125         ret = cherokee_downloader_init(&n->client); 
     125        ret = cherokee_downloader_init(&n->downloader); 
    126126        if ( ret != ret_ok ) 
    127127                return ret; 
    …… 
    142142{ 
    143143        cherokee_buffer_mrproper (&hdl->url); 
    144         cherokee_downloader_mrproper (&hdl->client); 
     144        cherokee_downloader_mrproper (&hdl->downloader); 
    145145 
    146146        return ret_ok; 
    …… 
    168168                if ((strncasecmp (i, "Host:", 5) != 0) && 
    169169                    (strncasecmp (i, "Connection:", 11) != 0)) { 
    170                         cherokee_request_header_add_header (&hdl->client.request, i, nl - i); 
     170                        cherokee_request_header_add_header (&hdl->downloader.request, i, nl - i); 
    171171                } 
    172172 
    …… 
    217217        /* Fill in the downloader object.  
    218218         */ 
    219         ret = cherokee_downloader_set_url(&hdl->client, &hdl->url); 
    220         if ( ret != ret_ok ) 
    221                 return ret; 
    222  
    223         TRACE(ENTRIES, "Request: %s\n", hdl->client.request.url.host.buf); 
     219        ret = cherokee_downloader_set_url (&hdl->downloader, &hdl->url); 
     220        if ( ret != ret_ok ) 
     221                return ret; 
     222 
     223        TRACE(ENTRIES, "Request: %s\n", hdl->downloader.request.url.host.buf); 
    224224 
    225225        /* Extra headers 
    …… 
    232232         */ 
    233233        if (! cherokee_post_is_empty (&conn->post)) {  
    234                 cherokee_downloader_post_set (&hdl->client, &conn->post); 
     234                cherokee_downloader_post_set (&hdl->downloader, &conn->post); 
    235235        } 
    236236 
    237237        /* Properties 
    238238         */ 
    239         ret = cherokee_downloader_set_keepalive (&hdl->client, false);  
     239        ret = cherokee_downloader_set_keepalive (&hdl->downloader, false);  
    240240        if (ret != ret_ok) 
    241241                return ret; 
    242242 
    243         ret = cherokee_downloader_connect (&hdl->client); 
     243        ret = cherokee_downloader_connect (&hdl->downloader); 
    244244        if (ret != ret_ok) 
    245245                return ret; 
    246246 
    247247 
    248         TRACE(ENTRIES, "client->downloader->socket: %d\n",  SOCKET_FD(&hdl->client.socket));  
     248        TRACE(ENTRIES, "downloader->downloader->socket: %d\n",  SOCKET_FD(&hdl->downloader.socket));  
    249249        return ret_ok; 
    250250} 
    …… 
    256256{ 
    257257        ret_t              ret;  
     258        char              *begin; 
    258259        char              *end;  
    259         cuint_t            skip; 
     260        cuint_t            nl_len; 
    260261        cherokee_boolean_t rw; 
    261         cherokee_buffer_t *reply_header = &phdl->client.reply_header; 
    262         cherokee_thread_t *thread = HANDLER_THREAD(HDL_PROXY_HANDLER(phdl)); 
    263         cherokee_buffer_t *tmp1 = THREAD_TMP_BUF1(thread); 
    264         cherokee_buffer_t *tmp2 = THREAD_TMP_BUF2(thread); 
    265  
    266         ret = cherokee_downloader_step (&phdl->client, tmp1, tmp2); 
     262        cuint_t            skip         = 0; 
     263        cherokee_buffer_t *reply_header = NULL; 
     264        cherokee_thread_t *thread       = HANDLER_THREAD(HDL_PROXY_HANDLER(phdl)); 
     265        cherokee_buffer_t *tmp1         = THREAD_TMP_BUF1(thread); 
     266        cherokee_buffer_t *tmp2         = THREAD_TMP_BUF2(thread); 
     267 
     268        /* Get the header 
     269         */ 
     270        ret = cherokee_downloader_get_reply_hdr (&phdl->downloader, &reply_header); 
     271        if (unlikely (ret != ret_ok)) 
     272                return ret; 
     273 
     274        if (reply_header->len >= 5) { 
     275                /* Check new line length 
     276                 */ 
     277                end = reply_header->buf + reply_header->len; 
     278                if (strncmp (end - 4, CRLF CRLF, 4) == 0) 
     279                        nl_len = 2; 
     280                else if (strncmp (end - 2, "\n\n", 2) == 0) 
     281                        nl_len = 1; 
     282                else 
     283                        return ret_error; 
     284 
     285                skip += nl_len; 
     286 
     287                /* Skip the first response line 
     288                 * Eg: HTTP/1.1 200 OK 
     289                 */ 
     290                begin = strstr (reply_header->buf, CRLF); 
     291                if (! begin) 
     292                        begin = strchr (reply_header->buf, CHR_LF); 
     293                if (! begin) 
     294                        return ret_error; 
     295 
     296                begin += nl_len; 
     297                skip += (begin - reply_header->buf); 
     298 
     299                /* Copy the headers 
     300                 */ 
     301                cherokee_buffer_add (buffer, begin, reply_header->len - skip); 
     302                return ret_ok; 
     303        } 
     304 
     305        /* There is no header yet: try to read it 
     306         */ 
     307        ret = cherokee_downloader_step (&phdl->downloader, tmp1, tmp2); 
    267308 
    268309        switch (ret) { 
    …… 
    270311        case ret_eof: 
    271312        case ret_eof_have_data: 
    272                 break;           
     313                break; 
     314 
    273315        case ret_eagain: 
    274                 ret = cherokee_downloader_is_request_sent (&phdl->client); 
     316                ret = cherokee_downloader_is_request_sent (&phdl->downloader); 
    275317                rw = (ret == ret_ok) ? 0 : 1; 
    276318 
    277319                cherokee_thread_deactive_to_polling (HANDLER_THREAD(phdl), HANDLER_CONN(phdl),  
    278                                                      SOCKET_FD(&phdl->client.socket), rw, false);       
     320                                                     SOCKET_FD(&phdl->downloader.socket), rw, false); 
    279321                return ret_eagain; 
     322 
    280323        case ret_error: 
    281324                return ret; 
     325 
    282326        default: 
    283327                RET_UNKNOWN(ret); 
    …… 
    285329        } 
    286330 
    287         if (reply_header->len < 5) 
    288                 return ret_eagain; 
    289  
    290         end = reply_header->buf + reply_header->len; 
    291  
    292         if (strncmp (end - 4, CRLF CRLF, 4) == 0) 
    293                 skip = 2; 
    294         else if (strncmp (end - 2, "\n\n", 2) == 0) 
    295                 skip = 1; 
    296         else 
    297                 return ret_error; 
    298  
    299         cherokee_buffer_add (buffer, reply_header->buf, reply_header->len - skip); 
    300         return ret_ok; 
     331        return ret_eagain; 
    301332} 
    302333 
    …… 
    308339        ret_t ret; 
    309340        cherokee_thread_t *thread = HANDLER_THREAD(HDL_PROXY_HANDLER(phdl)); 
    310         cherokee_buffer_t *tmp1 = THREAD_TMP_BUF1(thread); 
    311         cherokee_buffer_t *tmp2 = THREAD_TMP_BUF2(thread); 
    312  
    313         ret = cherokee_downloader_step (&phdl->client, tmp1, tmp2); 
     341        cherokee_buffer_t *tmp1   = THREAD_TMP_BUF1(thread); 
     342        cherokee_buffer_t *tmp2   = THREAD_TMP_BUF2(thread); 
     343 
     344        ret = cherokee_downloader_step (&phdl->downloader, tmp1, tmp2); 
    314345 
    315346        switch (ret) { 
    …… 
    321352                                HANDLER_THREAD(phdl), 
    322353                                HANDLER_CONN(phdl), 
    323                                 SOCKET_FD(&phdl->client.socket), 0, false); 
     354                                SOCKET_FD(&phdl->downloader.socket), 0, false); 
    324355                return ret_eagain; 
    325356        case ret_eof: 
    …… 
    333364        } 
    334365 
    335         if (phdl->client.body.len > 0) { 
    336                 cherokee_buffer_swap_buffers (buffer, &phdl->client.body); 
    337                 cherokee_buffer_clean (&phdl->client.body); 
    338         } 
    339          
     366        if (phdl->downloader.body.len > 0) { 
     367                cherokee_buffer_swap_buffers (buffer, &phdl->downloader.body); 
     368                cherokee_buffer_clean (&phdl->downloader.body); 
     369        } 
     370         
     371        /* Last block waits to be sent.. 
     372         */ 
    340373        if ((ret == ret_eof) && (buffer->len > 0)) 
    341374                return ret_eof_have_data; 
    342375 
     376        /* Downloader may have returned 'ok' with an empty buffer 
     377         */ 
     378        if ((ret == ret_ok) && (buffer->len <= 0)) 
     379                return ret_eagain; 
     380 
    343381        return ret; 
    344382} 

  • cherokee/trunk/cherokee/handler_proxy.h

    r1131 r1433  
    4848typedef struct { 
    4949        cherokee_handler_t       handler;        
    50         cherokee_downloader_t    client; 
     50        cherokee_downloader_t    downloader; 
    5151        cherokee_buffer_t        url; 
    5252} cherokee_handler_proxy_t;