Changeset 921

Show
Ignore:
Timestamp:
09/19/07 16:48:20 (1 year ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r920 r921  
    112007-09-19  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cherokee/request.c (cherokee_request_header_build_string): Moved 
     4        to use cherokee_http_* methods instead of local switches for 
     5        converting the http method into a string. 
     6         
     7        * cget/proxy.h, cget/proxy.c, cherokee/request.h, , cget/main.c, 
     8        cherokee/request.c (cherokee_request_header_build_string), 
     9        cherokee/downloader.h, cherokee/downloader.c: Added proxy 
     10        support. Cget inherits this feature of the cherokee-client 
     11        library. 
    212 
    313        * cget/main.c: Quite a few small fixes and micro-improvements. 

  • cherokee/trunk/cget/Makefile.am

    r701 r921  
    1616 
    1717cget_SOURCES = \ 
    18 main.c 
     18main.c \ 
     19proxy.h \ 
     20proxy.c 
    1921 
    2022bin_PROGRAMS = cget 

  • cherokee/trunk/cget/main.c

    r920 r921  
    66 *      Alvaro Lopez Ortega <alvaro@alobbs.com> 
    77 * 
    8  * Copyright (C) 2001-2006 Alvaro Lopez Ortega 
     8 * Copyright (C) 2001-2007 Alvaro Lopez Ortega 
    99 * 
    1010 * This program is free software; you can redistribute it and/or 
    …… 
    5656#include "socket.h" 
    5757#include "header-protected.h"      /* FIXME! */ 
     58 
     59#include "proxy.h" 
    5860 
    5961#define EXIT_OK    0 
    …… 
    338340        cint_t                 long_index; 
    339341        cherokee_downloader_t *downloader; 
     342        cherokee_buffer_t      proxy       = CHEROKEE_BUF_INIT; 
     343        cuint_t                proxy_port; 
    340344 
    341345        struct option long_options[] = { 
    …… 
    402406        } 
    403407 
     408        /* Tracing and proxy discovering.. 
     409         */ 
    404410        cherokee_trace_init(); 
     411        cget_find_proxy (&proxy, &proxy_port); 
    405412 
    406413        for (val=optind; val<optind+param_num; val++) { 
    …… 
    420427                if (ret != ret_ok) return EXIT_ERROR; 
    421428 
     429                if (! cherokee_buffer_is_empty (&proxy)) { 
     430                        ret = cherokee_downloader_set_proxy (downloader, &proxy, proxy_port); 
     431                        if (ret != ret_ok) return EXIT_ERROR; 
     432                } 
     433 
    422434                ret = cherokee_downloader_set_url (downloader, &url); 
    423435                if (ret != ret_ok) return EXIT_ERROR; 

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

    r613 r921  
    5656 
    5757        cherokee_post_t             *post; 
     58        cherokee_buffer_t            proxy; 
     59        cuint_t                      proxy_port; 
    5860 
    5961        cherokee_socket_t            socket; 
    …… 
    8082 
    8183 
    82  
    8384ret_t cherokee_downloader_init     (cherokee_downloader_t  *downloader); 
    8485ret_t cherokee_downloader_mrproper (cherokee_downloader_t  *downloader); 

  • cherokee/trunk/cherokee/downloader.c

    r895 r921  
    4848 
    4949ret_t  
    50 cherokee_downloader_new (cherokee_downloader_t **downloader) 
    51 { 
    52         ret_t ret; 
    53         CHEROKEE_NEW_STRUCT(n, downloader); 
    54  
    55         /* Init 
    56          */ 
    57         ret = cherokee_downloader_init (n); 
    58         if (unlikely(ret != ret_ok)) return ret; 
    59  
    60         /* Return the object 
    61          */ 
    62         *downloader = n; 
    63         return ret_ok; 
    64 } 
    65  
    66  
    67 ret_t  
    6850cherokee_downloader_init (cherokee_downloader_t *n) 
    6951{ 
    …… 
    8971        ret = cherokee_header_new (&n->header);  
    9072        if (unlikely(ret != ret_ok)) return ret; 
     73 
     74        cherokee_buffer_init (&n->proxy); 
     75        n->proxy_port = 0; 
    9176 
    9277        cherokee_buffer_init (&n->tmp1); 
    …… 
    116101 
    117102ret_t  
    118 cherokee_downloader_free (cherokee_downloader_t *downloader) 
    119 { 
    120         cherokee_downloader_mrproper (downloader); 
    121  
    122         free (downloader); 
    123         return ret_ok; 
    124 } 
    125  
    126  
    127 ret_t  
    128103cherokee_downloader_mrproper (cherokee_downloader_t *downloader) 
    129104{ 
    …… 
    135110        cherokee_buffer_mrproper (&downloader->reply_header); 
    136111        cherokee_buffer_mrproper (&downloader->body); 
     112        cherokee_buffer_mrproper (&downloader->proxy); 
    137113 
    138114        cherokee_buffer_mrproper (&downloader->tmp1); 
    …… 
    146122        return ret_ok; 
    147123} 
     124 
     125 
     126CHEROKEE_ADD_FUNC_NEW (downloader); 
     127CHEROKEE_ADD_FUNC_FREE (downloader); 
    148128 
    149129 
    …… 
    172152 
    173153ret_t  
     154cherokee_downloader_set_proxy (cherokee_downloader_t *downloader, cherokee_buffer_t *proxy, cuint_t port) 
     155{ 
     156        char *tmp; 
     157 
     158        /* Skip 'http(s)://' 
     159         */ 
     160        tmp = strchr (proxy->buf, '/'); 
     161        if (tmp == NULL)  
     162                tmp = proxy->buf; 
     163        else 
     164                tmp += 2; 
     165 
     166        /* Copy the values 
     167         */ 
     168        cherokee_buffer_clean (&downloader->proxy); 
     169        cherokee_buffer_add (&downloader->proxy, tmp, strlen(tmp)); 
     170 
     171        downloader->proxy_port = port; 
     172        return ret_ok; 
     173} 
     174 
     175 
     176ret_t  
    174177cherokee_downloader_get_reply_code (cherokee_downloader_t *downloader, cherokee_http_t *code) 
    175178{ 
    …… 
    179182 
    180183 
    181 ret_t  
    182 cherokee_downloader_connect (cherokee_downloader_t *downloader) 
     184static ret_t  
     185connect_to (cherokee_downloader_t *downloader, cherokee_buffer_t *host, cuint_t port, int protocol) 
    183186{ 
    184187        ret_t               ret; 
    185188        cherokee_socket_t  *sock = &downloader->socket; 
    186         cherokee_url_t     *url  = &downloader->request.url; 
     189 
     190        TRACE(ENTRIES, "host=%s port=%d proto=%d\n", host->buf, port, protocol); 
    187191 
    188192        /* Create the socket 
    …… 
    193197        /* Set the port 
    194198         */ 
    195         SOCKET_SIN_PORT(sock) = htons(url->port); 
    196  
    197         /* Find the IP from the hostname 
    198          * Maybe it is a IP.. 
    199          */ 
    200         ret = cherokee_socket_pton (sock, &url->host); 
     199        SOCKET_SIN_PORT(sock) = htons(port); 
     200 
     201        /* Supposing it's an IP: convert it. 
     202         */ 
     203        ret = cherokee_socket_pton (sock, host); 
    201204        if (ret != ret_ok) { 
    202205 
    203                 /* Ops! no, it could be a hostname.. 
    204                  * Try to resolv it! 
    205                  */ 
    206                 ret = cherokee_socket_gethostbyname (sock, &url->host); 
     206                /* Ops! It might be a hostname. Try to resolve it. 
     207                 */ 
     208                ret = cherokee_socket_gethostbyname (sock, host); 
    207209                if (unlikely(ret != ret_ok)) return ret_error; 
    208210        } 
    …… 
    211213         */ 
    212214        ret = cherokee_socket_connect (sock); 
     215        TRACE(ENTRIES, "socket=%p ret=%d\n", sock, ret); 
    213216        if (unlikely(ret != ret_ok)) return ret; 
    214217 
    215         /* Enables nonblocking I/O. 
    216          */ 
    217         cherokee_fd_set_nonblocking (SOCKET_FD(sock)); 
    218  
    219218        /* Is this connection TLS? 
    220219         */ 
    221         if (url->protocol == https) { 
     220        if (protocol == https) { 
    222221                ret = cherokee_socket_init_client_tls (sock); 
     222                if (ret != ret_ok) return ret; 
     223        } 
     224 
     225        TRACE(ENTRIES, "Exists socket=%p\n", sock); 
     226        return ret_ok; 
     227} 
     228 
     229 
     230ret_t  
     231cherokee_downloader_connect (cherokee_downloader_t *downloader) 
     232{ 
     233        ret_t               ret; 
     234        cherokee_boolean_t  uses_proxy; 
     235        cherokee_url_t     *url  = &downloader->request.url; 
     236 
     237        /* Does it use a proxy? 
     238         */ 
     239        uses_proxy = ! cherokee_buffer_is_empty (&downloader->proxy); 
     240        ret = cherokee_request_header_uses_proxy (&downloader->request, uses_proxy); 
     241        if (ret != ret_ok) return ret; 
     242         
     243        /* Connect 
     244         */ 
     245        if (uses_proxy) { 
     246                ret = connect_to (downloader, &downloader->proxy, downloader->proxy_port, http); 
     247                if (ret != ret_ok) return ret; 
     248        } else { 
     249                ret = connect_to (downloader, &url->host, url->port, url->protocol); 
    223250                if (ret != ret_ok) return ret; 
    224251        } 
    …… 
    396423        tmp1 = (ext_tmp1) ? ext_tmp1 : &downloader->tmp1; 
    397424        tmp2 = (ext_tmp2) ? ext_tmp2 : &downloader->tmp2; 
     425 
     426        TRACE (ENTRIES, "phase=%d\n", downloader->phase); 
    398427 
    399428        /* Process it 

  • cherokee/trunk/cherokee/downloader.h

    r606 r921  
    4343 
    4444typedef enum { 
    45         downloader_status_none = 0x0, 
    46         downloader_status_headers_sent = 0x1, 
    47         downloader_status_post_sent = 0x2, 
     45        downloader_status_none             = 0x0, 
     46        downloader_status_headers_sent     = 0x1, 
     47        downloader_status_post_sent        = 0x2, 
    4848        downloader_status_headers_received = 0x4, 
    49         downloader_status_data_available = 0x8, 
    50         downloader_status_finished = 0x10 
     49        downloader_status_data_available   = 0x8, 
     50        downloader_status_finished         = 0x10 
    5151} cherokee_downloader_status_t; 
    5252 
    …… 
    5656ret_t cherokee_downloader_set_url         (cherokee_downloader_t *downloader, cherokee_buffer_t *url); 
    5757ret_t cherokee_downloader_set_keepalive   (cherokee_downloader_t *downloader, cherokee_boolean_t active); 
     58ret_t cherokee_downloader_set_proxy       (cherokee_downloader_t *downloader, cherokee_buffer_t *proxy, cuint_t port); 
     59 
    5860ret_t cherokee_downloader_get_reply_code  (cherokee_downloader_t *downloader, cherokee_http_t *code); 
    5961 

  • cherokee/trunk/cherokee/post.c

    r863 r921  
    204204        /* Sanity check 
    205205         */ 
    206         if (fd < 0) return ret_error; 
     206        if (fd < 0)  
     207                return ret_error; 
    207208 
    208209        /* Send a chunk.. 

  • cherokee/trunk/cherokee/request.c

    r897 r921  
    3939        request->method    = http_get; 
    4040        request->version   = http_version_11; 
     41        request->proxy     = false; 
    4142        request->keepalive = true; 
    4243        request->pipeline  = 1; 
    …… 
    7576} 
    7677 
     78ret_t  
     79cherokee_request_header_uses_proxy (cherokee_request_header_t *request, cherokee_boolean_t proxy) 
     80{ 
     81        request->proxy = proxy; 
     82        return ret_ok; 
     83} 
     84 
    7785 
    7886ret_t  
    7987cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2) 
    8088{ 
     89        ret_t           ret; 
     90        const char     *ptr; 
     91        cuint_t         len; 
    8192        cherokee_url_t *url = REQUEST_URL(request); 
    8293 
    …… 
    8899         * GET /dir/object HTTP/1.1 
    89100         */ 
    90         switch (request->method) { 
    91         case http_get: 
    92                 cherokee_buffer_add_str (buf, "GET ");           
    93                 break; 
    94         case http_post: 
    95                 cherokee_buffer_add_str (buf, "POST ");                  
    96                 break; 
    97         case http_head: 
    98                 cherokee_buffer_add_str (buf, "HEAD ");                  
    99                 break; 
    100         case http_put: 
    101                 cherokee_buffer_add_str (buf, "PUT ");           
    102                 break; 
    103         default: 
    104                 SHOULDNT_HAPPEN; 
    105                 return ret_error; 
    106         } 
     101        ret = cherokee_http_method_to_string (request->method, &ptr, &len); 
     102        if (ret != ret_ok) return ret; 
     103 
     104        ret = cherokee_buffer_add (buf, ptr, len); 
     105        if (ret != ret_ok) return ret; 
     106 
     107        cherokee_buffer_add_str (buf, " "); 
     108 
     109        /* Check if the requests goes through a proxy 
     110         */ 
     111        if (request->proxy) { 
     112                cherokee_buffer_add_str (buf, "http://"); 
     113                cherokee_buffer_add_buffer (buf, URL_HOST(url)); 
     114        }  
    107115 
    108116        cherokee_buffer_add_buffer (buf, URL_REQUEST(url)); 
    …… 
    175183        cherokee_buffer_add_str (buf, CRLF); 
    176184 
     185        printf ("------>%s\n", buf->buf); 
     186 
    177187        return ret_ok; 
    178188} 

  • cherokee/trunk/cherokee/request.h

    r606 r921  
    3838 
    3939        uint16_t                pipeline; 
     40        cherokee_boolean_t      proxy; 
    4041        cherokee_boolean_t      keepalive; 
    4142        cherokee_http_method_t  method; 
    …… 
    5960ret_t cherokee_request_header_mrproper (cherokee_request_header_t *request); 
    6061 
     62ret_t cherokee_request_header_uses_proxy   (cherokee_request_header_t *request, cherokee_boolean_t proxy); 
    6163ret_t cherokee_request_header_add_header   (cherokee_request_header_t *request, char *ptr, cuint_t len); 
    6264ret_t cherokee_request_header_build_string (cherokee_request_header_t *request, cherokee_buffer_t *buf, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2);