Changeset 920

Show
Ignore:
Timestamp:
09/19/07 13:12:50 (1 year ago)
Author:
alo
Message:

--

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • cherokee/trunk/ChangeLog

    r918 r920  
     12007-09-19  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
     2 
     3        * cget/main.c: Quite a few small fixes and micro-improvements. 
     4 
    152007-09-18  Alvaro Lopez Ortega  <alvaro@alobbs.com> 
    26 

  • cherokee/trunk/cget/main.c

    r608 r920  
    6363#define COLUM_NUM  20 
    6464#define COLUM_SEP  ":" 
     65#define ENTRIES    "cget" 
    6566 
    6667 
    …… 
    167168        hdr = downloader->header; 
    168169 
     170        TRACE(ENTRIES, "quiet=%d http_code=%d\n", quiet, hdr->response); 
     171 
    169172        /* Check the response 
    170173         */ 
    171174        if (quiet == false) { 
    172                 cherokee_buffer_t *buf; 
    173  
    174                 cherokee_buffer_new (&buf); 
    175                 cherokee_http_code_copy (HDR_RESPONSE(hdr), buf); 
    176  
    177                 print_tuple_str ("Response", buf->buf); 
    178                  
    179                 cherokee_buffer_free (buf); 
    180         } 
    181  
    182         if ((! http_type_200 (hdr->response)) && (! save_headers)) { 
    183                 return ret_error; 
     175                cherokee_buffer_t tmp = CHEROKEE_BUF_INIT; 
     176 
     177                cherokee_http_code_copy (HDR_RESPONSE(hdr), &tmp); 
     178                print_tuple_str ("Response", tmp.buf); 
     179                cherokee_buffer_mrproper (&tmp); 
    184180        } 
    185181 
    …… 
    224220do_download__read_body (cherokee_downloader_t *downloader, void *param) 
    225221{ 
     222        ret_t   ret; 
     223        ssize_t len; 
    226224        char    tmp[5]; 
    227225        char    total[5]; 
    228  
    229         ret_t   ret; 
    230         ssize_t len; 
    231226 
    232227        /* Write down 
    …… 
    243238        cherokee_strfsize (downloader->info.body_recv, tmp); 
    244239 
    245         fprintf (stderr, "\rDownloading: %s of %s", tmp, total); 
    246         fflush(stderr); 
     240        if (! quiet) { 
     241                fprintf (stderr, "\rDownloading: %s of %s", tmp, total); 
     242                fflush(stderr); 
     243        } 
    247244 
    248245        return ret_ok;   
    …… 
    259256 
    260257static ret_t 
    261 do_download (cherokee_downloader_t *downloader, cherokee_fdpoll_t *fdpoll, cherokee_buffer_t *tmp1, cherokee_buffer_t *tmp2) 
     258do_download (cherokee_downloader_t *downloader) 
    262259{ 
    263260        ret_t                        ret; 
    264261        cherokee_downloader_status_t status; 
    265         cint_t                       headers_are_read = 0; 
    266         cint_t                       reading          = 0; 
     262        cherokee_boolean_t           got_headers = false; 
     263        cherokee_boolean_t           reading     = false; 
    267264 
    268265        do_download__init(downloader,NULL); 
    269266 
    270         /*  
    271          * add socket to fdpoll in write mode 
    272          */ 
    273         cherokee_fdpoll_add(fdpoll, downloader->socket.socket, 1); 
    274267        for (;;) { 
    275                 /* Inspect the file descriptors 
    276                  */  
    277                 if ( cherokee_fdpoll_watch (fdpoll, POLL_TIME) > 0 ) { 
    278  
    279  
    280                         /* Do some work 
     268                /* Do some real work 
     269                 */ 
     270                ret = cherokee_downloader_step (downloader, NULL, NULL); 
     271 
     272                cherokee_downloader_get_status(downloader, &status); 
     273                TRACE(ENTRIES, "ret=%d status=%d\n", ret, status); 
     274 
     275                switch (ret) { 
     276                case ret_ok: 
     277                        if ( !reading && (status & downloader_status_post_sent)) { 
     278                                reading = true; 
     279                        } 
     280                         
     281                        if ( (status & downloader_status_headers_received) && !got_headers) { 
     282                                do_download__has_headers (downloader, NULL); 
     283                                got_headers = true; 
     284                        } 
     285 
     286                        if (status & downloader_status_data_available) { 
     287                                do_download__read_body (downloader, NULL); 
     288                        } 
     289 
     290                        if (status & downloader_status_finished) { 
     291                                do_download__finish (downloader, NULL); 
     292                        } 
     293                        break; 
     294                         
     295                case ret_eagain: 
     296                        /* It's going on.. 
    281297                         */ 
    282                         ret = cherokee_downloader_step (downloader, tmp1, tmp2); 
    283  
    284                         cherokee_downloader_get_status(downloader, &status); 
    285                         switch (ret) { 
    286                         case ret_ok: 
    287                                 if ( !reading && (status & downloader_status_post_sent)) { 
    288                                         /*       
    289                                          * the headers and post have been sent, 
    290                                          * switch socket to read 
    291                                          */ 
    292                                         cherokee_fdpoll_set_mode (fdpoll, downloader->socket.socket, 0); 
    293                                         reading = 1; 
    294                                 } 
     298                        break; 
    295299                         
    296                                 if ( (status & downloader_status_headers_received) && !headers_are_read) { 
    297                                         do_download__has_headers(downloader, NULL); 
    298                                         headers_are_read = 1; 
    299                                 } 
    300  
    301                                 if (status & downloader_status_data_available) { 
    302                                         do_download__read_body(downloader, NULL); 
    303                                 } 
    304  
    305                                 if (status & downloader_status_finished) { 
    306                                         do_download__finish(downloader, NULL); 
    307                                 } 
    308  
    309                         case ret_eagain: 
    310                                 /* it is go.. continue 
    311                                  */ 
    312                                 break; 
     300                case ret_eof_have_data: 
     301                        if ((status & downloader_status_headers_received) && !got_headers) { 
     302                                do_download__has_headers (downloader, NULL); 
     303                                got_headers = true;                              
     304                        } 
     305                        if (status & downloader_status_data_available) { 
     306                                do_download__read_body (downloader, NULL); 
     307                        } 
     308                        /* fall down */ 
     309 
     310                case ret_eof: 
     311                        if (status & downloader_status_finished) { 
     312                                do_download__finish (downloader, NULL); 
     313                        } 
     314                        /* fall down */ 
     315 
     316                case ret_error: 
     317                        /* Finished or critical error 
     318                         */ 
     319                        return ret; 
    313320                         
    314                         case ret_eof_have_data: 
    315                                 if (status & downloader_status_data_available) { 
    316                                         do_download__read_body(downloader, NULL); 
    317                                 } 
    318                         case ret_eof: 
    319                                 if (status & downloader_status_finished) { 
    320                                         do_download__finish(downloader, NULL); 
    321                                 } 
    322                         case ret_error: 
    323                                 /* Finished or critical error 
    324                                  */ 
    325                                 return ret; 
    326                          
    327                         default: 
    328                                 SHOULDNT_HAPPEN; 
    329                                 return ret_error; 
    330                         } 
     321                default: 
     322                        SHOULDNT_HAPPEN; 
     323                        return ret_error; 
    331324                } 
    332325        } 
    …… 
    339332main (int argc, char **argv) 
    340333{ 
    341         int     re; 
    342         ret_t   ret; 
    343         int     val; 
    344         int     param_num; 
    345         int     long_index; 
    346         cuint_t fdlimit; 
    347         cherokee_fdpoll_t     *fdpoll; 
     334        int                    re; 
     335        ret_t                  ret; 
     336        cint_t                 val; 
     337        cint_t                 param_num; 
     338        cint_t                 long_index; 
    348339        cherokee_downloader_t *downloader; 
    349         cherokee_buffer_t     tmp1 = CHEROKEE_BUF_INIT; 
    350         cherokee_buffer_t     tmp2 = CHEROKEE_BUF_INIT; 
    351  
    352340 
    353341        struct option long_options[] = { 
    …… 
    361349        }; 
    362350 
    363         cherokee_buffer_ensure_size (&tmp1, 1024); 
    364         cherokee_buffer_ensure_size (&tmp2, 1024); 
    365  
    366         /* Build the fd poll object.. 
    367          */ 
    368         ret = cherokee_sys_fdlimit_get (&fdlimit); 
    369         if (ret != ret_ok) return EXIT_ERROR; 
    370  
    371         ret = cherokee_fdpoll_best_new (&fdpoll, fdlimit, fdlimit); 
    372         if (ret != ret_ok) return EXIT_ERROR; 
    373  
    374351        /* Parse known parameters 
    375352         */ 
    …… 
    379356                        printf ("Cherokee Downloader %s\n" 
    380357                                "Written by Alvaro Lopez Ortega <alvaro@gnu.org>\n\n" 
    381                                 "Copyright (C) 2001-2006 Alvaro Lopez Ortega.\n" 
     358                                "Copyright (C) 2001-2007 Alvaro Lopez Ortega.\n" 
    382359                                "This is free software; see the source for copying conditions.  There is NO\n" 
    383360                                "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", 
    …… 
    425402        } 
    426403 
     404        cherokee_trace_init(); 
     405 
    427406        for (val=optind; val<optind+param_num; val++) { 
    428                 cherokee_buffer_t *url; 
     407                cherokee_buffer_t url = CHEROKEE_BUF_INIT; 
    429408                 
    430409                /* Build the url buffer 
    431410                 */ 
    432                 ret = cherokee_buffer_new (&url); 
    433                 if (ret != ret_ok) return EXIT_ERROR; 
    434  
    435                 ret = cherokee_buffer_add_va (url, "%s", argv[val]); 
     411                ret = cherokee_buffer_add_va (&url, "%s", argv[val]); 
    436412                if (ret != ret_ok) return EXIT_ERROR; 
    437413 
    …… 
    444420                if (ret != ret_ok) return EXIT_ERROR; 
    445421 
    446                 ret = cherokee_downloader_set_url (downloader, url); 
     422                ret = cherokee_downloader_set_url (downloader, &url); 
    447423                if (ret != ret_ok) return EXIT_ERROR; 
    448424 
    …… 
    452428                /* Download it! 
    453429                 */ 
    454                 ret = do_download (downloader, fdpoll, &tmp1, &tmp2); 
     430                ret = do_download (downloader); 
    455431                if ((ret != ret_ok) && (ret != ret_eof)) { 
    456432                        return EXIT_ERROR; 
    …… 
    459435                /* Free the objects.. 
    460436                 */ 
    461                 cherokee_buffer_free (url); 
     437                cherokee_buffer_mrproper (&url); 
    462438                cherokee_downloader_free (downloader); 
    463439        }