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 /* Retrieve the given URL.  Decides which loop to call -- HTTP(S), FTP,
 302    or simply copy it with file:// (#### the latter not yet
 303    implemented!).  */
 304 uerr_t
 305 retrieve_url (const char *origurl, char **file, char **newloc,
 306               const char *refurl, int *dt)
 307 {
 308   uerr_t result;
 309   char *url;
 310   int location_changed, dummy;
 311   int use_proxy;
 312   char *mynewloc, *proxy;
 313   struct url *u;
 314   int up_error_code;            /* url parse error code */
 315   char *local_file;
 316   struct hash_table *redirections = NULL;
 317
 318   /* If dt is NULL, just ignore it.  */
 319   if (!dt)
 320     dt = &dummy;
 321   url = xstrdup (origurl);
 322   if (newloc)
 323     *newloc = NULL;
 324   if (file)
 325     *file = NULL;
 326
 327   u = url_parse (url, &up_error_code);
 328   if (!u)
 329     {
 330       logprintf (LOG_NOTQUIET, "%s: %s.\n", url, url_error (up_error_code));
 331       if (redirections)
 332         string_set_free (redirections);
 333       xfree (url);
 334       return URLERROR;
 335     }
 336
 337   if (!refurl)
 338     refurl = opt.referer;
 339
 340  redirected:
 341
 342   result = NOCONERROR;
 343   mynewloc = NULL;
 344   local_file = NULL;
 345
 346   use_proxy = USE_PROXY_P (u);
 347   if (use_proxy)
 348     {
 349       struct url *proxy_url;
 350
 351       /* Get the proxy server for the current scheme.  */
 352       proxy = getproxy (u->scheme);
 353       if (!proxy)
 354         {
 355           logputs (LOG_NOTQUIET, _("Could not find proxy host.\n"));
 356           url_free (u);
 357           if (redirections)
 358             string_set_free (redirections);
 359           xfree (url);
 360           return PROXERR;
 361         }
 362
 363       /* Parse the proxy URL.  */
 364       proxy_url = url_parse (proxy, &up_error_code);
 365       if (!proxy_url)
 366         {
 367           logprintf (LOG_NOTQUIET, _("Error parsing proxy URL %s: %s.\n"),
 368                      proxy, url_error (up_error_code));
 369           if (redirections)
 370             string_set_free (redirections);
 371           xfree (url);
 372           return PROXERR;
 373         }
 374       if (proxy_url->scheme != SCHEME_HTTP)
 375         {
 376           logprintf (LOG_NOTQUIET, _("Error in proxy URL %s: Must be HTTP.\n"), proxy);
 377           url_free (proxy_url);
 378           if (redirections)
 379             string_set_free (redirections);
 380           xfree (url);
 381           return PROXERR;
 382         }
 383
 384       result = http_loop (u, &mynewloc, &local_file, refurl, dt, proxy_url);
 385       url_free (proxy_url);
 386     }
 387   else if (u->scheme == SCHEME_HTTP
 388 #ifdef HAVE_SSL
 389       || u->scheme == SCHEME_HTTPS
 390 #endif
 391       )
 392     {
 393       result = http_loop (u, &mynewloc, &local_file, refurl, dt, NULL);
 394     }
 395   else if (u->scheme == SCHEME_FTP)
 396     {
 397       /* If this is a redirection, we must not allow recursive FTP
 398          retrieval, so we save recursion to oldrec, and restore it
 399          later.  */
 400       int oldrec = opt.recursive;
 401       if (redirections)
 402         opt.recursive = 0;
 403       result = ftp_loop (u, dt);
 404       opt.recursive = oldrec;
 405 #if 0
 406       /* There is a possibility of having HTTP being redirected to
 407          FTP.  In these cases we must decide whether the text is HTML
 408          according to the suffix.  The HTML suffixes are `.html' and
 409          `.htm', case-insensitive.  */
 410       if (redirections && u->local && (u->scheme == SCHEME_FTP))
 411         {
 412           char *suf = suffix (u->local);
 413           if (suf && (!strcasecmp (suf, "html") || !strcasecmp (suf, "htm")))
 414             *dt |= TEXTHTML;
 415         }
 416 #endif
 417     }
 418   location_changed = (result == NEWLOCATION);
 419   if (location_changed)
 420     {
 421       char *construced_newloc;
 422       struct url *newloc_parsed;
 423
 424       assert (mynewloc != NULL);
 425
 426       if (local_file)
 427         xfree (local_file);
 428
 429       /* The HTTP specs only allow absolute URLs to appear in
 430          redirects, but a ton of boneheaded webservers and CGIs out
 431          there break the rules and use relative URLs, and popular
 432          browsers are lenient about this, so wget should be too. */
 433       construced_newloc = uri_merge (url, mynewloc);
 434       xfree (mynewloc);
 435       mynewloc = construced_newloc;
 436
 437       /* Now, see if this new location makes sense. */
 438       newloc_parsed = url_parse (mynewloc, &up_error_code);
 439       if (!newloc_parsed)
 440         {
 441           logprintf (LOG_NOTQUIET, "%s: %s.\n", mynewloc,
 442                      url_error (up_error_code));
 443           url_free (u);
 444           if (redirections)
 445             string_set_free (redirections);
 446           xfree (url);
 447           xfree (mynewloc);
 448           return result;
 449         }
 450
 451       /* Now mynewloc will become newloc_parsed->url, because if the
 452          Location contained relative paths like .././something, we
 453          don't want that propagating as url.  */
 454       xfree (mynewloc);
 455       mynewloc = xstrdup (newloc_parsed->url);
 456
 457       if (!redirections)
 458         {
 459           redirections = make_string_hash_table (0);
 460           /* Add current URL immediately so we can detect it as soon
 461              as possible in case of a cycle. */
 462           string_set_add (redirections, u->url);
 463         }
 464
 465       /* The new location is OK.  Check for redirection cycle by
 466          peeking through the history of redirections. */
 467       if (string_set_contains (redirections, newloc_parsed->url))
 468         {
 469           logprintf (LOG_NOTQUIET, _("%s: Redirection cycle detected.\n"),
 470                      mynewloc);
 471           url_free (newloc_parsed);
 472           url_free (u);
 473           if (redirections)
 474             string_set_free (redirections);
 475           xfree (url);
 476           xfree (mynewloc);
 477           return WRONGCODE;
 478         }
 479       string_set_add (redirections, newloc_parsed->url);
 480
 481       xfree (url);
 482       url = mynewloc;
 483       url_free (u);
 484       u = newloc_parsed;
 485       goto redirected;
 486     }
 487
 488   if (local_file)
 489     {
 490       if (*dt & RETROKF)
 491         {
 492           register_download (url, local_file);
 493           if (redirections)
 494             register_all_redirections (redirections, url);
 495           if (*dt & TEXTHTML)
 496             register_html (url, local_file);
 497         }
 498     }
 499
 500   if (file)
 501     *file = local_file ? local_file : NULL;
 502   else
 503     FREE_MAYBE (local_file);
 504
 505   url_free (u);
 506
 507   if (redirections)
 508     {
 509       string_set_free (redirections);
 510       if (newloc)
 511         *newloc = url;
 512       else
 513         xfree (url);
 514     }
 515   else
 516     {
 517       if (newloc)
 518         *newloc = NULL;
 519       xfree (url);
 520     }
 521
 522   ++global_download_count;
 523
 524   return result;
 525 }
 526
 527 /* Find the URLs in the file and call retrieve_url() for each of
 528    them.  If HTML is non-zero, treat the file as HTML, and construct
 529    the URLs accordingly.
 530
 531    If opt.recursive is set, call recursive_retrieve() for each file.  */
 532 uerr_t
 533 retrieve_from_file (const char *file, int html, int *count)
 534 {
 535   uerr_t status;
 536   struct urlpos *url_list, *cur_url;
 537
 538   url_list = (html ? get_urls_html (file, NULL, NULL)
 539               : get_urls_file (file));
 540   status = RETROK;             /* Suppose everything is OK.  */
 541   *count = 0;                  /* Reset the URL count.  */
 542
 543   for (cur_url = url_list; cur_url; cur_url = cur_url->next, ++*count)
 544     {
 545       char *filename = NULL, *new_file = NULL;
 546       int dt;
 547
 548       if (cur_url->ignore_when_downloading)
 549         continue;
 550
 551       if (downloaded_exceeds_quota ())
 552         {
 553           status = QUOTEXC;
 554           break;
 555         }
 556       if (opt.recursive && cur_url->url->scheme != SCHEME_FTP)
 557         status = retrieve_tree (cur_url->url->url);
 558       else
 559         status = retrieve_url (cur_url->url->url, &filename, &new_file, NULL, &dt);
 560
 561       if (filename && opt.delete_after && file_exists_p (filename))
 562         {
 563           DEBUGP (("Removing file due to --delete-after in"
 564                    " retrieve_from_file():\n"));
 565           logprintf (LOG_VERBOSE, _("Removing %s.\n"), filename);
 566           if (unlink (filename))
 567             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
 568           dt &= ~RETROKF;
 569         }
 570
 571       FREE_MAYBE (new_file);
 572       FREE_MAYBE (filename);
 573     }
 574
 575   /* Free the linked list of URL-s.  */
 576   free_urlpos (url_list);
 577
 578   return status;
 579 }
 580
 581 /* Print `giving up', or `retrying', depending on the impending
 582    action.  N1 and N2 are the attempt number and the attempt limit.  */
 583 void
 584 printwhat (int n1, int n2)
 585 {
 586   logputs (LOG_VERBOSE, (n1 == n2) ? _("Giving up.\n\n") : _("Retrying.\n\n"));
 587 }
 588
 589 /* Increment opt.downloaded by BY_HOW_MUCH.  If an overflow occurs,
 590    set opt.downloaded_overflow to 1. */
 591 void
 592 downloaded_increase (unsigned long by_how_much)
 593 {
 594   VERY_LONG_TYPE old;
 595   if (opt.downloaded_overflow)
 596     return;
 597   old = opt.downloaded;
 598   opt.downloaded += by_how_much;
 599   if (opt.downloaded < old)     /* carry flag, where are you when I
 600                                    need you? */
 601     {
 602       /* Overflow. */
 603       opt.downloaded_overflow = 1;
 604       opt.downloaded = ~((VERY_LONG_TYPE)0);
 605     }
 606 }
 607
 608 /* Return non-zero if the downloaded amount of bytes exceeds the
 609    desired quota.  If quota is not set or if the amount overflowed, 0
 610    is returned. */
 611 int
 612 downloaded_exceeds_quota (void)
 613 {
 614   if (!opt.quota)
 615     return 0;
 616   if (opt.downloaded_overflow)
 617     /* We don't really know.  (Wildly) assume not. */
 618     return 0;
 619
 620   return opt.downloaded > opt.quota;
 621 }
 622
 623 /* If opt.wait or opt.waitretry are specified, and if certain
 624    conditions are met, sleep the appropriate number of seconds.  See
 625    the documentation of --wait and --waitretry for more information.
 626
 627    COUNT is the count of current retrieval, beginning with 1. */
 628
 629 void
 630 sleep_between_retrievals (int count)
 631 {
 632   static int first_retrieval = 1;
 633
 634   if (first_retrieval && opt.random_wait)
 635     /* --random-wait uses the RNG, so seed it. */
 636     srand (time (NULL));
 637
 638   if (!first_retrieval && (opt.wait || opt.waitretry))
 639     {
 640       if (opt.waitretry && count > 1)
 641         {
 642           /* If opt.waitretry is specified and this is a retry, wait
 643              for COUNT-1 number of seconds, or for opt.waitretry
 644              seconds.  */
 645           if (count <= opt.waitretry)
 646             sleep (count - 1);
 647           else
 648             sleep (opt.waitretry);
 649         }
 650       else if (opt.wait)
 651         {
 652           /* Otherwise, check if opt.wait is specified.  If so, sleep.  */
 653           if (count > 1 || !opt.random_wait)
 654             sleep (opt.wait);
 655           else
 656             {
 657               int waitmax = 2 * opt.wait;
 658               /* This is equivalent to rand() % waitmax, but uses the
 659                  high-order bits for better randomness.  */
 660               int waitsecs = (double)waitmax * rand () / (RAND_MAX + 1.0);
 661
 662               DEBUGP (("sleep_between_retrievals: norm=%ld,fuzz=%ld,sleep=%d\n",
 663                        opt.wait, waitsecs - opt.wait, waitsecs));
 664
 665               if (waitsecs)
 666                 sleep (waitsecs);
 667             }
 668         }
 669     }
 670   if (first_retrieval)
 671     first_retrieval = 0;
 672 }