sjero.net Git - wget/blob - src/retr.c

   1 /* File retrieval.
   2    Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Wget.
   5
   6 GNU Wget is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Wget is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with Wget; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <sys/types.h>
  25 #ifdef HAVE_UNISTD_H
  26 # include <unistd.h>
  27 #endif /* HAVE_UNISTD_H */
  28 #include <errno.h>
  29 #ifdef HAVE_STRING_H
  30 # include <string.h>
  31 #else
  32 # include <strings.h>
  33 #endif /* HAVE_STRING_H */
  34 #include <assert.h>
  35
  36 #include "wget.h"
  37 #include "utils.h"
  38 #include "retr.h"
  39 #include "progress.h"
  40 #include "url.h"
  41 #include "recur.h"
  42 #include "ftp.h"
  43 #include "host.h"
  44 #include "connect.h"
  45 #include "hash.h"
  46
  47 #ifdef HAVE_SSL
  48 # include "gen_sslfunc.h"       /* for ssl_iread */
  49 #endif
  50
  51 #ifndef errno
  52 extern int errno;
  53 #endif
  54
  55 /* See the comment in gethttp() why this is needed. */
  56 int global_download_count;
  57
  58 \f
  59 static struct {
  60   long bytes;
  61   long dltime;
  62 } limit_data;
  63
  64 static void
  65 limit_bandwidth_reset (void)
  66 {
  67   limit_data.bytes  = 0;
  68   limit_data.dltime = 0;
  69 }
  70
  71 /* Limit the bandwidth by pausing the download for an amount of time.
  72    BYTES is the number of bytes received from the network, DELTA is
  73    how long it took to receive them, DLTIME the current download time,
  74    TIMER the timer, and ADJUSTMENT the previous.  */
  75
  76 static void
  77 limit_bandwidth (long bytes, long delta)
  78 {
  79   long expected;
  80
  81   limit_data.bytes += bytes;
  82   limit_data.dltime += delta;
  83
  84   expected = (long)(1000.0 * limit_data.bytes / opt.limit_rate);
  85
  86   if (expected > limit_data.dltime)
  87     {
  88       long slp = expected - limit_data.dltime;
  89       if (slp < 200)
  90         {
  91           DEBUGP (("deferring a %ld ms sleep (%ld/%ld) until later.\n",
  92                    slp, limit_data.bytes, limit_data.dltime));
  93           return;
  94         }
  95       DEBUGP (("sleeping %ld ms\n", slp));
  96       usleep (1000 * slp);
  97     }
  98
  99   limit_data.bytes = 0;
 100   limit_data.dltime = 0;
 101 }
 102
 103 #define MIN(i, j) ((i) <= (j) ? (i) : (j))
 104
 105 /* Reads the contents of file descriptor FD, until it is closed, or a
 106    read error occurs.  The data is read in 8K chunks, and stored to
 107    stream fp, which should have been open for writing.  If BUF is
 108    non-NULL and its file descriptor is equal to FD, flush RBUF first.
 109    This function will *not* use the rbuf_* functions!
 110
 111    The EXPECTED argument is passed to show_progress() unchanged, but
 112    otherwise ignored.
 113
 114    If opt.verbose is set, the progress is also shown.  RESTVAL
 115    represents a value from which to start downloading (which will be
 116    shown accordingly).  If RESTVAL is non-zero, the stream should have
 117    been open for appending.
 118
 119    The function exits and returns codes of 0, -1 and -2 if the
 120    connection was closed, there was a read error, or if it could not
 121    write to the output stream, respectively.
 122
 123    IMPORTANT: The function flushes the contents of the buffer in
 124    rbuf_flush() before actually reading from fd.  If you wish to read
 125    from fd immediately, flush or discard the buffer.  */
 126 int
 127 get_contents (int fd, FILE *fp, long *len, long restval, long expected,
 128               struct rbuf *rbuf, int use_expected, long *elapsed)
 129 {
 130   int res = 0;
 131   static char c[8192];
 132   void *progress = NULL;
 133   struct wget_timer *timer = wtimer_allocate ();
 134   long dltime = 0, last_dltime = 0;
 135
 136   *len = restval;
 137
 138   if (opt.verbose)
 139     progress = progress_create (restval, expected);
 140
 141   if (rbuf && RBUF_FD (rbuf) == fd)
 142     {
 143       int sz = 0;
 144       while ((res = rbuf_flush (rbuf, c, sizeof (c))) != 0)
 145         {
 146           fwrite (c, sizeof (char), res, fp);
 147           *len += res;
 148           sz += res;
 149         }
 150       if (sz)
 151         fflush (fp);
 152       if (ferror (fp))
 153         {
 154           res = -2;
 155           goto out;
 156         }
 157       if (opt.verbose)
 158         progress_update (progress, sz, 0);
 159     }
 160
 161   if (opt.limit_rate)
 162     limit_bandwidth_reset ();
 163   wtimer_reset (timer);
 164
 165   /* Read from fd while there is available data.
 166
 167      Normally, if expected is 0, it means that it is not known how
 168      much data is expected.  However, if use_expected is specified,
 169      then expected being zero means exactly that.  */
 170   while (!use_expected || (*len < expected))
 171     {
 172       int amount_to_read = (use_expected
 173                             ? MIN (expected - *len, sizeof (c))
 174                             : sizeof (c));
 175 #ifdef HAVE_SSL
 176       if (rbuf->ssl!=NULL)
 177         res = ssl_iread (rbuf->ssl, c, amount_to_read);
 178       else
 179 #endif /* HAVE_SSL */
 180         res = iread (fd, c, amount_to_read);
 181
 182       if (res > 0)
 183         {
 184           fwrite (c, sizeof (char), res, fp);
 185           /* Always flush the contents of the network packet.  This
 186              should not be adverse to performance, as the network
 187              packets typically won't be too tiny anyway.  */
 188           fflush (fp);
 189           if (ferror (fp))
 190             {
 191               res = -2;
 192               goto out;
 193             }
 194
 195           /* If bandwidth is not limited, one call to wtimer_elapsed
 196              is sufficient.  */
 197           dltime = wtimer_elapsed (timer);
 198           if (opt.limit_rate)
 199             {
 200               limit_bandwidth (res, dltime - last_dltime);
 201               dltime = wtimer_elapsed (timer);
 202               last_dltime = dltime;
 203             }
 204
 205           if (opt.verbose)
 206             progress_update (progress, res, dltime);
 207           *len += res;
 208         }
 209       else
 210         break;
 211     }
 212   if (res < -1)
 213     res = -1;
 214
 215  out:
 216   if (opt.verbose)
 217     progress_finish (progress, dltime);
 218   if (elapsed)
 219     *elapsed = dltime;
 220   wtimer_delete (timer);
 221
 222   return res;
 223 }
 224 \f
 225 /* Return a printed representation of the download rate, as
 226    appropriate for the speed.  If PAD is non-zero, strings will be
 227    padded to the width of 7 characters (xxxx.xx).  */
 228 char *
 229 retr_rate (long bytes, long msecs, int pad)
 230 {
 231   static char res[20];
 232   static char *rate_names[] = {"B/s", "KB/s", "MB/s", "GB/s" };
 233   int units = 0;
 234
 235   double dlrate = calc_rate (bytes, msecs, &units);
 236   sprintf (res, pad ? "%7.2f %s" : "%.2f %s", dlrate, rate_names[units]);
 237
 238   return res;
 239 }
 240
 241 /* Calculate the download rate and trim it as appropriate for the
 242    speed.  Appropriate means that if rate is greater than 1K/s,
 243    kilobytes are used, and if rate is greater than 1MB/s, megabytes
 244    are used.
 245
 246    UNITS is zero for B/s, one for KB/s, two for MB/s, and three for
 247    GB/s.  */
 248 double
 249 calc_rate (long bytes, long msecs, int *units)
 250 {
 251   double dlrate;
 252
 253   assert (msecs >= 0);
 254   assert (bytes >= 0);
 255
 256   if (msecs == 0)
 257     /* If elapsed time is 0, it means we're under the granularity of
 258        the timer.  This often happens on systems that use time() for
 259        the timer.  */
 260     msecs = wtimer_granularity ();
 261
 262   dlrate = (double)1000 * bytes / msecs;
 263   if (dlrate < 1024.0)
 264     *units = 0;
 265   else if (dlrate < 1024.0 * 1024.0)
 266     *units = 1, dlrate /= 1024.0;
 267   else if (dlrate < 1024.0 * 1024.0 * 1024.0)
 268     *units = 2, dlrate /= (1024.0 * 1024.0);
 269   else
 270     /* Maybe someone will need this one day.  More realistically, it
 271        will get tickled by buggy timers. */
 272     *units = 3, dlrate /= (1024.0 * 1024.0 * 1024.0);
 273
 274   return dlrate;
 275 }
 276 \f
 277 static int
 278 register_redirections_mapper (void *key, void *value, void *arg)
 279 {
 280   const char *redirected_from = (const char *)key;
 281   const char *redirected_to   = (const char *)arg;
 282   if (0 != strcmp (redirected_from, redirected_to))
 283     register_redirection (redirected_from, redirected_to);
 284   return 0;
 285 }
 286
 287 /* Register the redirections that lead to the successful download of
 288    this URL.  This is necessary so that the link converter can convert
 289    redirected URLs to the local file.  */
 290
 291 static void
 292 register_all_redirections (struct hash_table *redirections, const char *final)
 293 {
 294   hash_table_map (redirections, register_redirections_mapper, (void *)final);
 295 }
 296
 297 #define USE_PROXY_P(u) (opt.use_proxy && getproxy((u)->scheme)          \
 298                         && no_proxy_match((u)->host,                    \
 299                                           (const char **)opt.no_proxy))
 300
 301 /* Maximum number of allowed redirections.  20 was chosen as a
 302    "reasonable" value, which is low enough to not cause havoc, yet
 303    high enough to guarantee that normal retrievals will not be hurt by
 304    the check.  */
 305
 306 #define MAX_REDIRECTIONS 20
 307
 308 /* Retrieve the given URL.  Decides which loop to call -- HTTP, FTP,
 309    FTP, proxy, etc.  */
 310
 311 uerr_t
 312 retrieve_url (const char *origurl, char **file, char **newloc,
 313               const char *refurl, int *dt)
 314 {
 315   uerr_t result;
 316   char *url;
 317   int location_changed, dummy;
 318   int use_proxy;
 319   char *mynewloc, *proxy;
 320   struct url *u;
 321   int up_error_code;            /* url parse error code */
 322   char *local_file;
 323   struct hash_table *redirections = NULL;
 324   int redirection_count = 0;
 325
 326   /* If dt is NULL, just ignore it.  */
 327   if (!dt)
 328     dt = &dummy;
 329   url = xstrdup (origurl);
 330   if (newloc)
 331     *newloc = NULL;
 332   if (file)
 333     *file = NULL;
 334
 335   u = url_parse (url, &up_error_code);
 336   if (!u)
 337     {
 338       logprintf (LOG_NOTQUIET, "%s: %s.\n", url, url_error (up_error_code));
 339       if (redirections)
 340         string_set_free (redirections);
 341       xfree (url);
 342       return URLERROR;
 343     }
 344
 345   if (!refurl)
 346     refurl = opt.referer;
 347
 348  redirected:
 349
 350   result = NOCONERROR;
 351   mynewloc = NULL;
 352   local_file = NULL;
 353
 354   use_proxy = USE_PROXY_P (u);
 355   if (use_proxy)
 356     {
 357       struct url *proxy_url;
 358
 359       /* Get the proxy server for the current scheme.  */
 360       proxy = getproxy (u->scheme);
 361       if (!proxy)
 362         {
 363           logputs (LOG_NOTQUIET, _("Could not find proxy host.\n"));
 364           url_free (u);
 365           if (redirections)
 366             string_set_free (redirections);
 367           xfree (url);
 368           return PROXERR;
 369         }
 370
 371       /* Parse the proxy URL.  */
 372       proxy_url = url_parse (proxy, &up_error_code);
 373       if (!proxy_url)
 374         {
 375           logprintf (LOG_NOTQUIET, _("Error parsing proxy URL %s: %s.\n"),
 376                      proxy, url_error (up_error_code));
 377           if (redirections)
 378             string_set_free (redirections);
 379           xfree (url);
 380           return PROXERR;
 381         }
 382       if (proxy_url->scheme != SCHEME_HTTP)
 383         {
 384           logprintf (LOG_NOTQUIET, _("Error in proxy URL %s: Must be HTTP.\n"), proxy);
 385           url_free (proxy_url);
 386           if (redirections)
 387             string_set_free (redirections);
 388           xfree (url);
 389           return PROXERR;
 390         }
 391
 392       result = http_loop (u, &mynewloc, &local_file, refurl, dt, proxy_url);
 393       url_free (proxy_url);
 394     }
 395   else if (u->scheme == SCHEME_HTTP
 396 #ifdef HAVE_SSL
 397       || u->scheme == SCHEME_HTTPS
 398 #endif
 399       )
 400     {
 401       result = http_loop (u, &mynewloc, &local_file, refurl, dt, NULL);
 402     }
 403   else if (u->scheme == SCHEME_FTP)
 404     {
 405       /* If this is a redirection, we must not allow recursive FTP
 406          retrieval, so we save recursion to oldrec, and restore it
 407          later.  */
 408       int oldrec = opt.recursive;
 409       if (redirections)
 410         opt.recursive = 0;
 411       result = ftp_loop (u, dt);
 412       opt.recursive = oldrec;
 413
 414       /* There is a possibility of having HTTP being redirected to
 415          FTP.  In these cases we must decide whether the text is HTML
 416          according to the suffix.  The HTML suffixes are `.html' and
 417          `.htm', case-insensitive.  */
 418       if (redirections && local_file && u->scheme == SCHEME_FTP)
 419         {
 420           char *suf = suffix (local_file);
 421           if (suf && (!strcasecmp (suf, "html") || !strcasecmp (suf, "htm")))
 422             *dt |= TEXTHTML;
 423         }
 424     }
 425   location_changed = (result == NEWLOCATION);
 426   if (location_changed)
 427     {
 428       char *construced_newloc;
 429       struct url *newloc_parsed;
 430
 431       assert (mynewloc != NULL);
 432
 433       if (local_file)
 434         xfree (local_file);
 435
 436       /* The HTTP specs only allow absolute URLs to appear in
 437          redirects, but a ton of boneheaded webservers and CGIs out
 438          there break the rules and use relative URLs, and popular
 439          browsers are lenient about this, so wget should be too. */
 440       construced_newloc = uri_merge (url, mynewloc);
 441       xfree (mynewloc);
 442       mynewloc = construced_newloc;
 443
 444       /* Now, see if this new location makes sense. */
 445       newloc_parsed = url_parse (mynewloc, &up_error_code);
 446       if (!newloc_parsed)
 447         {
 448           logprintf (LOG_NOTQUIET, "%s: %s.\n", mynewloc,
 449                      url_error (up_error_code));
 450           url_free (u);
 451           if (redirections)
 452             string_set_free (redirections);
 453           xfree (url);
 454           xfree (mynewloc);
 455           return result;
 456         }
 457
 458       /* Now mynewloc will become newloc_parsed->url, because if the
 459          Location contained relative paths like .././something, we
 460          don't want that propagating as url.  */
 461       xfree (mynewloc);
 462       mynewloc = xstrdup (newloc_parsed->url);
 463
 464       if (!redirections)
 465         {
 466           redirections = make_string_hash_table (0);
 467           /* Add current URL immediately so we can detect it as soon
 468              as possible in case of a cycle. */
 469           string_set_add (redirections, u->url);
 470         }
 471
 472       /* The new location is OK.  Check for max. number of
 473          redirections.  */
 474       if (++redirection_count > MAX_REDIRECTIONS)
 475         {
 476           logprintf (LOG_NOTQUIET, _("%d redirections exceeded.\n"),
 477                      MAX_REDIRECTIONS);
 478           url_free (newloc_parsed);
 479           url_free (u);
 480           if (redirections)
 481             string_set_free (redirections);
 482           xfree (url);
 483           xfree (mynewloc);
 484           return WRONGCODE;
 485         }
 486
 487       /*Check for redirection cycle by
 488          peeking through the history of redirections. */
 489       if (string_set_contains (redirections, newloc_parsed->url))
 490         {
 491           logprintf (LOG_NOTQUIET, _("%s: Redirection cycle detected.\n"),
 492                      mynewloc);
 493           url_free (newloc_parsed);
 494           url_free (u);
 495           if (redirections)
 496             string_set_free (redirections);
 497           xfree (url);
 498           xfree (mynewloc);
 499           return WRONGCODE;
 500         }
 501       string_set_add (redirections, newloc_parsed->url);
 502
 503       xfree (url);
 504       url = mynewloc;
 505       url_free (u);
 506       u = newloc_parsed;
 507       goto redirected;
 508     }
 509
 510   if (local_file)
 511     {
 512       if (*dt & RETROKF)
 513         {
 514           register_download (u->url, local_file);
 515           if (redirections)
 516             register_all_redirections (redirections, u->url);
 517           if (*dt & TEXTHTML)
 518             register_html (u->url, local_file);
 519         }
 520     }
 521
 522   if (file)
 523     *file = local_file ? local_file : NULL;
 524   else
 525     FREE_MAYBE (local_file);
 526
 527   url_free (u);
 528
 529   if (redirections)
 530     {
 531       string_set_free (redirections);
 532       if (newloc)
 533         *newloc = url;
 534       else
 535         xfree (url);
 536     }
 537   else
 538     {
 539       if (newloc)
 540         *newloc = NULL;
 541       xfree (url);
 542     }
 543
 544   ++global_download_count;
 545
 546   return result;
 547 }
 548
 549 /* Find the URLs in the file and call retrieve_url() for each of
 550    them.  If HTML is non-zero, treat the file as HTML, and construct
 551    the URLs accordingly.
 552
 553    If opt.recursive is set, call recursive_retrieve() for each file.  */
 554 uerr_t
 555 retrieve_from_file (const char *file, int html, int *count)
 556 {
 557   uerr_t status;
 558   struct urlpos *url_list, *cur_url;
 559
 560   url_list = (html ? get_urls_html (file, NULL, NULL)
 561               : get_urls_file (file));
 562   status = RETROK;             /* Suppose everything is OK.  */
 563   *count = 0;                  /* Reset the URL count.  */
 564
 565   for (cur_url = url_list; cur_url; cur_url = cur_url->next, ++*count)
 566     {
 567       char *filename = NULL, *new_file = NULL;
 568       int dt;
 569
 570       if (cur_url->ignore_when_downloading)
 571         continue;
 572
 573       if (downloaded_exceeds_quota ())
 574         {
 575           status = QUOTEXC;
 576           break;
 577         }
 578       if (opt.recursive && cur_url->url->scheme != SCHEME_FTP)
 579         status = retrieve_tree (cur_url->url->url);
 580       else
 581         status = retrieve_url (cur_url->url->url, &filename, &new_file, NULL, &dt);
 582
 583       if (filename && opt.delete_after && file_exists_p (filename))
 584         {
 585           DEBUGP (("Removing file due to --delete-after in"
 586                    " retrieve_from_file():\n"));
 587           logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
 588           if (unlink (filename))
 589             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
 590           dt &= ~RETROKF;
 591         }
 592
 593       FREE_MAYBE (new_file);
 594       FREE_MAYBE (filename);
 595     }
 596
 597   /* Free the linked list of URL-s.  */
 598   free_urlpos (url_list);
 599
 600   return status;
 601 }
 602
 603 /* Print `giving up', or `retrying', depending on the impending
 604    action.  N1 and N2 are the attempt number and the attempt limit.  */
 605 void
 606 printwhat (int n1, int n2)
 607 {
 608   logputs (LOG_VERBOSE, (n1 == n2) ? _("Giving up.\n\n") : _("Retrying.\n\n"));
 609 }
 610
 611 /* Increment opt.downloaded by BY_HOW_MUCH.  If an overflow occurs,
 612    set opt.downloaded_overflow to 1. */
 613 void
 614 downloaded_increase (unsigned long by_how_much)
 615 {
 616   VERY_LONG_TYPE old;
 617   if (opt.downloaded_overflow)
 618     return;
 619   old = opt.downloaded;
 620   opt.downloaded += by_how_much;
 621   if (opt.downloaded < old)     /* carry flag, where are you when I
 622                                    need you? */
 623     {
 624       /* Overflow. */
 625       opt.downloaded_overflow = 1;
 626       opt.downloaded = ~((VERY_LONG_TYPE)0);
 627     }
 628 }
 629
 630 /* Return non-zero if the downloaded amount of bytes exceeds the
 631    desired quota.  If quota is not set or if the amount overflowed, 0
 632    is returned. */
 633 int
 634 downloaded_exceeds_quota (void)
 635 {
 636   if (!opt.quota)
 637     return 0;
 638   if (opt.downloaded_overflow)
 639     /* We don't really know.  (Wildly) assume not. */
 640     return 0;
 641
 642   return opt.downloaded > opt.quota;
 643 }
 644
 645 /* If opt.wait or opt.waitretry are specified, and if certain
 646    conditions are met, sleep the appropriate number of seconds.  See
 647    the documentation of --wait and --waitretry for more information.
 648
 649    COUNT is the count of current retrieval, beginning with 1. */
 650
 651 void
 652 sleep_between_retrievals (int count)
 653 {
 654   static int first_retrieval = 1;
 655
 656   if (first_retrieval && opt.random_wait)
 657     /* --random-wait uses the RNG, so seed it. */
 658     srand (time (NULL));
 659
 660   if (!first_retrieval && (opt.wait || opt.waitretry))
 661     {
 662       if (opt.waitretry && count > 1)
 663         {
 664           /* If opt.waitretry is specified and this is a retry, wait
 665              for COUNT-1 number of seconds, or for opt.waitretry
 666              seconds.  */
 667           if (count <= opt.waitretry)
 668             sleep (count - 1);
 669           else
 670             sleep (opt.waitretry);
 671         }
 672       else if (opt.wait)
 673         {
 674           /* Otherwise, check if opt.wait is specified.  If so, sleep.  */
 675           if (count > 1 || !opt.random_wait)
 676             sleep (opt.wait);
 677           else
 678             {
 679               int waitmax = 2 * opt.wait;
 680               /* This is equivalent to rand() % waitmax, but uses the
 681                  high-order bits for better randomness.  */
 682               int waitsecs = (double)waitmax * rand () / (RAND_MAX + 1.0);
 683
 684               DEBUGP (("sleep_between_retrievals: norm=%ld,fuzz=%ld,sleep=%d\n",
 685                        opt.wait, waitsecs - opt.wait, waitsecs));
 686
 687               if (waitsecs)
 688                 sleep (waitsecs);
 689             }
 690         }
 691     }
 692   if (first_retrieval)
 693     first_retrieval = 0;
 694 }