Changeset 3232 in MondoRescue for branches/3.2/mindi-busybox/networking/wget.c

Timestamp:

Jan 1, 2014, 12:47:38 AM (10 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.21.1

File:

• branches/3.2/mindi-busybox/networking/wget.c (modified) (31 diffs)

branches/3.2/mindi-busybox/networking/wget.c

@@ -9 +9 @@
  * Kuhn's copyrights are licensed GPLv2-or-later.  File as a whole remains GPLv2.
  */
+
+//usage:#define wget_trivial_usage
+//usage:    IF_FEATURE_WGET_LONG_OPTIONS(
+//usage:       "[-c|--continue] [-s|--spider] [-q|--quiet] [-O|--output-document FILE]\n"
+//usage:       "    [--header 'header: value'] [-Y|--proxy on/off] [-P DIR]\n"
+/* Since we ignore these opts, we don't show them in --help */
+/* //usage:    "    [--no-check-certificate] [--no-cache]" */
+//usage:       "    [-U|--user-agent AGENT]" IF_FEATURE_WGET_TIMEOUT(" [-T SEC]") " URL..."
+//usage:    )
+//usage:    IF_NOT_FEATURE_WGET_LONG_OPTIONS(
+//usage:       "[-csq] [-O FILE] [-Y on/off] [-P DIR] [-U AGENT]"
+//usage:            IF_FEATURE_WGET_TIMEOUT(" [-T SEC]") " URL..."
+//usage:    )
+//usage:#define wget_full_usage "\n\n"
+//usage:       "Retrieve files via HTTP or FTP\n"
+//usage:     "\n    -s  Spider mode - only check file existence"
+//usage:     "\n    -c  Continue retrieval of aborted transfer"
+//usage:     "\n    -q  Quiet"
+//usage:     "\n    -P DIR  Save to DIR (default .)"
+//usage:    IF_FEATURE_WGET_TIMEOUT(
+//usage:     "\n    -T SEC  Network read timeout is SEC seconds"
+//usage:    )
+//usage:     "\n    -O FILE Save to FILE ('-' for stdout)"
+//usage:     "\n    -U STR  Use STR for User-Agent header"
+//usage:     "\n    -Y  Use proxy ('on' or 'off')"
+
 #include "libbb.h"
 
+#if 0
+# define log_io(...) bb_error_msg(__VA_ARGS__)
+#else
+# define log_io(...) ((void)0)
+#endif
+
+
 struct host_info {
-    // May be used if we ever will want to free() all xstrdup()s...
-    /* char *allocated; */
+    char *allocated;
     const char *path;
     const char *user;
@@ -31 +63 @@
     bb_progress_t pmt;
 #endif
+        char *dir_prefix;
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+        char *post_data;
+        char *extra_headers;
+#endif
+        char *fname_out;        /* where to direct output (-O) */
+        const char *proxy_flag; /* Use proxies if env vars are set */
+        const char *user_agent; /* "User-Agent" header field */
 #if ENABLE_FEATURE_WGET_TIMEOUT
     unsigned timeout_seconds;
 #endif
+    int output_fd;
+    int o_flags;
     smallint chunked;         /* chunked transfer encoding */
     smallint got_clen;        /* got content-length: from server  */
+    /* Local downloads do benefit from big buffer.
+     * With 512 byte buffer, it was measured to be
+     * an order of magnitude slower than with big one.
+     */
+    uint64_t just_to_align_next_member;
+    char wget_buf[CONFIG_FEATURE_COPYBUF_KB*1024];
 } FIX_ALIASING;
-#define G (*(struct globals*)&bb_common_bufsiz1)
-struct BUG_G_too_big {
-    char BUG_G_too_big[sizeof(G) <= COMMON_BUFSIZE ? 1 : -1];
-};
+#define G (*ptr_to_globals)
 #define INIT_G() do { \
+        SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
     IF_FEATURE_WGET_TIMEOUT(G.timeout_seconds = 900;) \
 } while (0)
@@ -74 +120 @@
 
     if (flag == PROGRESS_START)
-        bb_progress_init(&G.pmt);
-
-    bb_progress_update(&G.pmt, G.curfile, G.beg_range, G.transferred,
-               G.chunked ? 0 : G.beg_range + G.transferred + G.content_len);
+        bb_progress_init(&G.pmt, G.curfile);
+
+    bb_progress_update(&G.pmt,
+            G.beg_range,
+            G.transferred,
+            (G.chunked || !G.got_clen) ? 0 : G.beg_range + G.transferred + G.content_len
+    );
 
     if (flag == PROGRESS_END) {
+        bb_progress_free(&G.pmt);
         bb_putchar_stderr('\n');
         G.transferred = 0;
@@ -125 +175 @@
 }
 
-/* Read NMEMB bytes into PTR from STREAM.  Returns the number of bytes read,
- * and a short count if an eof or non-interrupt error is encountered.  */
-static size_t safe_fread(void *ptr, size_t nmemb, FILE *stream)
-{
-    size_t ret;
-    char *p = (char*)ptr;
-
-    do {
-        clearerr(stream);
-        errno = 0;
-        ret = fread(p, 1, nmemb, stream);
-        p += ret;
-        nmemb -= ret;
-    } while (nmemb && ferror(stream) && errno == EINTR);
-
-    return p - (char*)ptr;
-}
-
-/* Read a line or SIZE-1 bytes into S, whichever is less, from STREAM.
- * Returns S, or NULL if an eof or non-interrupt error is encountered.  */
-static char *safe_fgets(char *s, int size, FILE *stream)
-{
-    char *ret;
-
-    do {
-        clearerr(stream);
-        errno = 0;
-        ret = fgets(s, size, stream);
-    } while (ret == NULL && ferror(stream) && errno == EINTR);
-
-    return ret;
-}
-
 #if ENABLE_FEATURE_WGET_AUTHENTICATION
