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  * Licensed under GPLv2, see file LICENSE in this source tree.
   7  *
   8  * Copyright (C) 2010 Bradley M. Kuhn <bkuhn@ebb.org>
   9  * Kuhn's copyrights are licensed GPLv2-or-later.  File as a whole remains GPLv2.
  10  */
  11
  12 //config:config WGET
  13 //config:       bool "wget"
  14 //config:       default y
  15 //config:       help
  16 //config:         wget is a utility for non-interactive download of files from HTTP
  17 //config:         and FTP servers.
  18 //config:
  19 //config:config FEATURE_WGET_LONG_OPTIONS
  20 //config:       bool "Enable long options"
  21 //config:       default y
  22 //config:       depends on WGET && LONG_OPTS
  23 //config:
  24 //config:config FEATURE_WGET_STATUSBAR
  25 //config:       bool "Enable progress bar (+2k)"
  26 //config:       default y
  27 //config:       depends on WGET
  28 //config:
  29 //config:config FEATURE_WGET_AUTHENTICATION
  30 //config:       bool "Enable HTTP authentication"
  31 //config:       default y
  32 //config:       depends on WGET
  33 //config:       help
  34 //config:         Support authenticated HTTP transfers.
  35 //config:
  36 //config:config FEATURE_WGET_TIMEOUT
  37 //config:       bool "Enable timeout option -T SEC"
  38 //config:       default y
  39 //config:       depends on WGET
  40 //config:       help
  41 //config:         Supports network read and connect timeouts for wget,
  42 //config:         so that wget will give up and timeout, through the -T
  43 //config:         command line option.
  44 //config:
  45 //config:         Currently only connect and network data read timeout are
  46 //config:         supported (i.e., timeout is not applied to the DNS query). When
  47 //config:         FEATURE_WGET_LONG_OPTIONS is also enabled, the --timeout option
  48 //config:         will work in addition to -T.
  49 //config:
  50 //config:config FEATURE_WGET_HTTPS
  51 //config:       bool "Support HTTPS using internal TLS code"
  52 //config:       default y
  53 //config:       depends on WGET
  54 //config:       select TLS
  55 //config:       help
  56 //config:         wget will use internal TLS code to connect to https:// URLs.
  57 //config:         Note:
  58 //config:         On NOMMU machines, ssl_helper applet should be available
  59 //config:         in the $PATH for this to work. Make sure to select that applet.
  60 //config:
  61 //config:config FEATURE_WGET_OPENSSL
  62 //config:       bool "Try to connect to HTTPS using openssl"
  63 //config:       default y
  64 //config:       depends on WGET
  65 //config:       help
  66 //config:         Try to use openssl to handle HTTPS.
  67 //config:
  68 //config:         OpenSSL has a simple SSL client for debug purposes.
  69 //config:         If you select this option, wget will effectively run:
  70 //config:         "openssl s_client -quiet -connect hostname:443
  71 //config:         -servername hostname 2>/dev/null" and pipe its data
  72 //config:         through it. -servername is not used if hostname is numeric.
  73 //config:         Note inconvenient API: host resolution is done twice,
  74 //config:         and there is no guarantee openssl's idea of IPv6 address
  75 //config:         format is the same as ours.
  76 //config:         Another problem is that s_client prints debug information
  77 //config:         to stderr, and it needs to be suppressed. This means
  78 //config:         all error messages get suppressed too.
  79 //config:         openssl is also a big binary, often dynamically linked
  80 //config:         against ~15 libraries.
  81 //config:
  82 //config:         If openssl can't be executed, internal TLS code will be used
  83 //config:         (if you enabled it); if openssl can be executed but fails later,
  84 //config:         wget can't detect this, and download will fail.
  85
  86 //applet:IF_WGET(APPLET(wget, BB_DIR_USR_BIN, BB_SUID_DROP))
  87
  88 //kbuild:lib-$(CONFIG_WGET) += wget.o
  89
  90 //usage:#define wget_trivial_usage
  91 //usage:        IF_FEATURE_WGET_LONG_OPTIONS(
  92 //usage:       "[-c|--continue] [--spider] [-q|--quiet] [-O|--output-document FILE]\n"
  93 //usage:       "        [--header 'header: value'] [-Y|--proxy on/off] [-P DIR]\n"
  94 /* Since we ignore these opts, we don't show them in --help */
  95 /* //usage:    "        [--no-check-certificate] [--no-cache] [--passive-ftp] [-t TRIES]" */
  96 /* //usage:    "        [-nv] [-nc] [-nH] [-np]" */
  97 //usage:       "        [-U|--user-agent AGENT]" IF_FEATURE_WGET_TIMEOUT(" [-T SEC]") " URL..."
  98 //usage:        )
  99 //usage:        IF_NOT_FEATURE_WGET_LONG_OPTIONS(
 100 //usage:       "[-cq] [-O FILE] [-Y on/off] [-P DIR] [-U AGENT]"
 101 //usage:                        IF_FEATURE_WGET_TIMEOUT(" [-T SEC]") " URL..."
 102 //usage:        )
 103 //usage:#define wget_full_usage "\n\n"
 104 //usage:       "Retrieve files via HTTP or FTP\n"
 105 //usage:        IF_FEATURE_WGET_LONG_OPTIONS(
 106 //usage:     "\n        --spider        Spider mode - only check file existence"
 107 //usage:        )
 108 //usage:     "\n        -c              Continue retrieval of aborted transfer"
 109 //usage:     "\n        -q              Quiet"
 110 //usage:     "\n        -P DIR          Save to DIR (default .)"
 111 //usage:        IF_FEATURE_WGET_TIMEOUT(
 112 //usage:     "\n        -T SEC          Network read timeout is SEC seconds"
 113 //usage:        )
 114 //usage:     "\n        -O FILE         Save to FILE ('-' for stdout)"
 115 //usage:     "\n        -U STR          Use STR for User-Agent header"
 116 //usage:     "\n        -Y on/off       Use proxy"
 117
 118 #include "libbb.h"
 119
 120 #if 0
 121 # define log_io(...) bb_error_msg(__VA_ARGS__)
 122 # define SENDFMT(fp, fmt, ...) \
 123         do { \
 124                 log_io("> " fmt, ##__VA_ARGS__); \
 125                 fprintf(fp, fmt, ##__VA_ARGS__); \
 126         } while (0);
 127 #else
 128 # define log_io(...) ((void)0)
 129 # define SENDFMT(fp, fmt, ...) fprintf(fp, fmt, ##__VA_ARGS__)
 130 #endif
 131
 132
 133 #define SSL_SUPPORTED (ENABLE_FEATURE_WGET_OPENSSL || ENABLE_FEATURE_WGET_HTTPS)
 134
 135 struct host_info {
 136         char *allocated;
 137         const char *path;
 138         char       *user;
 139         const char *protocol;
 140         char       *host;
 141         int         port;
 142 };
 143 static const char P_FTP[] ALIGN1 = "ftp";
 144 static const char P_HTTP[] ALIGN1 = "http";
 145 #if SSL_SUPPORTED
 146 static const char P_HTTPS[] ALIGN1 = "https";
 147 #endif
 148
 149 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
 150 /* User-specified headers prevent using our corresponding built-in headers.  */
 151 enum {
 152         HDR_HOST          = (1<<0),
 153         HDR_USER_AGENT    = (1<<1),
 154         HDR_RANGE         = (1<<2),
 155         HDR_AUTH          = (1<<3) * ENABLE_FEATURE_WGET_AUTHENTICATION,
 156         HDR_PROXY_AUTH    = (1<<4) * ENABLE_FEATURE_WGET_AUTHENTICATION,
 157 };
 158 static const char wget_user_headers[] ALIGN1 =
 159         "Host:\0"
 160         "User-Agent:\0"
 161         "Range:\0"
 162 # if ENABLE_FEATURE_WGET_AUTHENTICATION
 163         "Authorization:\0"
 164         "Proxy-Authorization:\0"
 165 # endif
 166         ;
 167 # define USR_HEADER_HOST       (G.user_headers & HDR_HOST)
 168 # define USR_HEADER_USER_AGENT (G.user_headers & HDR_USER_AGENT)
 169 # define USR_HEADER_RANGE      (G.user_headers & HDR_RANGE)
 170 # define USR_HEADER_AUTH       (G.user_headers & HDR_AUTH)
 171 # define USR_HEADER_PROXY_AUTH (G.user_headers & HDR_PROXY_AUTH)
 172 #else /* No long options, no user-headers :( */
 173 # define USR_HEADER_HOST       0
 174 # define USR_HEADER_USER_AGENT 0
 175 # define USR_HEADER_RANGE      0
 176 # define USR_HEADER_AUTH       0
 177 # define USR_HEADER_PROXY_AUTH 0
 178 #endif
 179
 180 /* Globals */
 181 struct globals {
 182         off_t content_len;        /* Content-length of the file */
 183         off_t beg_range;          /* Range at which continue begins */
 184 #if ENABLE_FEATURE_WGET_STATUSBAR
 185         off_t transferred;        /* Number of bytes transferred so far */
 186         const char *curfile;      /* Name of current file being transferred */
 187         bb_progress_t pmt;
 188 #endif
 189         char *dir_prefix;
 190 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
 191         char *post_data;
 192         char *extra_headers;
 193         unsigned char user_headers; /* Headers mentioned by the user */
 194 #endif
 195         char *fname_out;        /* where to direct output (-O) */
 196         const char *proxy_flag; /* Use proxies if env vars are set */
 197         const char *user_agent; /* "User-Agent" header field */
 198 #if ENABLE_FEATURE_WGET_TIMEOUT
 199         unsigned timeout_seconds;
 200         bool die_if_timed_out;
 201 #endif
 202         int output_fd;
 203         int o_flags;
 204         smallint chunked;         /* chunked transfer encoding */
 205         smallint got_clen;        /* got content-length: from server  */
 206         /* Local downloads do benefit from big buffer.
 207          * With 512 byte buffer, it was measured to be
 208          * an order of magnitude slower than with big one.
 209          */
 210         uint64_t just_to_align_next_member;
 211         char wget_buf[CONFIG_FEATURE_COPYBUF_KB*1024];
 212 } FIX_ALIASING;
 213 #define G (*ptr_to_globals)
 214 #define INIT_G() do { \
 215         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 216 } while (0)
 217 #define FINI_G() do { \
 218         FREE_PTR_TO_GLOBALS(); \
 219 } while (0)
 220
 221
 222 /* Must match option string! */
 223 enum {
 224         WGET_OPT_CONTINUE   = (1 << 0),
 225         WGET_OPT_QUIET      = (1 << 1),
 226         WGET_OPT_OUTNAME    = (1 << 2),
 227         WGET_OPT_PREFIX     = (1 << 3),
 228         WGET_OPT_PROXY      = (1 << 4),
 229         WGET_OPT_USER_AGENT = (1 << 5),
 230         WGET_OPT_NETWORK_READ_TIMEOUT = (1 << 6),
 231         WGET_OPT_RETRIES    = (1 << 7),
 232         WGET_OPT_nsomething = (1 << 8),
 233         WGET_OPT_HEADER     = (1 << 9) * ENABLE_FEATURE_WGET_LONG_OPTIONS,
 234         WGET_OPT_POST_DATA  = (1 << 10) * ENABLE_FEATURE_WGET_LONG_OPTIONS,
 235         WGET_OPT_SPIDER     = (1 << 11) * ENABLE_FEATURE_WGET_LONG_OPTIONS,
 236 };
 237
 238 enum {
 239         PROGRESS_START = -1,
 240         PROGRESS_END   = 0,
 241         PROGRESS_BUMP  = 1,
 242 };
 243 #if ENABLE_FEATURE_WGET_STATUSBAR
 244 static void progress_meter(int flag)
 245 {
 246         if (option_mask32 & WGET_OPT_QUIET)
 247                 return;
 248
 249         if (flag == PROGRESS_START)
 250                 bb_progress_init(&G.pmt, G.curfile);
 251
 252         bb_progress_update(&G.pmt,
 253                         G.beg_range,
 254                         G.transferred,
 255                         (G.chunked || !G.got_clen) ? 0 : G.beg_range + G.transferred + G.content_len
 256         );
 257
 258         if (flag == PROGRESS_END) {
 259                 bb_progress_free(&G.pmt);
 260                 bb_putchar_stderr('\n');
 261                 G.transferred = 0;
 262         }
 263 }
 264 #else
 265 static ALWAYS_INLINE void progress_meter(int flag UNUSED_PARAM) { }
 266 #endif
 267
 268
 269 /* IPv6 knows scoped address types i.e. link and site local addresses. Link
 270  * local addresses can have a scope identifier to specify the
 271  * interface/link an address is valid on (e.g. fe80::1%eth0). This scope
 272  * identifier is only valid on a single node.
 273  *
 274  * RFC 4007 says that the scope identifier MUST NOT be sent across the wire,
 275  * unless all nodes agree on the semantic. Apache e.g. regards zone identifiers
 276  * in the Host header as invalid requests, see
 277  * https://issues.apache.org/bugzilla/show_bug.cgi?id=35122
 278  */
 279 static void strip_ipv6_scope_id(char *host)
 280 {
 281         char *scope, *cp;
 282
 283         /* bbox wget actually handles IPv6 addresses without [], like
 284          * wget "http://::1/xxx", but this is not standard.
 285          * To save code, _here_ we do not support it. */
 286
 287         if (host[0] != '[')
 288                 return; /* not IPv6 */
 289
 290         scope = strchr(host, '%');
 291         if (!scope)
 292                 return;
 293
 294         /* Remove the IPv6 zone identifier from the host address */
 295         cp = strchr(host, ']');
 296         if (!cp || (cp[1] != ':' && cp[1] != '\0')) {
 297                 /* malformed address (not "[xx]:nn" or "[xx]") */
 298                 return;
 299         }
 300
 301         /* cp points to "]...", scope points to "%eth0]..." */
 302         overlapping_strcpy(scope, cp);
 303 }
 304
 305 #if ENABLE_FEATURE_WGET_AUTHENTICATION
 306 /* Base64-encode character string. */
 307 static char *base64enc(const char *str)
 308 {
 309         unsigned len = strlen(str);
 310         if (len > sizeof(G.wget_buf)/4*3 - 10) /* paranoia */
 311                 len = sizeof(G.wget_buf)/4*3 - 10;
 312         bb_uuencode(G.wget_buf, str, len, bb_uuenc_tbl_base64);
 313         return G.wget_buf;
 314 }
 315 #endif
 316
 317 static char* sanitize_string(char *s)
 318 {
 319         unsigned char *p = (void *) s;
 320         while (*p >= ' ')
 321                 p++;
 322         *p = '\0';
 323         return s;
 324 }
 325
 326 #if ENABLE_FEATURE_WGET_TIMEOUT
 327 static void alarm_handler(int sig UNUSED_PARAM)
 328 {
 329         /* This is theoretically unsafe (uses stdio and malloc in signal handler) */
 330         if (G.die_if_timed_out)
 331                 bb_error_msg_and_die("download timed out");
 332 }
 333 static void set_alarm(void)
 334 {
 335         if (G.timeout_seconds) {
 336                 alarm(G.timeout_seconds);
 337                 G.die_if_timed_out = 1;
 338         }
 339 }
 340 # define clear_alarm() ((void)(G.die_if_timed_out = 0))
 341 #else
 342 # define set_alarm()   ((void)0)
 343 # define clear_alarm() ((void)0)
 344 #endif
 345
 346 #if ENABLE_FEATURE_WGET_OPENSSL
 347 /*
 348  * is_ip_address() attempts to verify whether or not a string
 349  * contains an IPv4 or IPv6 address (vs. an FQDN).  The result
 350  * of inet_pton() can be used to determine this.
 351  *
 352  * TODO add proper error checking when inet_pton() returns -1
 353  * (some form of system error has occurred, and errno is set)
 354  */
 355 static int is_ip_address(const char *string)
 356 {
 357         struct sockaddr_in sa;
 358
 359         int result = inet_pton(AF_INET, string, &(sa.sin_addr));
 360 # if ENABLE_FEATURE_IPV6
 361         if (result == 0) {
 362                 struct sockaddr_in6 sa6;
 363                 result = inet_pton(AF_INET6, string, &(sa6.sin6_addr));
 364         }
 365 # endif
 366         return (result == 1);
 367 }
 368 #endif
 369
 370 static FILE *open_socket(len_and_sockaddr *lsa)
 371 {
 372         int fd;
 373         FILE *fp;
 374
 375         set_alarm();
 376         fd = xconnect_stream(lsa);
 377         clear_alarm();
 378
 379         /* glibc 2.4 seems to try seeking on it - ??! */
 380         /* hopefully it understands what ESPIPE means... */
 381         fp = fdopen(fd, "r+");
 382         if (!fp)
 383                 bb_perror_msg_and_die(bb_msg_memory_exhausted);
 384
 385         return fp;
 386 }
 387
 388 /* Returns '\n' if it was seen, else '\0'. Trims at first '\r' or '\n' */
 389 static char fgets_and_trim(FILE *fp)
 390 {
 391         char c;
 392         char *buf_ptr;
 393
 394         set_alarm();
 395         if (fgets(G.wget_buf, sizeof(G.wget_buf) - 1, fp) == NULL)
 396                 bb_perror_msg_and_die("error getting response");
 397         clear_alarm();
 398
 399         buf_ptr = strchrnul(G.wget_buf, '\n');
 400         c = *buf_ptr;
 401         *buf_ptr = '\0';
 402         buf_ptr = strchrnul(G.wget_buf, '\r');
 403         *buf_ptr = '\0';
 404
 405         log_io("< %s", G.wget_buf);
 406
 407         return c;
 408 }
 409
 410 static int ftpcmd(const char *s1, const char *s2, FILE *fp)
 411 {
 412         int result;
 413         if (s1) {
 414                 if (!s2)
 415                         s2 = "";
 416                 fprintf(fp, "%s%s\r\n", s1, s2);
 417                 fflush(fp);
 418                 log_io("> %s%s", s1, s2);
 419         }
 420
 421         do {
 422                 fgets_and_trim(fp);
 423         } while (!isdigit(G.wget_buf[0]) || G.wget_buf[3] != ' ');
 424
 425         G.wget_buf[3] = '\0';
 426         result = xatoi_positive(G.wget_buf);
 427         G.wget_buf[3] = ' ';
 428         return result;
 429 }
 430
 431 static void parse_url(const char *src_url, struct host_info *h)
 432 {
 433         char *url, *p, *sp;
 434
 435         free(h->allocated);
 436         h->allocated = url = xstrdup(src_url);
 437
 438         h->protocol = P_FTP;
 439         p = strstr(url, "://");
 440         if (p) {
 441                 *p = '\0';
 442                 h->host = p + 3;
 443                 if (strcmp(url, P_FTP) == 0) {
 444                         h->port = bb_lookup_port(P_FTP, "tcp", 21);
 445                 } else
 446 #if SSL_SUPPORTED
 447                 if (strcmp(url, P_HTTPS) == 0) {
 448                         h->port = bb_lookup_port(P_HTTPS, "tcp", 443);
 449                         h->protocol = P_HTTPS;
 450                 } else
 451 #endif
 452                 if (strcmp(url, P_HTTP) == 0) {
 453  http:
 454                         h->port = bb_lookup_port(P_HTTP, "tcp", 80);
 455                         h->protocol = P_HTTP;
 456                 } else {
 457                         *p = ':';
 458                         bb_error_msg_and_die("not an http or ftp url: %s", sanitize_string(url));
 459                 }
 460         } else {
 461                 // GNU wget is user-friendly and falls back to http://
 462                 h->host = url;
 463                 goto http;
 464         }
 465
 466         // FYI:
 467         // "Real" wget 'http://busybox.net?var=a/b' sends this request:
 468         //   'GET /?var=a/b HTTP/1.0'
 469         //   and saves 'index.html?var=a%2Fb' (we save 'b')
 470         // wget 'http://busybox.net?login=john@doe':
 471         //   request: 'GET /?login=john@doe HTTP/1.0'
 472         //   saves: 'index.html?login=john@doe' (we save '?login=john@doe')
 473         // wget 'http://busybox.net#test/test':
 474         //   request: 'GET / HTTP/1.0'
 475         //   saves: 'index.html' (we save 'test')
 476         //
 477         // We also don't add unique .N suffix if file exists...
 478         sp = strchr(h->host, '/');
 479         p = strchr(h->host, '?'); if (!sp || (p && sp > p)) sp = p;
 480         p = strchr(h->host, '#'); if (!sp || (p && sp > p)) sp = p;
 481         if (!sp) {
 482                 h->path = "";
 483         } else if (*sp == '/') {
 484                 *sp = '\0';
 485                 h->path = sp + 1;
 486         } else { // '#' or '?'
 487                 // http://busybox.net?login=john@doe is a valid URL
 488                 // memmove converts to:
 489                 // http:/busybox.nett?login=john@doe...
 490                 memmove(h->host - 1, h->host, sp - h->host);
 491                 h->host--;
 492                 sp[-1] = '\0';
 493                 h->path = sp;
 494         }
 495
 496         sp = strrchr(h->host, '@');
 497         if (sp != NULL) {
 498                 // URL-decode "user:password" string before base64-encoding:
 499                 // wget http://test:my%20pass@example.com should send
 500                 // Authorization: Basic dGVzdDpteSBwYXNz
 501                 // which decodes to "test:my pass".
 502                 // Standard wget and curl do this too.
 503                 *sp = '\0';
 504                 free(h->user);
 505                 h->user = xstrdup(percent_decode_in_place(h->host, /*strict:*/ 0));
 506                 h->host = sp + 1;
 507         }
 508         /* else: h->user remains NULL, or as set by original request
 509          * before redirect (if we are here after a redirect).
 510          */
 511 }
 512
 513 static char *gethdr(FILE *fp)
 514 {
 515         char *s, *hdrval;
 516         int c;
 517
 518         /* retrieve header line */
 519         c = fgets_and_trim(fp);
 520
 521         /* end of the headers? */
 522         if (G.wget_buf[0] == '\0')
 523                 return NULL;
 524
 525         /* convert the header name to lower case */
 526         for (s = G.wget_buf; isalnum(*s) || *s == '-' || *s == '.' || *s == '_'; ++s) {
 527                 /*
 528                  * No-op for 20-3f and 60-7f. "0-9a-z-." are in these ranges.
 529                  * 40-5f range ("@A-Z[\]^_") maps to 60-7f.
 530                  * "A-Z" maps to "a-z".
 531                  * "@[\]" can't occur in header names.
 532                  * "^_" maps to "~,DEL" (which is wrong).
 533                  * "^" was never seen yet, "_" was seen from web.archive.org
 534                  * (x-archive-orig-x_commoncrawl_Signature: HEXSTRING).
 535                  */
 536                 *s |= 0x20;
 537         }
 538
 539         /* verify we are at the end of the header name */
 540         if (*s != ':')
 541                 bb_error_msg_and_die("bad header line: %s", sanitize_string(G.wget_buf));
 542
 543         /* locate the start of the header value */
 544         *s++ = '\0';
 545         hdrval = skip_whitespace(s);
 546
 547         if (c != '\n') {
 548                 /* Rats! The buffer isn't big enough to hold the entire header value */
 549                 while (c = getc(fp), c != EOF && c != '\n')
 550                         continue;
 551         }
 552
 553         return hdrval;
 554 }
 555
 556 static void reset_beg_range_to_zero(void)
 557 {
 558         bb_error_msg("restart failed");
 559         G.beg_range = 0;
 560         xlseek(G.output_fd, 0, SEEK_SET);
 561         /* Done at the end instead: */
 562         /* ftruncate(G.output_fd, 0); */
 563 }
 564
 565 static FILE* prepare_ftp_session(FILE **dfpp, struct host_info *target, len_and_sockaddr *lsa)
 566 {
 567         FILE *sfp;
 568         char *str;
 569         int port;
 570
 571         if (!target->user)
 572                 target->user = xstrdup("anonymous:busybox@");
 573
 574         sfp = open_socket(lsa);
 575         if (ftpcmd(NULL, NULL, sfp) != 220)
 576                 bb_error_msg_and_die("%s", sanitize_string(G.wget_buf + 4));
 577
 578         /*
 579          * Splitting username:password pair,
 580          * trying to log in
 581          */
 582         str = strchr(target->user, ':');
 583         if (str)
 584                 *str++ = '\0';
 585         switch (ftpcmd("USER ", target->user, sfp)) {
 586         case 230:
 587                 break;
 588         case 331:
 589                 if (ftpcmd("PASS ", str, sfp) == 230)
 590                         break;
 591                 /* fall through (failed login) */
 592         default:
 593                 bb_error_msg_and_die("ftp login: %s", sanitize_string(G.wget_buf + 4));
 594         }
 595
 596         ftpcmd("TYPE I", NULL, sfp);
 597
 598         /*
 599          * Querying file size
 600          */
 601         if (ftpcmd("SIZE ", target->path, sfp) == 213) {
 602                 G.content_len = BB_STRTOOFF(G.wget_buf + 4, NULL, 10);
 603                 if (G.content_len < 0 || errno) {
 604                         bb_error_msg_and_die("SIZE value is garbage");
 605                 }
 606                 G.got_clen = 1;
 607         }
 608
 609         /*
 610          * Entering passive mode
 611          */
 612         if (ftpcmd("PASV", NULL, sfp) != 227) {
 613  pasv_error:
 614                 bb_error_msg_and_die("bad response to %s: %s", "PASV", sanitize_string(G.wget_buf));
 615         }
 616         // Response is "227 garbageN1,N2,N3,N4,P1,P2[)garbage]
 617         // Server's IP is N1.N2.N3.N4 (we ignore it)
 618         // Server's port for data connection is P1*256+P2
 619         str = strrchr(G.wget_buf, ')');
 620         if (str) str[0] = '\0';
 621         str = strrchr(G.wget_buf, ',');
 622         if (!str) goto pasv_error;
 623         port = xatou_range(str+1, 0, 255);
 624         *str = '\0';
 625         str = strrchr(G.wget_buf, ',');
 626         if (!str) goto pasv_error;
 627         port += xatou_range(str+1, 0, 255) * 256;
 628         set_nport(&lsa->u.sa, htons(port));
 629
 630         *dfpp = open_socket(lsa);
 631
 632         if (G.beg_range != 0) {
 633                 sprintf(G.wget_buf, "REST %"OFF_FMT"u", G.beg_range);
 634                 if (ftpcmd(G.wget_buf, NULL, sfp) == 350)
 635                         G.content_len -= G.beg_range;
 636                 else
 637                         reset_beg_range_to_zero();
 638         }
 639
 640         if (ftpcmd("RETR ", target->path, sfp) > 150)
 641                 bb_error_msg_and_die("bad response to %s: %s", "RETR", sanitize_string(G.wget_buf));
 642
 643         return sfp;
 644 }
 645
 646 #if ENABLE_FEATURE_WGET_OPENSSL
 647 static int spawn_https_helper_openssl(const char *host, unsigned port)
 648 {
 649         char *allocated = NULL;
 650         char *servername;
 651         int sp[2];
 652         int pid;
 653         IF_FEATURE_WGET_HTTPS(volatile int child_failed = 0;)
 654
 655         if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
 656                 /* Kernel can have AF_UNIX support disabled */
 657                 bb_perror_msg_and_die("socketpair");
 658
 659         if (!strchr(host, ':'))
 660                 host = allocated = xasprintf("%s:%u", host, port);
 661         servername = xstrdup(host);
 662         strrchr(servername, ':')[0] = '\0';
 663
 664         fflush_all();
 665         pid = xvfork();
 666         if (pid == 0) {
 667                 /* Child */
 668                 char *argv[8];
 669
 670                 close(sp[0]);
 671                 xmove_fd(sp[1], 0);
 672                 xdup2(0, 1);
 673                 /*
 674                  * openssl s_client -quiet -connect www.kernel.org:443 2>/dev/null
 675                  * It prints some debug stuff on stderr, don't know how to suppress it.
 676                  * Work around by dev-nulling stderr. We lose all error messages :(
 677                  */
 678                 xmove_fd(2, 3);
 679                 xopen("/dev/null", O_RDWR);
 680                 memset(&argv, 0, sizeof(argv));
 681                 argv[0] = (char*)"openssl";
 682                 argv[1] = (char*)"s_client";
 683                 argv[2] = (char*)"-quiet";
 684                 argv[3] = (char*)"-connect";
 685                 argv[4] = (char*)host;
 686                 /*
 687                  * Per RFC 6066 Section 3, the only permitted values in the
 688                  * TLS server_name (SNI) field are FQDNs (DNS hostnames).
 689                  * IPv4 and IPv6 addresses, port numbers are not allowed.
 690                  */
 691                 if (!is_ip_address(servername)) {
 692                         argv[5] = (char*)"-servername";
 693                         argv[6] = (char*)servername;
 694                 }
 695
 696                 BB_EXECVP(argv[0], argv);
 697                 xmove_fd(3, 2);
 698 # if ENABLE_FEATURE_WGET_HTTPS
 699                 child_failed = 1;
 700                 xfunc_die();
 701 # else
 702                 bb_perror_msg_and_die("can't execute '%s'", argv[0]);
 703 # endif
 704                 /* notreached */
 705         }
 706
 707         /* Parent */
 708         free(servername);
 709         free(allocated);
 710         close(sp[1]);
 711 # if ENABLE_FEATURE_WGET_HTTPS
 712         if (child_failed) {
 713                 close(sp[0]);
 714                 return -1;
 715         }
 716 # endif
 717         return sp[0];
 718 }
 719 #endif
 720
 721 #if ENABLE_FEATURE_WGET_HTTPS
 722 static void spawn_ssl_client(const char *host, int network_fd)
 723 {
 724         int sp[2];
 725         int pid;
 726         char *servername, *p;
 727
 728         servername = xstrdup(host);
 729         p = strrchr(servername, ':');
 730         if (p) *p = '\0';
 731
 732         if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) != 0)
 733                 /* Kernel can have AF_UNIX support disabled */
 734                 bb_perror_msg_and_die("socketpair");
 735
 736         fflush_all();
 737         pid = BB_MMU ? xfork() : xvfork();
 738         if (pid == 0) {
 739                 /* Child */
 740                 close(sp[0]);
 741                 xmove_fd(sp[1], 0);
 742                 xdup2(0, 1);
 743                 if (BB_MMU) {
 744                         tls_state_t *tls = new_tls_state();
 745                         tls->ifd = tls->ofd = network_fd;
 746                         tls_handshake(tls, servername);
 747                         tls_run_copy_loop(tls);
 748                         exit(0);
 749                 } else {
 750                         char *argv[5];
 751                         xmove_fd(network_fd, 3);
 752                         argv[0] = (char*)"ssl_client";
 753                         argv[1] = (char*)"-s3";
 754                         //TODO: if (!is_ip_address(servername))...
 755                         argv[2] = (char*)"-n";
 756                         argv[3] = servername;
 757                         argv[4] = NULL;
 758                         BB_EXECVP(argv[0], argv);
 759                         bb_perror_msg_and_die("can't execute '%s'", argv[0]);
 760                 }
 761                 /* notreached */
 762         }
 763
 764         /* Parent */
 765         free(servername);
 766         close(sp[1]);
 767         xmove_fd(sp[0], network_fd);
 768 }
 769 #endif
 770
 771 static void NOINLINE retrieve_file_data(FILE *dfp)
 772 {
 773 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 774 # if ENABLE_FEATURE_WGET_TIMEOUT
 775         unsigned second_cnt = G.timeout_seconds;
 776 # endif
 777         struct pollfd polldata;
 778
 779         polldata.fd = fileno(dfp);
 780         polldata.events = POLLIN | POLLPRI;
 781 #endif
 782         progress_meter(PROGRESS_START);
 783
 784         if (G.chunked)
 785                 goto get_clen;
 786
 787         /* Loops only if chunked */
 788         while (1) {
 789
 790 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 791                 /* Must use nonblocking I/O, otherwise fread will loop
 792                  * and *block* until it reads full buffer,
 793                  * which messes up progress bar and/or timeout logic.
 794                  * Because of nonblocking I/O, we need to dance
 795                  * very carefully around EAGAIN. See explanation at
 796                  * clearerr() calls.
 797                  */
 798                 ndelay_on(polldata.fd);
 799 #endif
 800                 while (1) {
 801                         int n;
 802                         unsigned rdsz;
 803
 804 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 805                         /* fread internally uses read loop, which in our case
 806                          * is usually exited when we get EAGAIN.
 807                          * In this case, libc sets error marker on the stream.
 808                          * Need to clear it before next fread to avoid possible
 809                          * rare false positive ferror below. Rare because usually
 810                          * fread gets more than zero bytes, and we don't fall
 811                          * into if (n <= 0) ...
 812                          */
 813                         clearerr(dfp);
 814 #endif
 815                         errno = 0;
 816                         rdsz = sizeof(G.wget_buf);
 817                         if (G.got_clen) {
 818                                 if (G.content_len < (off_t)sizeof(G.wget_buf)) {
 819                                         if ((int)G.content_len <= 0)
 820                                                 break;
 821                                         rdsz = (unsigned)G.content_len;
 822                                 }
 823                         }
 824                         n = fread(G.wget_buf, 1, rdsz, dfp);
 825
 826                         if (n > 0) {
 827                                 xwrite(G.output_fd, G.wget_buf, n);
 828 #if ENABLE_FEATURE_WGET_STATUSBAR
 829                                 G.transferred += n;
 830 #endif
 831                                 if (G.got_clen) {
 832                                         G.content_len -= n;
 833                                         if (G.content_len == 0)
 834                                                 break;
 835                                 }
 836 #if ENABLE_FEATURE_WGET_TIMEOUT
 837                                 second_cnt = G.timeout_seconds;
 838 #endif
 839                                 goto bump;
 840                         }
 841
 842                         /* n <= 0.
 843                          * man fread:
 844                          * If error occurs, or EOF is reached, the return value
 845                          * is a short item count (or zero).
 846                          * fread does not distinguish between EOF and error.
 847                          */
 848                         if (errno != EAGAIN) {
 849                                 if (ferror(dfp)) {
 850                                         progress_meter(PROGRESS_END);
 851                                         bb_perror_msg_and_die(bb_msg_read_error);
 852                                 }
 853                                 break; /* EOF, not error */
 854                         }
 855
 856 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 857                         /* It was EAGAIN. There is no data. Wait up to one second
 858                          * then abort if timed out, or update the bar and try reading again.
 859                          */
 860                         if (safe_poll(&polldata, 1, 1000) == 0) {
 861 # if ENABLE_FEATURE_WGET_TIMEOUT
 862                                 if (second_cnt != 0 && --second_cnt == 0) {
 863                                         progress_meter(PROGRESS_END);
 864                                         bb_error_msg_and_die("download timed out");
 865                                 }
 866 # endif
 867                                 /* We used to loop back to poll here,
 868                                  * but there is no great harm in letting fread
 869                                  * to try reading anyway.
 870                                  */
 871                         }
 872 #endif
 873  bump:
 874                         /* Need to do it _every_ second for "stalled" indicator
 875                          * to be shown properly.
 876                          */
 877                         progress_meter(PROGRESS_BUMP);
 878                 } /* while (reading data) */
 879
 880 #if ENABLE_FEATURE_WGET_STATUSBAR || ENABLE_FEATURE_WGET_TIMEOUT
 881                 clearerr(dfp);
 882                 ndelay_off(polldata.fd); /* else fgets can get very unhappy */
 883 #endif
 884                 if (!G.chunked)
 885                         break;
 886
 887                 fgets_and_trim(dfp); /* Eat empty line */
 888  get_clen:
 889                 fgets_and_trim(dfp);
 890                 G.content_len = STRTOOFF(G.wget_buf, NULL, 16);
 891                 /* FIXME: error check? */
 892                 if (G.content_len == 0)
 893                         break; /* all done! */
 894                 G.got_clen = 1;
 895                 /*
 896                  * Note that fgets may result in some data being buffered in dfp.
 897                  * We loop back to fread, which will retrieve this data.
 898                  * Also note that code has to be arranged so that fread
 899                  * is done _before_ one-second poll wait - poll doesn't know
 900                  * about stdio buffering and can result in spurious one second waits!
 901                  */
 902         }
 903
 904         /* If -c failed, we restart from the beginning,
 905          * but we do not truncate file then, we do it only now, at the end.
 906          * This lets user to ^C if his 99% complete 10 GB file download
 907          * failed to restart *without* losing the almost complete file.
 908          */
 909         {
 910                 off_t pos = lseek(G.output_fd, 0, SEEK_CUR);
 911                 if (pos != (off_t)-1)
 912                         ftruncate(G.output_fd, pos);
 913         }
 914
 915         /* Draw full bar and free its resources */
 916         G.chunked = 0;  /* makes it show 100% even for chunked download */
 917         G.got_clen = 1; /* makes it show 100% even for download of (formerly) unknown size */
 918         progress_meter(PROGRESS_END);
 919 }
 920
 921 static void download_one_url(const char *url)
 922 {
 923         bool use_proxy;                 /* Use proxies if env vars are set  */
 924         int redir_limit;
 925         len_and_sockaddr *lsa;
 926         FILE *sfp;                      /* socket to web/ftp server         */
 927         FILE *dfp;                      /* socket to ftp server (data)      */
 928         char *proxy = NULL;
 929         char *fname_out_alloc;
 930         char *redirected_path = NULL;
 931         struct host_info server;
 932         struct host_info target;
 933
 934         server.allocated = NULL;
 935         target.allocated = NULL;
 936         server.user = NULL;
 937         target.user = NULL;
 938
 939         parse_url(url, &target);
 940
 941         /* Use the proxy if necessary */
 942         use_proxy = (strcmp(G.proxy_flag, "off") != 0);
 943         if (use_proxy) {
 944                 proxy = getenv(target.protocol == P_FTP ? "ftp_proxy" : "http_proxy");
 945 //FIXME: what if protocol is https? Ok to use http_proxy?
 946                 use_proxy = (proxy && proxy[0]);
 947                 if (use_proxy)
 948                         parse_url(proxy, &server);
 949         }
 950         if (!use_proxy) {
 951                 server.port = target.port;
 952                 if (ENABLE_FEATURE_IPV6) {
 953                         //free(server.allocated); - can't be non-NULL
 954                         server.host = server.allocated = xstrdup(target.host);
 955                 } else {
 956                         server.host = target.host;
 957                 }
 958         }
 959
 960         if (ENABLE_FEATURE_IPV6)
 961                 strip_ipv6_scope_id(target.host);
 962
 963         /* If there was no -O FILE, guess output filename */
 964         fname_out_alloc = NULL;
 965         if (!(option_mask32 & WGET_OPT_OUTNAME)) {
 966                 G.fname_out = bb_get_last_path_component_nostrip(target.path);
 967                 /* handle "wget http://kernel.org//" */
 968                 if (G.fname_out[0] == '/' || !G.fname_out[0])
 969                         G.fname_out = (char*)"index.html";
 970                 /* -P DIR is considered only if there was no -O FILE */
 971                 if (G.dir_prefix)
 972                         G.fname_out = fname_out_alloc = concat_path_file(G.dir_prefix, G.fname_out);
 973                 else {
 974                         /* redirects may free target.path later, need to make a copy */
 975                         G.fname_out = fname_out_alloc = xstrdup(G.fname_out);
 976                 }
 977         }
 978 #if ENABLE_FEATURE_WGET_STATUSBAR
 979         G.curfile = bb_get_last_path_component_nostrip(G.fname_out);
 980 #endif
 981
 982         /* Determine where to start transfer */
 983         G.beg_range = 0;
 984         if (option_mask32 & WGET_OPT_CONTINUE) {
 985                 G.output_fd = open(G.fname_out, O_WRONLY);
 986                 if (G.output_fd >= 0) {
 987                         G.beg_range = xlseek(G.output_fd, 0, SEEK_END);
 988                 }
 989                 /* File doesn't exist. We do not create file here yet.
 990                  * We are not sure it exists on remote side */
 991         }
 992
 993         redir_limit = 5;
 994  resolve_lsa:
 995         lsa = xhost2sockaddr(server.host, server.port);
 996         if (!(option_mask32 & WGET_OPT_QUIET)) {
 997                 char *s = xmalloc_sockaddr2dotted(&lsa->u.sa);
 998                 fprintf(stderr, "Connecting to %s (%s)\n", server.host, s);
 999                 free(s);
1000         }
1001  establish_session:
1002         /*G.content_len = 0; - redundant, got_clen = 0 is enough */
1003         G.got_clen = 0;
1004         G.chunked = 0;
1005         if (use_proxy || target.protocol != P_FTP) {
1006                 /*
1007                  *  HTTP session
1008                  */
1009                 char *str;
1010                 int status;
1011
1012                 /* Open socket to http(s) server */
1013 #if ENABLE_FEATURE_WGET_OPENSSL
1014                 /* openssl (and maybe internal TLS) support is configured */
1015                 if (target.protocol == P_HTTPS) {
1016                         /* openssl-based helper
1017                          * Inconvenient API since we can't give it an open fd
1018                          */
1019                         int fd = spawn_https_helper_openssl(server.host, server.port);
1020 # if ENABLE_FEATURE_WGET_HTTPS
1021                         if (fd < 0) { /* no openssl? try internal */
1022                                 sfp = open_socket(lsa);
1023                                 spawn_ssl_client(server.host, fileno(sfp));
1024                                 goto socket_opened;
1025                         }
1026 # else
1027                         /* We don't check for exec("openssl") failure in this case */
1028 # endif
1029                         sfp = fdopen(fd, "r+");
1030                         if (!sfp)
1031                                 bb_perror_msg_and_die(bb_msg_memory_exhausted);
1032                         goto socket_opened;
1033                 }
1034                 sfp = open_socket(lsa);
1035  socket_opened:
1036 #elif ENABLE_FEATURE_WGET_HTTPS
1037                 /* Only internal TLS support is configured */
1038                 sfp = open_socket(lsa);
1039                 if (target.protocol == P_HTTPS)
1040                         spawn_ssl_client(server.host, fileno(sfp));
1041 #else
1042                 /* ssl (https) support is not configured */
1043                 sfp = open_socket(lsa);
1044 #endif
1045                 /* Send HTTP request */
1046                 if (use_proxy) {
1047                         SENDFMT(sfp, "GET %s://%s/%s HTTP/1.1\r\n",
1048                                 target.protocol, target.host,
1049                                 target.path);
1050                 } else {
1051                         SENDFMT(sfp, "%s /%s HTTP/1.1\r\n",
1052                                 (option_mask32 & WGET_OPT_POST_DATA) ? "POST" : "GET",
1053                                 target.path);
1054                 }
1055                 if (!USR_HEADER_HOST)
1056                         SENDFMT(sfp, "Host: %s\r\n", target.host);
1057                 if (!USR_HEADER_USER_AGENT)
1058                         SENDFMT(sfp, "User-Agent: %s\r\n", G.user_agent);
1059
1060                 /* Ask server to close the connection as soon as we are done
1061                  * (IOW: we do not intend to send more requests)
1062                  */
1063                 SENDFMT(sfp, "Connection: close\r\n");
1064
1065 #if ENABLE_FEATURE_WGET_AUTHENTICATION
1066                 if (target.user && !USR_HEADER_AUTH) {
1067                         SENDFMT(sfp, "Proxy-Authorization: Basic %s\r\n"+6,
1068                                 base64enc(target.user));
1069                 }
1070                 if (use_proxy && server.user && !USR_HEADER_PROXY_AUTH) {
1071                         SENDFMT(sfp, "Proxy-Authorization: Basic %s\r\n",
1072                                 base64enc(server.user));
1073                 }
1074 #endif
1075
1076                 if (G.beg_range != 0 && !USR_HEADER_RANGE)
1077                         SENDFMT(sfp, "Range: bytes=%"OFF_FMT"u-\r\n", G.beg_range);
1078
1079 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
1080                 if (G.extra_headers) {
1081                         log_io(G.extra_headers);
1082                         fputs(G.extra_headers, sfp);
1083                 }
1084
1085                 if (option_mask32 & WGET_OPT_POST_DATA) {
1086                         SENDFMT(sfp,
1087                                 "Content-Type: application/x-www-form-urlencoded\r\n"
1088                                 "Content-Length: %u\r\n"
1089                                 "\r\n"
1090                                 "%s",
1091                                 (int) strlen(G.post_data), G.post_data
1092                         );
1093                 } else
1094 #endif
1095                 {
1096                         SENDFMT(sfp, "\r\n");
1097                 }
1098
1099                 fflush(sfp);
1100
1101 /* Tried doing this unconditionally.
1102  * Cloudflare and nginx/1.11.5 are shocked to see SHUT_WR on non-HTTPS.
1103  */
1104 #if SSL_SUPPORTED
1105                 if (target.protocol == P_HTTPS) {
1106                         /* If we use SSL helper, keeping our end of the socket open for writing
1107                          * makes our end (i.e. the same fd!) readable (EAGAIN instead of EOF)
1108                          * even after child closes its copy of the fd.
1109                          * This helps:
1110                          */
1111                         shutdown(fileno(sfp), SHUT_WR);
1112                 }
1113 #endif
1114
1115                 /*
1116                  * Retrieve HTTP response line and check for "200" status code.
1117                  */
1118  read_response:
1119                 fgets_and_trim(sfp);
1120
1121                 str = G.wget_buf;
1122                 str = skip_non_whitespace(str);
1123                 str = skip_whitespace(str);
1124                 // FIXME: no error check
1125                 // xatou wouldn't work: "200 OK"
1126                 status = atoi(str);
1127                 switch (status) {
1128                 case 0:
1129                 case 100:
1130                         while (gethdr(sfp) != NULL)
1131                                 /* eat all remaining headers */;
1132                         goto read_response;
1133
1134                 /* Success responses */
1135                 case 200:
1136                         /* fall through */
1137                 case 201: /* 201 Created */
1138 /* "The request has been fulfilled and resulted in a new resource being created" */
1139                         /* Standard wget is reported to treat this as success */
1140                         /* fall through */
1141                 case 202: /* 202 Accepted */
1142 /* "The request has been accepted for processing, but the processing has not been completed" */
1143                         /* Treat as success: fall through */
1144                 case 203: /* 203 Non-Authoritative Information */
1145 /* "Use of this response code is not required and is only appropriate when the response would otherwise be 200 (OK)" */
1146                         /* fall through */
1147                 case 204: /* 204 No Content */
1148 /*
1149 Response 204 doesn't say "null file", it says "metadata
1150 has changed but data didn't":
1151
1152 "10.2.5 204 No Content
1153 The server has fulfilled the request but does not need to return
1154 an entity-body, and might want to return updated metainformation.
1155 The response MAY include new or updated metainformation in the form
1156 of entity-headers, which if present SHOULD be associated with
1157 the requested variant.
1158
1159 If the client is a user agent, it SHOULD NOT change its document
1160 view from that which caused the request to be sent. This response
1161 is primarily intended to allow input for actions to take place
1162 without causing a change to the user agent's active document view,
1163 although any new or updated metainformation SHOULD be applied
1164 to the document currently in the user agent's active view.
1165
1166 The 204 response MUST NOT include a message-body, and thus
1167 is always terminated by the first empty line after the header fields."
1168
1169 However, in real world it was observed that some web servers
1170 (e.g. Boa/0.94.14rc21) simply use code 204 when file size is zero.
1171 */
1172                         if (G.beg_range != 0) {
1173                                 /* "Range:..." was not honored by the server.
1174                                  * Restart download from the beginning.
1175                                  */
1176                                 reset_beg_range_to_zero();
1177                         }
1178                         break;
1179                 /* 205 Reset Content ?? what to do on this ??   */
1180
1181                 case 300:  /* redirection */
1182                 case 301:
1183                 case 302:
1184                 case 303:
1185                         break;
1186
1187                 case 206: /* Partial Content */
1188                         if (G.beg_range != 0)
1189                                 /* "Range:..." worked. Good. */
1190                                 break;
1191                         /* Partial Content even though we did not ask for it??? */
1192                         /* fall through */
1193                 default:
1194                         bb_error_msg_and_die("server returned error: %s", sanitize_string(G.wget_buf));
1195                 }
1196
1197                 /*
1198                  * Retrieve HTTP headers.
1199                  */
1200                 while ((str = gethdr(sfp)) != NULL) {
1201                         static const char keywords[] ALIGN1 =
1202                                 "content-length\0""transfer-encoding\0""location\0";
1203                         enum {
1204                                 KEY_content_length = 1, KEY_transfer_encoding, KEY_location
1205                         };
1206                         smalluint key;
1207
1208                         /* gethdr converted "FOO:" string to lowercase */
1209
1210                         /* strip trailing whitespace */
1211                         char *s = strchrnul(str, '\0') - 1;
1212                         while (s >= str && (*s == ' ' || *s == '\t')) {
1213                                 *s = '\0';
1214                                 s--;
1215                         }
1216                         key = index_in_strings(keywords, G.wget_buf) + 1;
1217                         if (key == KEY_content_length) {
1218                                 G.content_len = BB_STRTOOFF(str, NULL, 10);
1219                                 if (G.content_len < 0 || errno) {
1220                                         bb_error_msg_and_die("content-length %s is garbage", sanitize_string(str));
1221                                 }
1222                                 G.got_clen = 1;
1223                                 continue;
1224                         }
1225                         if (key == KEY_transfer_encoding) {
1226                                 if (strcmp(str_tolower(str), "chunked") != 0)
1227                                         bb_error_msg_and_die("transfer encoding '%s' is not supported", sanitize_string(str));
1228                                 G.chunked = 1;
1229                         }
1230                         if (key == KEY_location && status >= 300) {
1231                                 if (--redir_limit == 0)
1232                                         bb_error_msg_and_die("too many redirections");
1233                                 fclose(sfp);
1234                                 if (str[0] == '/') {
1235                                         free(redirected_path);
1236                                         target.path = redirected_path = xstrdup(str+1);
1237                                         /* lsa stays the same: it's on the same server */
1238                                 } else {
1239                                         parse_url(str, &target);
1240                                         if (!use_proxy) {
1241                                                 /* server.user remains untouched */
1242                                                 free(server.allocated);
1243                                                 server.allocated = NULL;
1244                                                 server.host = target.host;
1245                                                 /* strip_ipv6_scope_id(target.host); - no! */
1246                                                 /* we assume remote never gives us IPv6 addr with scope id */
1247                                                 server.port = target.port;
1248                                                 free(lsa);
1249                                                 goto resolve_lsa;
1250                                         } /* else: lsa stays the same: we use proxy */
1251                                 }
1252                                 goto establish_session;
1253                         }
1254                 }
1255 //              if (status >= 300)
1256 //                      bb_error_msg_and_die("bad redirection (no Location: header from server)");
1257
1258                 /* For HTTP, data is pumped over the same connection */
1259                 dfp = sfp;
1260         } else {
1261                 /*
1262                  *  FTP session
1263                  */
1264                 sfp = prepare_ftp_session(&dfp, &target, lsa);
1265         }
1266
1267         free(lsa);
1268
1269         if (!(option_mask32 & WGET_OPT_SPIDER)) {
1270                 if (G.output_fd < 0)
1271                         G.output_fd = xopen(G.fname_out, G.o_flags);
1272                 retrieve_file_data(dfp);
1273                 if (!(option_mask32 & WGET_OPT_OUTNAME)) {
1274                         xclose(G.output_fd);
1275                         G.output_fd = -1;
1276                 }
1277         }
1278
1279         if (dfp != sfp) {
1280                 /* It's ftp. Close data connection properly */
1281                 fclose(dfp);
1282                 if (ftpcmd(NULL, NULL, sfp) != 226)
1283                         bb_error_msg_and_die("ftp error: %s", sanitize_string(G.wget_buf + 4));
1284                 /* ftpcmd("QUIT", NULL, sfp); - why bother? */
1285         }
1286         fclose(sfp);
1287
1288         free(server.allocated);
1289         free(target.allocated);
1290         free(server.user);
1291         free(target.user);
1292         free(fname_out_alloc);
1293         free(redirected_path);
1294 }
1295
1296 int wget_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1297 int wget_main(int argc UNUSED_PARAM, char **argv)
1298 {
1299 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
1300         static const char wget_longopts[] ALIGN1 =
1301                 /* name, has_arg, val */
1302                 "continue\0"         No_argument       "c"
1303                 "quiet\0"            No_argument       "q"
1304                 "output-document\0"  Required_argument "O"
1305                 "directory-prefix\0" Required_argument "P"
1306                 "proxy\0"            Required_argument "Y"
1307                 "user-agent\0"       Required_argument "U"
1308 IF_FEATURE_WGET_TIMEOUT(
1309                 "timeout\0"          Required_argument "T")
1310                 /* Ignored: */
1311 IF_DESKTOP(     "tries\0"            Required_argument "t")
1312                 "header\0"           Required_argument "\xff"
1313                 "post-data\0"        Required_argument "\xfe"
1314                 "spider\0"           No_argument       "\xfd"
1315                 /* Ignored (we always use PASV): */
1316 IF_DESKTOP(     "passive-ftp\0"      No_argument       "\xf0")
1317                 /* Ignored (we don't do ssl) */
1318 IF_DESKTOP(     "no-check-certificate\0" No_argument   "\xf0")
1319                 /* Ignored (we don't support caching) */
1320 IF_DESKTOP(     "no-cache\0"         No_argument       "\xf0")
1321 IF_DESKTOP(     "no-verbose\0"       No_argument       "\xf0")
1322 IF_DESKTOP(     "no-clobber\0"       No_argument       "\xf0")
1323 IF_DESKTOP(     "no-host-directories\0" No_argument    "\xf0")
1324 IF_DESKTOP(     "no-parent\0"        No_argument       "\xf0")
1325                 ;
1326 #endif
1327
1328 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
1329         llist_t *headers_llist = NULL;
1330 #endif
1331
1332         INIT_G();
1333
1334 #if ENABLE_FEATURE_WGET_TIMEOUT
1335         G.timeout_seconds = 900;
1336         signal(SIGALRM, alarm_handler);
1337 #endif
1338         G.proxy_flag = "on";   /* use proxies if env vars are set */
1339         G.user_agent = "Wget"; /* "User-Agent" header field */
1340
1341 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
1342         applet_long_options = wget_longopts;
1343 #endif
1344         opt_complementary = "-1" /* at least one URL */
1345                 IF_FEATURE_WGET_LONG_OPTIONS(":\xff::"); /* --header is a list */
1346         getopt32(argv, "cqO:P:Y:U:T:+"
1347                 /*ignored:*/ "t:"
1348                 /*ignored:*/ "n::"
1349                 /* wget has exactly four -n<letter> opts, all of which we can ignore:
1350                  * -nv --no-verbose: be moderately quiet (-q is full quiet)
1351                  * -nc --no-clobber: abort if exists, neither download to FILE.n nor overwrite FILE
1352                  * -nH --no-host-directories: wget -r http://host/ won't create host/
1353                  * -np --no-parent
1354                  * "n::" above says that we accept -n[ARG].
1355                  * Specifying "n:" would be a bug: "-n ARG" would eat ARG!
1356                  */
1357                 , &G.fname_out, &G.dir_prefix,
1358                 &G.proxy_flag, &G.user_agent,
1359                 IF_FEATURE_WGET_TIMEOUT(&G.timeout_seconds) IF_NOT_FEATURE_WGET_TIMEOUT(NULL),
1360                 NULL, /* -t RETRIES */
1361                 NULL  /* -n[ARG] */
1362                 IF_FEATURE_WGET_LONG_OPTIONS(, &headers_llist)
1363                 IF_FEATURE_WGET_LONG_OPTIONS(, &G.post_data)
1364         );
1365 #if 0 /* option bits debug */
1366         if (option_mask32 & WGET_OPT_RETRIES) bb_error_msg("-t NUM");
1367         if (option_mask32 & WGET_OPT_nsomething) bb_error_msg("-nsomething");
1368         if (option_mask32 & WGET_OPT_HEADER) bb_error_msg("--header");
1369         if (option_mask32 & WGET_OPT_POST_DATA) bb_error_msg("--post-data");
1370         if (option_mask32 & WGET_OPT_SPIDER) bb_error_msg("--spider");
1371         exit(0);
1372 #endif
1373         argv += optind;
1374
1375 #if ENABLE_FEATURE_WGET_LONG_OPTIONS
1376         if (headers_llist) {
1377                 int size = 0;
1378                 char *hdr;
1379                 llist_t *ll = headers_llist;
1380                 while (ll) {
1381                         size += strlen(ll->data) + 2;
1382                         ll = ll->link;
1383                 }
1384                 G.extra_headers = hdr = xmalloc(size + 1);
1385                 while (headers_llist) {
1386                         int bit;
1387                         const char *words;
1388
1389                         size = sprintf(hdr, "%s\r\n",
1390                                         (char*)llist_pop(&headers_llist));
1391                         /* a bit like index_in_substrings but don't match full key */
1392                         bit = 1;
1393                         words = wget_user_headers;
1394                         while (*words) {
1395                                 if (strstr(hdr, words) == hdr) {
1396                                         G.user_headers |= bit;
1397                                         break;
1398                                 }
1399                                 bit <<= 1;
1400                                 words += strlen(words) + 1;
1401                         }
1402                         hdr += size;
1403                 }
1404         }
1405 #endif
1406
1407         G.output_fd = -1;
1408         G.o_flags = O_WRONLY | O_CREAT | O_TRUNC | O_EXCL;
1409         if (G.fname_out) { /* -O FILE ? */
1410                 if (LONE_DASH(G.fname_out)) { /* -O - ? */
1411                         G.output_fd = 1;
1412                         option_mask32 &= ~WGET_OPT_CONTINUE;
1413                 }
1414                 /* compat with wget: -O FILE can overwrite */
1415                 G.o_flags = O_WRONLY | O_CREAT | O_TRUNC;
1416         }
1417
1418         while (*argv)
1419                 download_one_url(*argv++);
1420
1421         if (G.output_fd >= 0)
1422                 xclose(G.output_fd);
1423
1424 #if ENABLE_FEATURE_CLEAN_UP && ENABLE_FEATURE_WGET_LONG_OPTIONS
1425         free(G.extra_headers);
1426 #endif
1427         FINI_G();
1428
1429         return EXIT_SUCCESS;
1430 }