wget: get rid of setitimer
[people/mcb30/busybox.git] / networking / wget.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * wget - retrieve a file using HTTP or FTP
4  *
5  * Chip Rosenthal Covad Communications <chip@laserlink.net>
6  *
7  */
8
9 #include <getopt.h>     /* for struct option */
10 #include "libbb.h"
11
12 struct host_info {
13         // May be used if we ever will want to free() all xstrdup()s...
14         /* char *allocated; */
15         char    *path;
16         char    *user;
17         char    *host;
18         int      port;
19         smallint is_ftp;
20 };
21
22
23 /* Globals (can be accessed from signal handlers) */
24 struct globals {
25         off_t content_len;        /* Content-length of the file */
26         off_t beg_range;          /* Range at which continue begins */
27 #if ENABLE_FEATURE_WGET_STATUSBAR
28         off_t lastsize;
29         off_t totalsize;
30         off_t transferred;        /* Number of bytes transferred so far */
31         const char *curfile;      /* Name of current file being transferred */
32         unsigned lastupdate_sec;
33         unsigned start_sec;
34 #endif
35         smallint chunked;             /* chunked transfer encoding */
36 };
37 #define G (*(struct globals*)&bb_common_bufsiz1)
38 struct BUG_G_too_big {
39         char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
40 };
41 #define content_len     (G.content_len    )
42 #define beg_range       (G.beg_range      )
43 #define lastsize        (G.lastsize       )
44 #define totalsize       (G.totalsize      )
45 #define transferred     (G.transferred    )
46 #define curfile         (G.curfile        )
47 #define lastupdate_sec  (G.lastupdate_sec )
48 #define start_sec       (G.start_sec      )
49 #define chunked         (G.chunked        )
50 #define INIT_G() do { } while (0)
51
52
53 #if ENABLE_FEATURE_WGET_STATUSBAR
54 enum {
55         STALLTIME = 5                   /* Seconds when xfer considered "stalled" */
56 };
57
58 static int getttywidth(void)
59 {
60         int width;
61         get_terminal_width_height(0, &width, NULL);
62         return width;
63 }
64
65 static void progressmeter(int flag)
66 {
67         /* We can be called from signal handler */
68         int save_errno = errno;
69         off_t abbrevsize;
70         unsigned since_last_update, elapsed;
71         unsigned ratio;
72         int barlength, i;
73
74         if (flag == -1) { /* first call to progressmeter */
75                 start_sec = monotonic_sec();
76                 lastupdate_sec = start_sec;
77                 lastsize = 0;
78                 totalsize = content_len + beg_range; /* as content_len changes.. */
79         }
80
81         ratio = 100;
82         if (totalsize != 0 && !chunked) {
83                 /* long long helps to have it working even if !LFS */
84                 ratio = (unsigned) (100ULL * (transferred+beg_range) / totalsize);
85                 if (ratio > 100) ratio = 100;
86         }
87
88         fprintf(stderr, "\r%-20.20s%4d%% ", curfile, ratio);
89
90         barlength = getttywidth() - 49;
91         if (barlength > 0) {
92                 /* god bless gcc for variable arrays :) */
93                 i = barlength * ratio / 100;
94                 {
95                         char buf[i+1];
96                         memset(buf, '*', i);
97                         buf[i] = '\0';
98                         fprintf(stderr, "|%s%*s|", buf, barlength - i, "");
99                 }
100         }
101         i = 0;
102         abbrevsize = transferred + beg_range;
103         while (abbrevsize >= 100000) {
104                 i++;
105                 abbrevsize >>= 10;
106         }
107         /* see http://en.wikipedia.org/wiki/Tera */
108         fprintf(stderr, "%6d%c ", (int)abbrevsize, " kMGTPEZY"[i]);
109
110 // Nuts! Ain't it easier to update progress meter ONLY when we transferred++?
111
112         elapsed = monotonic_sec();
113         since_last_update = elapsed - lastupdate_sec;
114         if (transferred > lastsize) {
115                 lastupdate_sec = elapsed;
116                 lastsize = transferred;
117                 if (since_last_update >= STALLTIME) {
118                         /* We "cut off" these seconds from elapsed time
119                          * by adjusting start time */
120                         start_sec += since_last_update;
121                 }
122                 since_last_update = 0; /* we are un-stalled now */
123         }
124         elapsed -= start_sec; /* now it's "elapsed since start" */
125
126         if (since_last_update >= STALLTIME) {
127                 fprintf(stderr, " - stalled -");
128         } else {
129                 off_t to_download = totalsize - beg_range;
130                 if (transferred <= 0 || (int)elapsed <= 0 || transferred > to_download || chunked) {
131                         fprintf(stderr, "--:--:-- ETA");
132                 } else {
133                         /* to_download / (transferred/elapsed) - elapsed: */
134                         int eta = (int) ((unsigned long long)to_download*elapsed/transferred - elapsed);
135                         /* (long long helps to have working ETA even if !LFS) */
136                         i = eta % 3600;
137                         fprintf(stderr, "%02d:%02d:%02d ETA", eta / 3600, i / 60, i % 60);
138                 }
139         }
140
141         if (flag == 0) {
142                 /* last call to progressmeter */
143                 alarm(0);
144                 transferred = 0;
145                 putc('\n', stderr);
146         } else {
147                 if (flag == -1) {
148                         /* first call to progressmeter */
149                         struct sigaction sa;
150                         sa.sa_handler = progressmeter;
151                         sigemptyset(&sa.sa_mask);
152                         sa.sa_flags = SA_RESTART;
153                         sigaction(SIGALRM, &sa, NULL);
154                 }
155                 alarm(1);
156         }
157
158         errno = save_errno;
159 }
160 /* Original copyright notice which applies to the CONFIG_FEATURE_WGET_STATUSBAR stuff,
161  * much of which was blatantly stolen from openssh.  */
162 /*-
163  * Copyright (c) 1992, 1993
164  *      The Regents of the University of California.  All rights reserved.
165  *
166  * Redistribution and use in source and binary forms, with or without
167  * modification, are permitted provided that the following conditions
168  * are met:
169  * 1. Redistributions of source code must retain the above copyright
170  *    notice, this list of conditions and the following disclaimer.
171  * 2. Redistributions in binary form must reproduce the above copyright
172  *    notice, this list of conditions and the following disclaimer in the
173  *    documentation and/or other materials provided with the distribution.
174  *
175  * 3. <BSD Advertising Clause omitted per the July 22, 1999 licensing change
176  *              ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change>
177  *
178  * 4. Neither the name of the University nor the names of its contributors
179  *    may be used to endorse or promote products derived from this software
180  *    without specific prior written permission.
181  *
182  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
183  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
184  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
185  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
186  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
187  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
188  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
189  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
190  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
191  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
192  * SUCH DAMAGE.
193  *
194  */
195 #else /* FEATURE_WGET_STATUSBAR */
196
197 static ALWAYS_INLINE void progressmeter(int flag) { }
198
199 #endif
200
201
202 /* Read NMEMB bytes into PTR from STREAM.  Returns the number of bytes read,
203  * and a short count if an eof or non-interrupt error is encountered.  */
204 static size_t safe_fread(void *ptr, size_t nmemb, FILE *stream)
205 {
206         size_t ret;
207         char *p = (char*)ptr;
208
209         do {
210                 clearerr(stream);
211                 ret = fread(p, 1, nmemb, stream);
212                 p += ret;
213                 nmemb -= ret;
214         } while (nmemb && ferror(stream) && errno == EINTR);
215
216         return p - (char*)ptr;
217 }
218
219 /* Read a line or SIZE-1 bytes into S, whichever is less, from STREAM.
220  * Returns S, or NULL if an eof or non-interrupt error is encountered.  */
221 static char *safe_fgets(char *s, int size, FILE *stream)
222 {
223         char *ret;
224
225         do {
226                 clearerr(stream);
227                 ret = fgets(s, size, stream);
228         } while (ret == NULL && ferror(stream) && errno == EINTR);
229
230         return ret;
231 }
232
233 #if ENABLE_FEATURE_WGET_AUTHENTICATION
234 /* Base64-encode character string. buf is assumed to be char buf[512]. */
235 static char *base64enc_512(char buf[512], const char *str)
236 {
237         unsigned len = strlen(str);
238         if (len > 512/4*3 - 10) /* paranoia */
239                 len = 512/4*3 - 10;
240         bb_uuencode(buf, str, len, bb_uuenc_tbl_base64);
241         return buf;
242 }
243 #endif
244
245
246 static FILE *open_socket(len_and_sockaddr *lsa)
247 {
248         FILE *fp;
249
250         /* glibc 2.4 seems to try seeking on it - ??! */
251         /* hopefully it understands what ESPIPE means... */
252         fp = fdopen(xconnect_stream(lsa), "r+");
253         if (fp == NULL)
254                 bb_perror_msg_and_die("fdopen");
255
256         return fp;
257 }
258
259
260 static int ftpcmd(const char *s1, const char *s2, FILE *fp, char *buf)
261 {
262         int result;
263         if (s1) {
264                 if (!s2) s2 = "";
265                 fprintf(fp, "%s%s\r\n", s1, s2);
266                 fflush(fp);
267         }
268
269         do {
270                 char *buf_ptr;
271
272                 if (fgets(buf, 510, fp) == NULL) {
273                         bb_perror_msg_and_die("error getting response");
274                 }
275                 buf_ptr = strstr(buf, "\r\n");
276                 if (buf_ptr) {
277                         *buf_ptr = '\0';
278                 }
279         } while (!isdigit(buf[0]) || buf[3] != ' ');
280
281         buf[3] = '\0';
282         result = xatoi_u(buf);
283         buf[3] = ' ';
284         return result;
285 }
286
287
288 static void parse_url(char *src_url, struct host_info *h)
289 {
290         char *url, *p, *sp;
291
292         /* h->allocated = */ url = xstrdup(src_url);
293
294         if (strncmp(url, "http://", 7) == 0) {
295                 h->port = bb_lookup_port("http", "tcp", 80);
296                 h->host = url + 7;
297                 h->is_ftp = 0;
298         } else if (strncmp(url, "ftp://", 6) == 0) {
299                 h->port = bb_lookup_port("ftp", "tcp", 21);
300                 h->host = url + 6;
301                 h->is_ftp = 1;
302         } else
303                 bb_error_msg_and_die("not an http or ftp url: %s", url);
304
305         // FYI:
306         // "Real" wget 'http://busybox.net?var=a/b' sends this request:
307         //   'GET /?var=a/b HTTP 1.0'
308         //   and saves 'index.html?var=a%2Fb' (we save 'b')
309         // wget 'http://busybox.net?login=john@doe':
310         //   request: 'GET /?login=john@doe HTTP/1.0'
311         //   saves: 'index.html?login=john@doe' (we save '?login=john@doe')
312         // wget 'http://busybox.net#test/test':
313         //   request: 'GET / HTTP/1.0'
314         //   saves: 'index.html' (we save 'test')
315         //
316         // We also don't add unique .N suffix if file exists...
317         sp = strchr(h->host, '/');
318         p = strchr(h->host, '?'); if (!sp || (p && sp > p)) sp = p;
319         p = strchr(h->host, '#'); if (!sp || (p && sp > p)) sp = p;
320         if (!sp) {
321                 /* must be writable because of bb_get_last_path_component() */
322                 static char nullstr[] ALIGN1 = "";
323                 h->path = nullstr;
324         } else if (*sp == '/') {
325                 *sp = '\0';
326                 h->path = sp + 1;
327         } else { // '#' or '?'
328                 // http://busybox.net?login=john@doe is a valid URL
329                 // memmove converts to:
330                 // http:/busybox.nett?login=john@doe...
331                 memmove(h->host-1, h->host, sp - h->host);
332                 h->host--;
333                 sp[-1] = '\0';
334                 h->path = sp;
335         }
336
337         sp = strrchr(h->host, '@');
338         h->user = NULL;
339         if (sp != NULL) {
340                 h->user = h->host;
341                 *sp = '\0';
342                 h->host = sp + 1;
343         }
344
345         sp = h->host;
346 }
347
348
349 static char *gethdr(char *buf, size_t bufsiz, FILE *fp /*, int *istrunc*/)
350 {
351         char *s, *hdrval;
352         int c;
353
354         /* *istrunc = 0; */
355
356         /* retrieve header line */
357         if (fgets(buf, bufsiz, fp) == NULL)
358                 return NULL;
359
360         /* see if we are at the end of the headers */
361         for (s = buf; *s == '\r'; ++s)
362                 continue;
363         if (*s == '\n')
364                 return NULL;
365
366         /* convert the header name to lower case */
367         for (s = buf; isalnum(*s) || *s == '-' || *s == '.'; ++s)
368                 *s = tolower(*s);
369
370         /* verify we are at the end of the header name */
371         if (*s != ':')
372                 bb_error_msg_and_die("bad header line: %s", buf);
373
374         /* locate the start of the header value */
375         *s++ = '\0';
376         hdrval = skip_whitespace(s);
377
378         /* locate the end of header */
379         while (*s && *s != '\r' && *s != '\n')
380                 ++s;
381
382         /* end of header found */
383         if (*s) {
384                 *s = '\0';
385                 return hdrval;
386         }
387
388         /* Rats! The buffer isn't big enough to hold the entire header value. */
389         while (c = getc(fp), c != EOF && c != '\n')
390                 continue;
391         /* *istrunc = 1; */
392         return hdrval;
393 }
394
395
396 int wget_main(int argc, char **argv);
397 int wget_main(int argc, char **argv)
398 {
399         char buf[512];
400         struct host_info server, target;
401         len_and_sockaddr *lsa;
402         int status;
403         int port;
404         int try = 5;
405         unsigned opt;
406         char *str;
407         char *proxy = 0;
408         char *dir_prefix = NULL;
409 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
410         char *extra_headers = NULL;
411         llist_t *headers_llist = NULL;
412 #endif
413         FILE *sfp = NULL;               /* socket to web/ftp server         */
414         FILE *dfp = NULL;               /* socket to ftp server (data)      */
415         char *fname_out = NULL;         /* where to direct output (-O)      */
416         bool got_clen = 0;              /* got content-length: from server  */
417         int output_fd = -1;
418         bool use_proxy = 1;             /* Use proxies if env vars are set  */
419         const char *proxy_flag = "on";  /* Use proxies if env vars are set  */
420         const char *user_agent = "Wget";/* "User-Agent" header field        */
421
422         static const char keywords[] ALIGN1 =
423                 "content-length\0""transfer-encoding\0""chunked\0""location\0";
424         enum {
425                 KEY_content_length = 1, KEY_transfer_encoding, KEY_chunked, KEY_location
426         };
427         enum {
428                 WGET_OPT_CONTINUE   = 0x1,
429                 WGET_OPT_SPIDER     = 0x2,
430                 WGET_OPT_QUIET      = 0x4,
431                 WGET_OPT_OUTNAME    = 0x8,
432                 WGET_OPT_PREFIX     = 0x10,
433                 WGET_OPT_PROXY      = 0x20,
434                 WGET_OPT_USER_AGENT = 0x40,
435                 WGET_OPT_PASSIVE    = 0x80,
436                 WGET_OPT_HEADER     = 0x100,
437         };
438 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
439         static const char wget_longopts[] ALIGN1 =
440                 /* name, has_arg, val */
441                 "continue\0"         No_argument       "c"
442                 "spider\0"           No_argument       "s"
443                 "quiet\0"            No_argument       "q"
444                 "output-document\0"  Required_argument "O"
445                 "directory-prefix\0" Required_argument "P"
446                 "proxy\0"            Required_argument "Y"
447                 "user-agent\0"       Required_argument "U"
448                 "passive-ftp\0"      No_argument       "\xff"
449                 "header\0"           Required_argument "\xfe"
450                 ;
451 #endif
452
453         INIT_G();
454
455 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
456         applet_long_options = wget_longopts;
457 #endif
458         /* server.allocated = target.allocated = NULL; */
459         opt_complementary = "-1" USE_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
460         opt = getopt32(argv, "csqO:P:Y:U:",
461                                 &fname_out, &dir_prefix,
462                                 &proxy_flag, &user_agent
463                                 USE_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
464                                 );
465         if (strcmp(proxy_flag, "off") == 0) {
466                 /* Use the proxy if necessary */
467                 use_proxy = 0;
468         }
469 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
470         if (headers_llist) {
471                 int size = 1;
472                 char *cp;
473                 llist_t *ll = headers_llist;
474                 while (ll) {
475                         size += strlen(ll->data) + 2;
476                         ll = ll->link;
477                 }
478                 extra_headers = cp = xmalloc(size);
479                 while (headers_llist) {
480                         cp += sprintf(cp, "%s\r\n", headers_llist->data);
481                         headers_llist = headers_llist->link;
482                 }
483         }
484 #endif
485
486         parse_url(argv[optind], &target);
487         server.host = target.host;
488         server.port = target.port;
489
490         /* Use the proxy if necessary */
491         if (use_proxy) {
492                 proxy = getenv(target.is_ftp ? "ftp_proxy" : "http_proxy");
493                 if (proxy && *proxy) {
494                         parse_url(proxy, &server);
495                 } else {
496                         use_proxy = 0;
497                 }
498         }
499
500         /* Guess an output filename */
501         if (!fname_out) {
502                 // Dirty hack. Needed because bb_get_last_path_component
503                 // will destroy trailing / by storing '\0' in last byte!
504                 if (!last_char_is(target.path, '/')) {
505                         fname_out = bb_get_last_path_component(target.path);
506 #if ENABLE_FEATURE_WGET_STATUSBAR
507                         curfile = fname_out;
508 #endif
509                 }
510                 if (!fname_out || !fname_out[0]) {
511                         /* bb_get_last_path_component writes
512                          * to last '/' only. We don't have one here... */
513                         fname_out = (char*)"index.html";
514 #if ENABLE_FEATURE_WGET_STATUSBAR
515                         curfile = fname_out;
516 #endif
517                 }
518                 if (dir_prefix != NULL)
519                         fname_out = concat_path_file(dir_prefix, fname_out);
520 #if ENABLE_FEATURE_WGET_STATUSBAR
521         } else {
522                 curfile = bb_get_last_path_component(fname_out);
523 #endif
524         }
525         /* Impossible?
526         if ((opt & WGET_OPT_CONTINUE) && !fname_out)
527                 bb_error_msg_and_die("cannot specify continue (-c) without a filename (-O)"); */
528
529         /* Determine where to start transfer */
530         if (LONE_DASH(fname_out)) {
531                 output_fd = 1;
532                 opt &= ~WGET_OPT_CONTINUE;
533         }
534         if (opt & WGET_OPT_CONTINUE) {
535                 output_fd = open(fname_out, O_WRONLY);
536                 if (output_fd >= 0) {
537                         beg_range = xlseek(output_fd, 0, SEEK_END);
538                 }
539                 /* File doesn't exist. We do not create file here yet.
540                    We are not sure it exists on remove side */
541         }
542
543         /* We want to do exactly _one_ DNS lookup, since some
544          * sites (i.e. ftp.us.debian.org) use round-robin DNS
545          * and we want to connect to only one IP... */
546         lsa = xhost2sockaddr(server.host, server.port);
547         if (!(opt & WGET_OPT_QUIET)) {
548                 fprintf(stderr, "Connecting to %s (%s)\n", server.host,
549                                 xmalloc_sockaddr2dotted(&lsa->sa));
550                 /* We leak result of xmalloc_sockaddr2dotted */
551         }
552
553         if (use_proxy || !target.is_ftp) {
554                 /*
555                  *  HTTP session
556                  */
557                 do {
558                         got_clen = 0;
559                         chunked = 0;
560
561                         if (!--try)
562                                 bb_error_msg_and_die("too many redirections");
563
564                         /* Open socket to http server */
565                         if (sfp) fclose(sfp);
566                         sfp = open_socket(lsa);
567
568                         /* Send HTTP request.  */
569                         if (use_proxy) {
570                                 fprintf(sfp, "GET %stp://%s/%s HTTP/1.1\r\n",
571                                         target.is_ftp ? "f" : "ht", target.host,
572                                         target.path);
573                         } else {
574                                 fprintf(sfp, "GET /%s HTTP/1.1\r\n", target.path);
575                         }
576
577                         fprintf(sfp, "Host: %s\r\nUser-Agent: %s\r\n",
578                                 target.host, user_agent);
579
580 #if ENABLE_FEATURE_WGET_AUTHENTICATION
581                         if (target.user) {
582                                 fprintf(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
583                                         base64enc_512(buf, target.user));
584                         }
585                         if (use_proxy && server.user) {
586                                 fprintf(sfp, "Proxy-Authorization: Basic %s\r\n",
587                                         base64enc_512(buf, server.user));
588                         }
589 #endif
590
591                         if (beg_range)
592                                 fprintf(sfp, "Range: bytes=%"OFF_FMT"d-\r\n", beg_range);
593 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
594                         if (extra_headers)
595                                 fputs(extra_headers, sfp);
596 #endif
597                         fprintf(sfp, "Connection: close\r\n\r\n");
598
599                         /*
600                         * Retrieve HTTP response line and check for "200" status code.
601                         */
602  read_response:
603                         if (fgets(buf, sizeof(buf), sfp) == NULL)
604                                 bb_error_msg_and_die("no response from server");
605
606                         str = buf;
607                         str = skip_non_whitespace(str);
608                         str = skip_whitespace(str);
609                         // FIXME: no error check
610                         // xatou wouldn't work: "200 OK"
611                         status = atoi(str);
612                         switch (status) {
613                         case 0:
614                         case 100:
615                                 while (gethdr(buf, sizeof(buf), sfp /*, &n*/) != NULL)
616                                         /* eat all remaining headers */;
617                                 goto read_response;
618                         case 200:
619                                 break;
620                         case 300:       /* redirection */
621                         case 301:
622                         case 302:
623                         case 303:
624                                 break;
625                         case 206:
626                                 if (beg_range)
627                                         break;
628                                 /*FALLTHRU*/
629                         default:
630                                 /* Show first line only and kill any ESC tricks */
631                                 buf[strcspn(buf, "\n\r\x1b")] = '\0';
632                                 bb_error_msg_and_die("server returned error: %s", buf);
633                         }
634
635                         /*
636                          * Retrieve HTTP headers.
637                          */
638                         while ((str = gethdr(buf, sizeof(buf), sfp /*, &n*/)) != NULL) {
639                                 /* gethdr did already convert the "FOO:" string to lowercase */
640                                 smalluint key = index_in_strings(keywords, *&buf) + 1;
641                                 if (key == KEY_content_length) {
642                                         content_len = BB_STRTOOFF(str, NULL, 10);
643                                         if (errno || content_len < 0) {
644                                                 bb_error_msg_and_die("content-length %s is garbage", str);
645                                         }
646                                         got_clen = 1;
647                                         continue;
648                                 }
649                                 if (key == KEY_transfer_encoding) {
650                                         if (index_in_strings(keywords, str_tolower(str)) + 1 != KEY_chunked)
651                                                 bb_error_msg_and_die("transfer encoding '%s' is not supported", str);
652                                         chunked = got_clen = 1;
653                                 }
654                                 if (key == KEY_location) {
655                                         if (str[0] == '/')
656                                                 /* free(target.allocated); */
657                                                 target.path = /* target.allocated = */ xstrdup(str+1);
658                                         else {
659                                                 parse_url(str, &target);
660                                                 if (use_proxy == 0) {
661                                                         server.host = target.host;
662                                                         server.port = target.port;
663                                                 }
664                                                 free(lsa);
665                                                 lsa = xhost2sockaddr(server.host, server.port);
666                                                 break;
667                                         }
668                                 }
669                         }
670                 } while (status >= 300);
671
672                 dfp = sfp;
673
674         } else {
675
676                 /*
677                  *  FTP session
678                  */
679                 if (!target.user)
680                         target.user = xstrdup("anonymous:busybox@");
681
682                 sfp = open_socket(lsa);
683                 if (ftpcmd(NULL, NULL, sfp, buf) != 220)
684                         bb_error_msg_and_die("%s", buf+4);
685
686                 /*
687                  * Splitting username:password pair,
688                  * trying to log in
689                  */
690                 str = strchr(target.user, ':');
691                 if (str)
692                         *(str++) = '\0';
693                 switch (ftpcmd("USER ", target.user, sfp, buf)) {
694                 case 230:
695                         break;
696                 case 331:
697                         if (ftpcmd("PASS ", str, sfp, buf) == 230)
698                                 break;
699                         /* FALLTHRU (failed login) */
700                 default:
701                         bb_error_msg_and_die("ftp login: %s", buf+4);
702                 }
703
704                 ftpcmd("TYPE I", NULL, sfp, buf);
705
706                 /*
707                  * Querying file size
708                  */
709                 if (ftpcmd("SIZE ", target.path, sfp, buf) == 213) {
710                         content_len = BB_STRTOOFF(buf+4, NULL, 10);
711                         if (errno || content_len < 0) {
712                                 bb_error_msg_and_die("SIZE value is garbage");
713                         }
714                         got_clen = 1;
715                 }
716
717                 /*
718                  * Entering passive mode
719                  */
720                 if (ftpcmd("PASV", NULL, sfp, buf) != 227) {
721  pasv_error:
722                         bb_error_msg_and_die("bad response to %s: %s", "PASV", buf);
723                 }
724                 // Response is "227 garbageN1,N2,N3,N4,P1,P2[)garbage]
725                 // Server's IP is N1.N2.N3.N4 (we ignore it)
726                 // Server's port for data connection is P1*256+P2
727                 str = strrchr(buf, ')');
728                 if (str) str[0] = '\0';
729                 str = strrchr(buf, ',');
730                 if (!str) goto pasv_error;
731                 port = xatou_range(str+1, 0, 255);
732                 *str = '\0';
733                 str = strrchr(buf, ',');
734                 if (!str) goto pasv_error;
735                 port += xatou_range(str+1, 0, 255) * 256;
736                 set_nport(lsa, htons(port));
737                 dfp = open_socket(lsa);
738
739                 if (beg_range) {
740                         sprintf(buf, "REST %"OFF_FMT"d", beg_range);
741                         if (ftpcmd(buf, NULL, sfp, buf) == 350)
742                                 content_len -= beg_range;
743                 }
744
745                 if (ftpcmd("RETR ", target.path, sfp, buf) > 150)
746                         bb_error_msg_and_die("bad response to %s: %s", "RETR", buf);
747         }
748
749         if (opt & WGET_OPT_SPIDER) {
750                 if (ENABLE_FEATURE_CLEAN_UP)
751                         fclose(sfp);
752                 return EXIT_SUCCESS;
753         }
754
755         /*
756          * Retrieve file
757          */
758
759         /* Do it before progressmeter (want to have nice error message) */
760         if (output_fd < 0)
761                 output_fd = xopen(fname_out,
762                         O_WRONLY|O_CREAT|O_EXCL|O_TRUNC);
763
764         if (!(opt & WGET_OPT_QUIET))
765                 progressmeter(-1);
766
767         if (chunked)
768                 goto get_clen;
769
770         /* Loops only if chunked */
771         while (1) {
772                 while (content_len > 0 || !got_clen) {
773                         int n;
774                         unsigned rdsz = sizeof(buf);
775
776                         if (content_len < sizeof(buf) && (chunked || got_clen))
777                                 rdsz = (unsigned)content_len;
778                         n = safe_fread(buf, rdsz, dfp);
779                         if (n <= 0) {
780                                 if (ferror(dfp)) {
781                                         /* perror will not work: ferror doesn't set errno */
782                                         bb_error_msg_and_die(bb_msg_read_error);
783                                 }
784                                 break;
785                         }
786                         xwrite(output_fd, buf, n);
787 #if ENABLE_FEATURE_WGET_STATUSBAR
788                         transferred += n;
789 #endif
790                         if (got_clen)
791                                 content_len -= n;
792                 }
793
794                 if (!chunked)
795                         break;
796
797                 safe_fgets(buf, sizeof(buf), dfp); /* This is a newline */
798  get_clen:
799                 safe_fgets(buf, sizeof(buf), dfp);
800                 content_len = STRTOOFF(buf, NULL, 16);
801                 /* FIXME: error check? */
802                 if (content_len == 0)
803                         break; /* all done! */
804         }
805
806         if (!(opt & WGET_OPT_QUIET))
807                 progressmeter(0);
808
809         if ((use_proxy == 0) && target.is_ftp) {
810                 fclose(dfp);
811                 if (ftpcmd(NULL, NULL, sfp, buf) != 226)
812                         bb_error_msg_and_die("ftp error: %s", buf+4);
813                 ftpcmd("QUIT", NULL, sfp, buf);
814         }
815
816         return EXIT_SUCCESS;
817 }