-/* Base64-encode character string. buf is assumed to be char buf[512]. */
-static char *base64enc_512(char buf[512], const char *str)
+/* Base64-encode character string. */
+static char *base64enc(const char *str)
 {
     unsigned len = strlen(str);
-    if (len > 512/4*3 - 10) /* paranoia */
-        len = 512/4*3 - 10;
-    bb_uuencode(buf, str, len, bb_uuenc_tbl_base64);
-    return buf;
+    if (len > sizeof(G.wget_buf)/4*3 - 10) /* paranoia */
+        len = sizeof(G.wget_buf)/4*3 - 10;
+    bb_uuencode(G.wget_buf, str, len, bb_uuenc_tbl_base64);
+    return G.wget_buf;
 }
 #endif
@@ -187 +204 @@
     fp = fdopen(xconnect_stream(lsa), "r+");
     if (fp == NULL)
-        bb_perror_msg_and_die("fdopen");
+        bb_perror_msg_and_die(bb_msg_memory_exhausted);
 
     return fp;
 }
 
-static int ftpcmd(const char *s1, const char *s2, FILE *fp, char *buf)
+/* Returns '\n' if it was seen, else '\0'. Trims at first '\r' or '\n' */
+static char fgets_and_trim(FILE *fp)
+{
+    char c;
+    char *buf_ptr;
+
+    if (fgets(G.wget_buf, sizeof(G.wget_buf) - 1, fp) == NULL)
+        bb_perror_msg_and_die("error getting response");
+
+    buf_ptr = strchrnul(G.wget_buf, '\n');
+    c = *buf_ptr;
+    *buf_ptr = '\0';
+    buf_ptr = strchrnul(G.wget_buf, '\r');
+    *buf_ptr = '\0';
+
+    log_io("< %s", G.wget_buf);
+
+    return c;
+}
+
+static int ftpcmd(const char *s1, const char *s2, FILE *fp)
 {
     int result;
     if (s1) {
-        if (!s2) s2 = "";
+        if (!s2)
+            s2 = "";
         fprintf(fp, "%s%s\r\n", s1, s2);
         fflush(fp);
+        log_io("> %s%s", s1, s2);
     }
 
     do {
-        char *buf_ptr;
-
-        if (fgets(buf, 510, fp) == NULL) {
-            bb_perror_msg_and_die("error getting response");
-        }
-        buf_ptr = strstr(buf, "\r\n");
-        if (buf_ptr) {
-            *buf_ptr = '\0';
-        }
-    } while (!isdigit(buf[0]) || buf[3] != ' ');
-
-    buf[3] = '\0';
-    result = xatoi_positive(buf);
-    buf[3] = ' ';
+        fgets_and_trim(fp);
+    } while (!isdigit(G.wget_buf[0]) || G.wget_buf[3] != ' ');
+
+    G.wget_buf[3] = '\0';
+    result = xatoi_positive(G.wget_buf);
+    G.wget_buf[3] = ' ';
     return result;
 }
 
-static void parse_url(char *src_url, struct host_info *h)
+static void parse_url(const char *src_url, struct host_info *h)
 {
     char *url, *p, *sp;
 
-    /* h->allocated = */ url = xstrdup(src_url);
+    free(h->allocated);
+    h->allocated = url = xstrdup(src_url);
 
     if (strncmp(url, "http://", 7) == 0) {
@@ -271 +303 @@
     sp = strrchr(h->host, '@');
     if (sp != NULL) {
-        h->user = h->host;
+        // URL-decode "user:password" string before base64-encoding:
+        // wget http://test:my%20pass@example.com should send
+        // Authorization: Basic dGVzdDpteSBwYXNz
+        // which decodes to "test:my pass".
+        // Standard wget and curl do this too.
         *sp = '\0';
+        h->user = percent_decode_in_place(h->host, /*strict:*/ 0);
         h->host = sp + 1;
     }
@@ -279 +316 @@
 }
 
-static char *gethdr(char *buf, size_t bufsiz, FILE *fp /*, int *istrunc*/)
+static char *gethdr(FILE *fp)
 {
     char *s, *hdrval;
     int c;
 
-    /* *istrunc = 0; */
-
     /* retrieve header line */
-    if (fgets(buf, bufsiz, fp) == NULL)
+    c = fgets_and_trim(fp);
+
+    /* end of the headers? */
+    if (G.wget_buf[0] == '\0')
         return NULL;
 
-    /* see if we are at the end of the headers */
-    for (s = buf; *s == '\r'; ++s)
-        continue;
-    if (*s == '\n')
-        return NULL;
-
     /* convert the header name to lower case */
-    for (s = buf; isalnum(*s) || *s == '-' || *s == '.'; ++s) {
+    for (s = G.wget_buf; isalnum(*s) || *s == '-' || *s == '.'; ++s) {
         /* tolower for "A-Z", no-op for "0-9a-z-." */
-        *s = (*s | 0x20);
+        *s |= 0x20;
     }
 
     /* verify we are at the end of the header name */
     if (*s != ':')
-        bb_error_msg_and_die("bad header line: %s", sanitize_string(buf));
+        bb_error_msg_and_die("bad header line: %s", sanitize_string(G.wget_buf));
 
     /* locate the start of the header value */
@@ -310 +342 @@
     hdrval = skip_whitespace(s);
 
-    /* locate the end of header */
-    while (*s && *s != '\r' && *s != '\n')
-        ++s;
-
-    /* end of header found */
-    if (*s) {
-        *s = '\0';
-        return hdrval;
-    }
-
-    /* Rats! The buffer isn't big enough to hold the entire header value */
-    while (c = getc(fp), c != EOF && c != '\n')
-        continue;
-    /* *istrunc = 1; */
+    if (c != '\n') {
+        /* Rats! The buffer isn't big enough to hold the entire header value */
+        while (c = getc(fp), c != EOF && c != '\n')
+            continue;
+    }
+
     return hdrval;
 }
 
-#if ENABLE_FEATURE_WGET_LONG_OPTIONS
-static char *URL_escape(const char *str)
-{
-    /* URL encode, see RFC 2396 */
-    char *dst;
-    char *res = dst = xmalloc(strlen(str) * 3 + 1);
-    unsigned char c;
-
-    while (1) {
-        c = *str++;
-        if (c == '\0'
-        /* || strchr("!&'()*-.=_~", c) - more code */
-         || c == '!'
-         || c == '&'
-         || c == '\''
-         || c == '('
-         || c == ')'
-         || c == '*'
-         || c == '-'
-         || c == '.'
-         || c == '='
-         || c == '_'
-         || c == '~'
-         || (c >= '0' && c <= '9')
-         || ((c|0x20) >= 'a' && (c|0x20) <= 'z')
-        ) {
-            *dst++ = c;
-            if (c == '\0')
-                return res;
-        } else {
-            *dst++ = '%';
-            *dst++ = bb_hexdigits_upcase[c >> 4];
-            *dst++ = bb_hexdigits_upcase[c & 0xf];
-        }
-    }
-}
-#endif
+static void reset_beg_range_to_zero(void)
+{
+    bb_error_msg("restart failed");
+    G.beg_range = 0;
+    xlseek(G.output_fd, 0, SEEK_SET);
+    /* Done at the end instead: */
+    /* ftruncate(G.output_fd, 0); */
+}
 
 static FILE* prepare_ftp_session(FILE **dfpp, struct host_info *target, len_and_sockaddr *lsa)
 {
-    char buf[512];
     FILE *sfp;
     char *str;
@@ -376 +370 @@
 
     sfp = open_socket(lsa);
-    if (ftpcmd(NULL, NULL, sfp, buf) != 220)
-        bb_error_msg_and_die("%s", sanitize_string(buf+4));
+    if (ftpcmd(NULL, NULL, sfp) != 220)
+        bb_error_msg_and_die("%s", sanitize_string(G.wget_buf + 4));
 
     /*
@@ -386 +380 @@
     if (str)
         *str++ = '\0';
-    switch (ftpcmd("USER ", target->user, sfp, buf)) {
+    switch (ftpcmd("USER ", target->user, sfp)) {
     case 230:
         break;
     case 331:
-        if (ftpcmd("PASS ", str, sfp, buf) == 230)
+        if (ftpcmd("PASS ", str, sfp) == 230)
             break;
         /* fall through (failed login) */
     default:
-        bb_error_msg_and_die("ftp login: %s", sanitize_string(buf+4));
-    }
-
-    ftpcmd("TYPE I", NULL, sfp, buf);
+        bb_error_msg_and_die("ftp login: %s", sanitize_string(G.wget_buf + 4));
+    }
+
+    ftpcmd("TYPE I", NULL, sfp);
 
     /*
      * Querying file size
      */
-    if (ftpcmd("SIZE ", target->path, sfp, buf) == 213) {
-        G.content_len = BB_STRTOOFF(buf+4, NULL, 10);
+    if (ftpcmd("SIZE ", target->path, sfp) == 213) {
+        G.content_len = BB_STRTOOFF(G.wget_buf + 4, NULL, 10);
         if (G.content_len < 0 || errno) {
             bb_error_msg_and_die("SIZE value is garbage");
@@ -413 +407 @@
      * Entering passive mode
      */
-    if (ftpcmd("PASV", NULL, sfp, buf) != 227) {
+    if (ftpcmd("PASV", NULL, sfp) != 227) {
  pasv_error:
-        bb_error_msg_and_die("bad response to %s: %s", "PASV", sanitize_string(buf));
+        bb_error_msg_and_die("bad response to %s: %s", "PASV", sanitize_string(G.wget_buf));
     }
     // Response is "227 garbageN1,N2,N3,N4,P1,P2[)garbage]
     // Server's IP is N1.N2.N3.N4 (we ignore it)
     // Server's port for data connection is P1*256+P2
-    str = strrchr(buf, ')');
+    str = strrchr(G.wget_buf, ')');
     if (str) str[0] = '\0';
-    str = strrchr(buf, ',');
+    str = strrchr(G.wget_buf, ',');
     if (!str) goto pasv_error;
     port = xatou_range(str+1, 0, 255);
     *str = '\0';
-    str = strrchr(buf, ',');
+    str = strrchr(G.wget_buf, ',');
     if (!str) goto pasv_error;
     port += xatou_range(str+1, 0, 255) * 256;
-    set_nport(lsa, htons(port));
+    set_nport(&lsa->u.sa, htons(port));
 
     *dfpp = open_socket(lsa);
 
-    if (G.beg_range) {
-        sprintf(buf, "REST %"OFF_FMT"u", G.beg_range);
-        if (ftpcmd(buf, NULL, sfp, buf) == 350)
+    if (G.beg_range != 0) {
+        sprintf(G.wget_buf, "REST %"OFF_FMT"u", G.beg_range);
+        if (ftpcmd(G.wget_buf, NULL, sfp) == 350)
             G.content_len -= G.beg_range;
-    }
-
-    if (ftpcmd("RETR ", target->path, sfp, buf) > 150)
-        bb_error_msg_and_die("bad response to %s: %s", "RETR", sanitize_string(buf));
+        else
+            reset_beg_range_to_zero();
+    }
+
+    if (ftpcmd("RETR ", target->path, sfp) > 150)
+        bb_error_msg_and_die("bad response to %s: %s", "RETR", sanitize_string(G.wget_buf));
 
     return sfp;
 }
 
-static void NOINLINE retrieve_file_data(FILE *dfp, int output_fd)
-{
-    char buf[4*1024]; /* made bigger to speed up local xfers */
+static void NOINLINE retrieve_file_data(FILE *dfp)
+{
 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 # if ENABLE_FEATURE_WGET_TIMEOUT
-    unsigned second_cnt;
+    unsigned second_cnt = G.timeout_seconds;
 # endif
     struct pollfd polldata;
@@ -466 +461 @@
 
 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
+        /* Must use nonblocking I/O, otherwise fread will loop
+         * and *block* until it reads full buffer,
+         * which messes up progress bar and/or timeout logic.
+         * Because of nonblocking I/O, we need to dance
+         * very carefully around EAGAIN. See explanation at
+         * clearerr() calls.
+         */
         ndelay_on(polldata.fd);
 #endif
@@ -472 +474 @@
             unsigned rdsz;
 
-            rdsz = sizeof(buf);
-            if (G.got_clen) {
-                if (G.content_len < (off_t)sizeof(buf)) {
-                    if ((int)G.content_len <= 0)
-                        break;
-                    rdsz = (unsigned)G.content_len;
-                }
-            }
 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
-# if ENABLE_FEATURE_WGET_TIMEOUT
-            second_cnt = G.timeout_seconds;
-# endif
-            while (1) {
-                if (safe_poll(&polldata, 1, 1000) != 0)
-                    break; /* error, EOF, or data is available */
-# if ENABLE_FEATURE_WGET_TIMEOUT
-                if (second_cnt != 0 && --second_cnt == 0) {
-                    progress_meter(PROGRESS_END);
-                    bb_perror_msg_and_die("download timed out");
-                }
-# endif
-                /* Needed for "stalled" indicator */
-                progress_meter(PROGRESS_BUMP);
-            }
-#endif
             /* fread internally uses read loop, which in our case
              * is usually exited when we get EAGAIN.
@@ -506 +484 @@
              */
             clearerr(dfp);
+#endif
             errno = 0;
-            n = safe_fread(buf, rdsz, dfp);
-            /* man fread:
+            rdsz = sizeof(G.wget_buf);
+            if (G.got_clen) {
+                if (G.content_len < (off_t)sizeof(G.wget_buf)) {
+                    if ((int)G.content_len <= 0)
+                        break;
+                    rdsz = (unsigned)G.content_len;
+                }
+            }
+            n = fread(G.wget_buf, 1, rdsz, dfp);
+
+            if (n > 0) {
+                xwrite(G.output_fd, G.wget_buf, n);
+#if ENABLE_FEATURE_WGET_STATUSBAR
+                G.transferred += n;
+#endif
+                if (G.got_clen) {
+                    G.content_len -= n;
+                    if (G.content_len == 0)
+                        break;
+                }
+#if ENABLE_FEATURE_WGET_TIMEOUT
+                second_cnt = G.timeout_seconds;
+#endif
+                continue;
+            }
+
+            /* n <= 0.
+             * man fread:
              * If error occurs, or EOF is reached, the return value
              * is a short item count (or zero).
              * fread does not distinguish between EOF and error.
              */
-            if (n <= 0) {
-#if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
-                if (errno == EAGAIN) /* poll lied, there is no data? */
-                    continue; /* yes */
-#endif
-                if (ferror(dfp))
+            if (errno != EAGAIN) {
+                if (ferror(dfp)) {
+                    progress_meter(PROGRESS_END);
                     bb_perror_msg_and_die(bb_msg_read_error);
+                }
                 break; /* EOF, not error */
             }
 
-            xwrite(output_fd, buf, n);
-#if ENABLE_FEATURE_WGET_STATUSBAR
-            G.transferred += n;
+#if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
+            /* It was EAGAIN. There is no data. Wait up to one second
+             * then abort if timed out, or update the bar and try reading again.
+             */
+            if (safe_poll(&polldata, 1, 1000) == 0) {
+# if ENABLE_FEATURE_WGET_TIMEOUT
+                if (second_cnt != 0 && --second_cnt == 0) {
+                    progress_meter(PROGRESS_END);
+                    bb_error_msg_and_die("download timed out");
+                }
+# endif
+                /* We used to loop back to poll here,
+                 * but there is no great harm in letting fread
+                 * to try reading anyway.
+                 */
+            }
+            /* Need to do it _every_ second for "stalled" indicator
+             * to be shown properly.
+             */
             progress_meter(PROGRESS_BUMP);
 #endif
-            if (G.got_clen) {
-                G.content_len -= n;
-                if (G.content_len == 0)
-                    break;
-            }
-        }
+        } /* while (reading data) */
+
 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
-        ndelay_off(polldata.fd);
-#endif
-
+        clearerr(dfp);
+        ndelay_off(polldata.fd); /* else fgets can get very unhappy */
+#endif
         if (!G.chunked)
             break;
 
-        safe_fgets(buf, sizeof(buf), dfp); /* This is a newline */
+        fgets_and_trim(dfp); /* Eat empty line */
  get_clen:
-        safe_fgets(buf, sizeof(buf), dfp);
-        G.content_len = STRTOOFF(buf, NULL, 16);
+        fgets_and_trim(dfp);
+        G.content_len = STRTOOFF(G.wget_buf, NULL, 16);
         /* FIXME: error check? */
         if (G.content_len == 0)
             break; /* all done! */
         G.got_clen = 1;
-    }
-
+        /*
+         * Note that fgets may result in some data being buffered in dfp.
+         * We loop back to fread, which will retrieve this data.
+         * Also note that code has to be arranged so that fread
+         * is done _before_ one-second poll wait - poll doesn't know
+         * about stdio buffering and can result in spurious one second waits!
+         */
+    }
+
+    /* If -c failed, we restart from the beginning,
+     * but we do not truncate file then, we do it only now, at the end.
+     * This lets user to ^C if his 99% complete 10 GB file download
+     * failed to restart *without* losing the almost complete file.
+     */
+    {
+        off_t pos = lseek(G.output_fd, 0, SEEK_CUR);
+        if (pos != (off_t)-1)
+            ftruncate(G.output_fd, pos);
+    }
+
+    /* Draw full bar and free its resources */
+    G.chunked = 0;  /* makes it show 100% even for chunked download */
+    G.got_clen = 1; /* makes it show 100% even for download of (formerly) unknown size */
     progress_meter(PROGRESS_END);
 }
 
-int wget_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
-int wget_main(int argc UNUSED_PARAM, char **argv)
-{
-    char buf[512];
-    struct host_info server, target;
+static void download_one_url(const char *url)
+{
+    bool use_proxy;                 /* Use proxies if env vars are set  */
+    int redir_limit;
     len_and_sockaddr *lsa;
-    unsigned opt;
-    int redir_limit;
-    char *proxy = NULL;
-    char *dir_prefix = NULL;
-#if ENABLE_FEATURE_WGET_LONG_OPTIONS
-    char *post_data;
-    char *extra_headers = NULL;
-    llist_t *headers_llist = NULL;
-#endif
     FILE *sfp;                      /* socket to web/ftp server         */
     FILE *dfp;                      /* socket to ftp server (data)      */
-    char *fname_out;                /* where to direct output (-O)      */
-    int output_fd = -1;
-    bool use_proxy;                 /* Use proxies if env vars are set  */
-    const char *proxy_flag = "on";  /* Use proxies if env vars are set  */
-    const char *user_agent = "Wget";/* "User-Agent" header field        */
-
-    static const char keywords[] ALIGN1 =
-        "content-length\0""transfer-encoding\0""chunked\0""location\0";
-    enum {
-        KEY_content_length = 1, KEY_transfer_encoding, KEY_chunked, KEY_location
-    };
-#if ENABLE_FEATURE_WGET_LONG_OPTIONS
-    static const char wget_longopts[] ALIGN1 =
-        /* name, has_arg, val */
-        "continue\0"         No_argument       "c"
-        "spider\0"           No_argument       "s"
-        "quiet\0"            No_argument       "q"
-        "output-document\0"  Required_argument "O"
-        "directory-prefix\0" Required_argument "P"
-        "proxy\0"            Required_argument "Y"
-        "user-agent\0"       Required_argument "U"
-#if ENABLE_FEATURE_WGET_TIMEOUT
-        "timeout\0"          Required_argument "T"
-#endif
-        /* Ignored: */
-        // "tries\0"            Required_argument "t"
-        /* Ignored (we always use PASV): */
-        "passive-ftp\0"      No_argument       "\xff"
-        "header\0"           Required_argument "\xfe"
-        "post-data\0"        Required_argument "\xfd"
-        /* Ignored (we don't do ssl) */
-        "no-check-certificate\0" No_argument   "\xfc"
-        ;
-#endif
-
-    INIT_G();
-
-#if ENABLE_FEATURE_WGET_LONG_OPTIONS
-    applet_long_options = wget_longopts;
-#endif
-    /* server.allocated = target.allocated = NULL; */
-    opt_complementary = "-1" IF_FEATURE_WGET_TIMEOUT(":T+") IF_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
-    opt = getopt32(argv, "csqO:P:Y:U:T:" /*ignored:*/ "t:",
-                &fname_out, &dir_prefix,
-                &proxy_flag, &user_agent,
-                IF_FEATURE_WGET_TIMEOUT(&G.timeout_seconds) IF_NOT_FEATURE_WGET_TIMEOUT(NULL),
-                NULL /* -t RETRIES */
-                IF_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
-                IF_FEATURE_WGET_LONG_OPTIONS(, &post_data)
-                );
-#if ENABLE_FEATURE_WGET_LONG_OPTIONS
-    if (headers_llist) {
-        int size = 1;
-        char *cp;
-        llist_t *ll = headers_llist;
-        while (ll) {
-            size += strlen(ll->data) + 2;
-            ll = ll->link;
-        }
-        extra_headers = cp = xmalloc(size);
-        while (headers_llist) {
-            cp += sprintf(cp, "%s\r\n", (char*)llist_pop(&headers_llist));
-        }
-    }
-#endif
-
-    /* TODO: compat issue: should handle "wget URL1 URL2..." */
-
+    char *proxy = NULL;
+    char *fname_out_alloc;
+    char *redirected_path = NULL;
+    struct host_info server;
+    struct host_info target;
+
+    server.allocated = NULL;
+    target.allocated = NULL;
+    server.user = NULL;
     target.user = NULL;
-    parse_url(argv[optind], &target);
+
+    parse_url(url, &target);
 
     /* Use the proxy if necessary */
-    use_proxy = (strcmp(proxy_flag, "off") != 0);
+    use_proxy = (strcmp(G.proxy_flag, "off") != 0);
     if (use_proxy) {
         proxy = getenv(target.is_ftp ? "ftp_proxy" : "http_proxy");
-        if (proxy && proxy[0]) {
-            server.user = NULL;
+        use_proxy = (proxy && proxy[0]);
+        if (use_proxy)
             parse_url(proxy, &server);
-        } else {
-            use_proxy = 0;
-        }
     }
     if (!use_proxy) {
         server.port = target.port;
         if (ENABLE_FEATURE_IPV6) {
-            server.host = xstrdup(target.host);
+            //free(server.allocated); - can't be non-NULL
+            server.host = server.allocated = xstrdup(target.host);
         } else {
             server.host = target.host;
@@ -665 +631 @@
         strip_ipv6_scope_id(target.host);
 
-    /* Guess an output filename, if there was no -O FILE */
-    if (!(opt & WGET_OPT_OUTNAME)) {
-        fname_out = bb_get_last_path_component_nostrip(target.path);
+    /* If there was no -O FILE, guess output filename */
+    fname_out_alloc = NULL;
+    if (!(option_mask32 & WGET_OPT_OUTNAME)) {
+        G.fname_out = bb_get_last_path_component_nostrip(target.path);
         /* handle "wget http://kernel.org//" */
-        if (fname_out[0] == '/' || !fname_out[0])
-            fname_out = (char*)"index.html";
+        if (G.fname_out[0] == '/' || !G.fname_out[0])
+            G.fname_out = (char*)"index.html";
         /* -P DIR is considered only if there was no -O FILE */
-        if (dir_prefix)
-            fname_out = concat_path_file(dir_prefix, fname_out);
-    } else {
-        if (LONE_DASH(fname_out)) {
-            /* -O - */
-            output_fd = 1;
-            opt &= ~WGET_OPT_CONTINUE;
+        if (G.dir_prefix)
+            G.fname_out = fname_out_alloc = concat_path_file(G.dir_prefix, G.fname_out);
+        else {
+            /* redirects may free target.path later, need to make a copy */
+            G.fname_out = fname_out_alloc = xstrdup(G.fname_out);
         }
     }
 #if ENABLE_FEATURE_WGET_STATUSBAR
-    G.curfile = bb_get_last_path_component_nostrip(fname_out);
-#endif
-
-    /* Impossible?
-    if ((opt & WGET_OPT_CONTINUE) && !fname_out)
-        bb_error_msg_and_die("can't specify continue (-c) without a filename (-O)");
-    */
+    G.curfile = bb_get_last_path_component_nostrip(G.fname_out);
+#endif
 
     /* Determine where to start transfer */
-    if (opt & WGET_OPT_CONTINUE) {
-        output_fd = open(fname_out, O_WRONLY);
-        if (output_fd >= 0) {
-            G.beg_range = xlseek(output_fd, 0, SEEK_END);
+    G.beg_range = 0;
+    if (option_mask32 & WGET_OPT_CONTINUE) {
+        G.output_fd = open(G.fname_out, O_WRONLY);
+        if (G.output_fd >= 0) {
+            G.beg_range = xlseek(G.output_fd, 0, SEEK_END);
         }
         /* File doesn't exist. We do not create file here yet.
-         * We are not sure it exists on remove side */
+         * We are not sure it exists on remote side */
     }
 
@@ -703 +664 @@
  resolve_lsa:
     lsa = xhost2sockaddr(server.host, server.port);
-    if (!(opt & WGET_OPT_QUIET)) {
+    if (!(option_mask32 & WGET_OPT_QUIET)) {
         char *s = xmalloc_sockaddr2dotted(&lsa->u.sa);
         fprintf(stderr, "Connecting to %s (%s)\n", server.host, s);
@@ -709 +670 @@
     }
  establish_session:
+    /*G.content_len = 0; - redundant, got_clen = 0 is enough */
+    G.got_clen = 0;
+    G.chunked = 0;
     if (use_proxy || !target.is_ftp) {
         /*
@@ -716 +680 @@
         int status;
 
+
         /* Open socket to http server */
         sfp = open_socket(lsa);
@@ -725 +690 @@
                 target.path);
         } else {
-            if (opt & WGET_OPT_POST_DATA)
+            if (option_mask32 & WGET_OPT_POST_DATA)
                 fprintf(sfp, "POST /%s HTTP/1.1\r\n", target.path);
             else
@@ -732 +697 @@
 
         fprintf(sfp, "Host: %s\r\nUser-Agent: %s\r\n",
-            target.host, user_agent);
+            target.host, G.user_agent);
 
         /* Ask server to close the connection as soon as we are done
@@ -742 +707 @@
         if (target.user) {
             fprintf(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
-                base64enc_512(buf, target.user));
+                base64enc(target.user));
         }
         if (use_proxy && server.user) {
             fprintf(sfp, "Proxy-Authorization: Basic %s\r\n",
-                base64enc_512(buf, server.user));
-        }
-#endif
-
-        if (G.beg_range)
+                base64enc(server.user));
+        }
+#endif
+
+        if (G.beg_range != 0)
             fprintf(sfp, "Range: bytes=%"OFF_FMT"u-\r\n", G.beg_range);
 
 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
-        if (extra_headers)
-            fputs(extra_headers, sfp);
-
-        if (opt & WGET_OPT_POST_DATA) {
-            char *estr = URL_escape(post_data);
+        if (G.extra_headers)
+            fputs(G.extra_headers, sfp);
+
+        if (option_mask32 & WGET_OPT_POST_DATA) {
             fprintf(sfp,
                 "Content-Type: application/x-www-form-urlencoded\r\n"
@@ -764 +728 @@
                 "\r\n"
                 "%s",
-                (int) strlen(estr), estr
+                (int) strlen(G.post_data), G.post_data
             );
-            free(estr);
         } else
 #endif
@@ -779 +742 @@
          */
  read_response:
-        if (fgets(buf, sizeof(buf), sfp) == NULL)
-            bb_error_msg_and_die("no response from server");
-
-        str = buf;
+        fgets_and_trim(sfp);
+
+        str = G.wget_buf;
         str = skip_non_whitespace(str);
         str = skip_whitespace(str);
@@ -791 +753 @@
         case 0:
         case 100:
-            while (gethdr(buf, sizeof(buf), sfp /*, &n*/) != NULL)
+            while (gethdr(sfp) != NULL)
                 /* eat all remaining headers */;
             goto read_response;
@@ -820 +782 @@
 */
         case 204:
+            if (G.beg_range != 0) {
+                /* "Range:..." was not honored by the server.
+                 * Restart download from the beginning.
+                 */
+                reset_beg_range_to_zero();
+            }
             break;
         case 300:  /* redirection */
@@ -826 +794 @@
         case 303:
             break;
-        case 206:
-            if (G.beg_range)
+        case 206: /* Partial Content */
+            if (G.beg_range != 0)
+                /* "Range:..." worked. Good. */
                 break;
+            /* Partial Content even though we did not ask for it??? */
             /* fall through */
         default:
-            bb_error_msg_and_die("server returned error: %s", sanitize_string(buf));
+            bb_error_msg_and_die("server returned error: %s", sanitize_string(G.wget_buf));
         }
 
@@ -837 +807 @@
          * Retrieve HTTP headers.
          */
-        while ((str = gethdr(buf, sizeof(buf), sfp /*, &n*/)) != NULL) {
+        while ((str = gethdr(sfp)) != NULL) {
+            static const char keywords[] ALIGN1 =
+                "content-length\0""transfer-encoding\0""location\0";
+            enum {
+                KEY_content_length = 1, KEY_transfer_encoding, KEY_location
+            };
+            smalluint key;
+
             /* gethdr converted "FOO:" string to lowercase */
-            smalluint key;
+
             /* strip trailing whitespace */
             char *s = strchrnul(str, '\0') - 1;
@@ -846 +823 @@
                 s--;
             }
-            key = index_in_strings(keywords, buf) + 1;
+            key = index_in_strings(keywords, G.wget_buf) + 1;
             if (key == KEY_content_length) {
                 G.content_len = BB_STRTOOFF(str, NULL, 10);
@@ -856 +833 @@
             }
             if (key == KEY_transfer_encoding) {
-                if (index_in_strings(keywords, str_tolower(str)) + 1 != KEY_chunked)
+                if (strcmp(str_tolower(str), "chunked") != 0)
                     bb_error_msg_and_die("transfer encoding '%s' is not supported", sanitize_string(str));
-                G.chunked = G.got_clen = 1;
+                G.chunked = 1;
             }
             if (key == KEY_location && status >= 300) {
@@ -864 +841 @@
                     bb_error_msg_and_die("too many redirections");
                 fclose(sfp);
-                G.got_clen = 0;
-                G.chunked = 0;
-                if (str[0] == '/')
-                    /* free(target.allocated); */
-                    target.path = /* target.allocated = */ xstrdup(str+1);
+                if (str[0] == '/') {
+                    free(redirected_path);
+                    target.path = redirected_path = xstrdup(str+1);
                     /* lsa stays the same: it's on the same server */
-                else {
+                } else {
                     parse_url(str, &target);
                     if (!use_proxy) {
+                        free(server.allocated);
+                        server.allocated = NULL;
                         server.host = target.host;
                         /* strip_ipv6_scope_id(target.host); - no! */
@@ -897 +874 @@
     }
 
-    if (opt & WGET_OPT_SPIDER) {
-        if (ENABLE_FEATURE_CLEAN_UP)
-            fclose(sfp);
-        return EXIT_SUCCESS;
-    }
-
-    if (output_fd < 0) {
-        int o_flags = O_WRONLY | O_CREAT | O_TRUNC | O_EXCL;
+    free(lsa);
+
+    if (!(option_mask32 & WGET_OPT_SPIDER)) {
+        if (G.output_fd < 0)
+            G.output_fd = xopen(G.fname_out, G.o_flags);
+        retrieve_file_data(dfp);
+        if (!(option_mask32 & WGET_OPT_OUTNAME)) {
+            xclose(G.output_fd);
+            G.output_fd = -1;
+        }
+    }
+
+    if (dfp != sfp) {
+        /* It's ftp. Close data connection properly */
+        fclose(dfp);
+        if (ftpcmd(NULL, NULL, sfp) != 226)
+            bb_error_msg_and_die("ftp error: %s", sanitize_string(G.wget_buf + 4));
+        /* ftpcmd("QUIT", NULL, sfp); - why bother? */
+    }
+    fclose(sfp);
+
+    free(server.allocated);
+    free(target.allocated);
+    free(fname_out_alloc);
+    free(redirected_path);
+}
+
+int wget_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int wget_main(int argc UNUSED_PARAM, char **argv)
+{
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    static const char wget_longopts[] ALIGN1 =
+        /* name, has_arg, val */
+        "continue\0"         No_argument       "c"
+//FIXME: -s isn't --spider, it's --save-headers!
+        "spider\0"           No_argument       "s"
+        "quiet\0"            No_argument       "q"
+        "output-document\0"  Required_argument "O"
+        "directory-prefix\0" Required_argument "P"
+        "proxy\0"            Required_argument "Y"
+        "user-agent\0"       Required_argument "U"
+#if ENABLE_FEATURE_WGET_TIMEOUT
+        "timeout\0"          Required_argument "T"
+#endif
+        /* Ignored: */
+        // "tries\0"            Required_argument "t"
+        /* Ignored (we always use PASV): */
+        "passive-ftp\0"      No_argument       "\xff"
+        "header\0"           Required_argument "\xfe"
+        "post-data\0"        Required_argument "\xfd"
+        /* Ignored (we don't do ssl) */
+        "no-check-certificate\0" No_argument   "\xfc"
+        /* Ignored (we don't support caching) */
+        "no-cache\0"         No_argument       "\xfb"
+        ;
+#endif
+
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    llist_t *headers_llist = NULL;
+#endif
+
+    INIT_G();
+
+    IF_FEATURE_WGET_TIMEOUT(G.timeout_seconds = 900;)
+    G.proxy_flag = "on";   /* use proxies if env vars are set */
+    G.user_agent = "Wget"; /* "User-Agent" header field */
+
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    applet_long_options = wget_longopts;
+#endif
+    opt_complementary = "-1" IF_FEATURE_WGET_TIMEOUT(":T+") IF_FEATURE_WGET_LONG_OPTIONS(":\xfe::");
+    getopt32(argv, "csqO:P:Y:U:T:" /*ignored:*/ "t:",
+        &G.fname_out, &G.dir_prefix,
+        &G.proxy_flag, &G.user_agent,
+        IF_FEATURE_WGET_TIMEOUT(&G.timeout_seconds) IF_NOT_FEATURE_WGET_TIMEOUT(NULL),
+        NULL /* -t RETRIES */
+        IF_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
+        IF_FEATURE_WGET_LONG_OPTIONS(, &G.post_data)
+    );
+    argv += optind;
+
+#if ENABLE_FEATURE_WGET_LONG_OPTIONS
+    if (headers_llist) {
+        int size = 1;
+        char *cp;
+        llist_t *ll = headers_llist;
+        while (ll) {
+            size += strlen(ll->data) + 2;
+            ll = ll->link;
+        }
+        G.extra_headers = cp = xmalloc(size);
+        while (headers_llist) {
+            cp += sprintf(cp, "%s\r\n", (char*)llist_pop(&headers_llist));
+        }
+    }
+#endif
+
+    G.output_fd = -1;
+    G.o_flags = O_WRONLY | O_CREAT | O_TRUNC | O_EXCL;
+    if (G.fname_out) { /* -O FILE ? */
+        if (LONE_DASH(G.fname_out)) { /* -O - ? */
+            G.output_fd = 1;
+            option_mask32 &= ~WGET_OPT_CONTINUE;
+        }
         /* compat with wget: -O FILE can overwrite */
-        if (opt & WGET_OPT_OUTNAME)
-            o_flags = O_WRONLY | O_CREAT | O_TRUNC;
-        output_fd = xopen(fname_out, o_flags);
-    }
-
-    retrieve_file_data(dfp, output_fd);
-    xclose(output_fd);
-
-    if (dfp != sfp) {
-        /* It's ftp. Close it properly */
-        fclose(dfp);
-        if (ftpcmd(NULL, NULL, sfp, buf) != 226)
-            bb_error_msg_and_die("ftp error: %s", sanitize_string(buf+4));
-        /* ftpcmd("QUIT", NULL, sfp, buf); - why bother? */
-    }
+        G.o_flags = O_WRONLY | O_CREAT | O_TRUNC;
+    }
+
+    while (*argv)
+        download_one_url(*argv++);
+
+    if (G.output_fd >= 0)
+        xclose(G.output_fd);
 
     return EXIT_SUCCESS;