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

   1 /* Handling of recursive HTTP retrieving.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   3    2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Wget.
   6
   7 GNU Wget is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or
  10  (at your option) any later version.
  11
  12 GNU Wget is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Wget.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 Additional permission under GNU GPL version 3 section 7
  21
  22 If you modify this program, or any covered work, by linking or
  23 combining it with the OpenSSL project's OpenSSL library (or a
  24 modified version of that library), containing parts covered by the
  25 terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
  26 grants you additional permission to convey the resulting work.
  27 Corresponding Source for a non-source form of such a combination
  28 shall include the source code for the parts of OpenSSL used as well
  29 as that of the covered work.  */
  30
  31 #include "wget.h"
  32
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #ifdef HAVE_UNISTD_H
  37 # include <unistd.h>
  38 #endif /* HAVE_UNISTD_H */
  39 #include <errno.h>
  40 #include <assert.h>
  41
  42 #include "url.h"
  43 #include "recur.h"
  44 #include "utils.h"
  45 #include "retr.h"
  46 #include "ftp.h"
  47 #include "host.h"
  48 #include "hash.h"
  49 #include "res.h"
  50 #include "convert.h"
  51 #include "html-url.h"
  52 #include "css-url.h"
  53 #include "spider.h"
  54 \f
  55 /* Functions for maintaining the URL queue.  */
  56
  57 struct queue_element {
  58   const char *url;              /* the URL to download */
  59   const char *referer;          /* the referring document */
  60   int depth;                    /* the depth */
  61   bool html_allowed;            /* whether the document is allowed to
  62                                    be treated as HTML. */
  63   struct iri *iri;                /* sXXXav */
  64   bool css_allowed;             /* whether the document is allowed to
  65                                    be treated as CSS. */
  66   struct queue_element *next;   /* next element in queue */
  67 };
  68
  69 struct url_queue {
  70   struct queue_element *head;
  71   struct queue_element *tail;
  72   int count, maxcount;
  73 };
  74
  75 /* Create a URL queue. */
  76
  77 static struct url_queue *
  78 url_queue_new (void)
  79 {
  80   struct url_queue *queue = xnew0 (struct url_queue);
  81   return queue;
  82 }
  83
  84 /* Delete a URL queue. */
  85
  86 static void
  87 url_queue_delete (struct url_queue *queue)
  88 {
  89   xfree (queue);
  90 }
  91
  92 /* Enqueue a URL in the queue.  The queue is FIFO: the items will be
  93    retrieved ("dequeued") from the queue in the order they were placed
  94    into it.  */
  95
  96 static void
  97 url_enqueue (struct url_queue *queue, struct iri *i,
  98              const char *url, const char *referer, int depth,
  99              bool html_allowed, bool css_allowed)
 100 {
 101   struct queue_element *qel = xnew (struct queue_element);
 102   qel->iri = i;
 103   qel->url = url;
 104   qel->referer = referer;
 105   qel->depth = depth;
 106   qel->html_allowed = html_allowed;
 107   qel->css_allowed = css_allowed;
 108   qel->next = NULL;
 109
 110   ++queue->count;
 111   if (queue->count > queue->maxcount)
 112     queue->maxcount = queue->count;
 113
 114   DEBUGP (("Enqueuing %s at depth %d\n",
 115            quotearg_n_style (0, escape_quoting_style, url), depth));
 116   DEBUGP (("Queue count %d, maxcount %d.\n", queue->count, queue->maxcount));
 117
 118   if (i)
 119     DEBUGP (("[IRI Enqueuing %s with %s\n", quote_n (0, url),
 120              i->uri_encoding ? quote_n (1, i->uri_encoding) : "None"));
 121
 122   if (queue->tail)
 123     queue->tail->next = qel;
 124   queue->tail = qel;
 125
 126   if (!queue->head)
 127     queue->head = queue->tail;
 128 }
 129
 130 /* Take a URL out of the queue.  Return true if this operation
 131    succeeded, or false if the queue is empty.  */
 132
 133 static bool
 134 url_dequeue (struct url_queue *queue, struct iri **i,
 135              const char **url, const char **referer, int *depth,
 136              bool *html_allowed, bool *css_allowed)
 137 {
 138   struct queue_element *qel = queue->head;
 139
 140   if (!qel)
 141     return false;
 142
 143   queue->head = queue->head->next;
 144   if (!queue->head)
 145     queue->tail = NULL;
 146
 147   *i = qel->iri;
 148   *url = qel->url;
 149   *referer = qel->referer;
 150   *depth = qel->depth;
 151   *html_allowed = qel->html_allowed;
 152   *css_allowed = qel->css_allowed;
 153
 154   --queue->count;
 155
 156   DEBUGP (("Dequeuing %s at depth %d\n",
 157            quotearg_n_style (0, escape_quoting_style, qel->url), qel->depth));
 158   DEBUGP (("Queue count %d, maxcount %d.\n", queue->count, queue->maxcount));
 159
 160   xfree (qel);
 161   return true;
 162 }
 163 \f
 164 static bool download_child_p (const struct urlpos *, struct url *, int,
 165                               struct url *, struct hash_table *, struct iri *);
 166 static bool descend_redirect_p (const char *, struct url *, int,
 167                                 struct url *, struct hash_table *, struct iri *);
 168
 169
 170 /* Retrieve a part of the web beginning with START_URL.  This used to
 171    be called "recursive retrieval", because the old function was
 172    recursive and implemented depth-first search.  retrieve_tree on the
 173    other hand implements breadth-search traversal of the tree, which
 174    results in much nicer ordering of downloads.
 175
 176    The algorithm this function uses is simple:
 177
 178    1. put START_URL in the queue.
 179    2. while there are URLs in the queue:
 180
 181      3. get next URL from the queue.
 182      4. download it.
 183      5. if the URL is HTML and its depth does not exceed maximum depth,
 184         get the list of URLs embedded therein.
 185      6. for each of those URLs do the following:
 186
 187        7. if the URL is not one of those downloaded before, and if it
 188           satisfies the criteria specified by the various command-line
 189           options, add it to the queue. */
 190
 191 uerr_t
 192 retrieve_tree (struct url *start_url_parsed, struct iri *pi)
 193 {
 194   uerr_t status = RETROK;
 195
 196   /* The queue of URLs we need to load. */
 197   struct url_queue *queue;
 198
 199   /* The URLs we do not wish to enqueue, because they are already in
 200      the queue, but haven't been downloaded yet.  */
 201   struct hash_table *blacklist;
 202
 203   struct iri *i = iri_new ();
 204
 205 #define COPYSTR(x)  (x) ? xstrdup(x) : NULL;
 206   /* Duplicate pi struct if not NULL */
 207   if (pi)
 208     {
 209       i->uri_encoding = COPYSTR (pi->uri_encoding);
 210       i->content_encoding = COPYSTR (pi->content_encoding);
 211       i->utf8_encode = pi->utf8_encode;
 212     }
 213   else
 214     set_uri_encoding (i, opt.locale, true);
 215 #undef COPYSTR
 216
 217   queue = url_queue_new ();
 218   blacklist = make_string_hash_table (0);
 219
 220   /* Enqueue the starting URL.  Use start_url_parsed->url rather than
 221      just URL so we enqueue the canonical form of the URL.  */
 222   url_enqueue (queue, i, xstrdup (start_url_parsed->url), NULL, 0, true,
 223                false);
 224   string_set_add (blacklist, start_url_parsed->url);
 225
 226   while (1)
 227     {
 228       bool descend = false;
 229       char *url, *referer, *file = NULL;
 230       int depth;
 231       bool html_allowed, css_allowed;
 232       bool is_css = false;
 233       bool dash_p_leaf_HTML = false;
 234
 235       if (opt.quota && total_downloaded_bytes > opt.quota)
 236         break;
 237       if (status == FWRITEERR)
 238         break;
 239
 240       /* Get the next URL from the queue... */
 241
 242       if (!url_dequeue (queue, (struct iri **) &i,
 243                         (const char **)&url, (const char **)&referer,
 244                         &depth, &html_allowed, &css_allowed))
 245         break;
 246
 247       /* ...and download it.  Note that this download is in most cases
 248          unconditional, as download_child_p already makes sure a file
 249          doesn't get enqueued twice -- and yet this check is here, and
 250          not in download_child_p.  This is so that if you run `wget -r
 251          URL1 URL2', and a random URL is encountered once under URL1
 252          and again under URL2, but at a different (possibly smaller)
 253          depth, we want the URL's children to be taken into account
 254          the second time.  */
 255       if (dl_url_file_map && hash_table_contains (dl_url_file_map, url))
 256         {
 257           file = xstrdup (hash_table_get (dl_url_file_map, url));
 258
 259           DEBUGP (("Already downloaded \"%s\", reusing it from \"%s\".\n",
 260                    url, file));
 261
 262           /* this sucks, needs to be combined! */
 263           if (html_allowed
 264               && downloaded_html_set
 265               && string_set_contains (downloaded_html_set, file))
 266             {
 267               descend = true;
 268               is_css = false;
 269             }
 270           if (css_allowed
 271               && downloaded_css_set
 272               && string_set_contains (downloaded_css_set, file))
 273             {
 274               descend = true;
 275               is_css = true;
 276             }
 277         }
 278       else
 279         {
 280           int dt = 0, url_err;
 281           char *redirected = NULL;
 282           struct url *url_parsed = url_parse (url, &url_err, i, true);
 283
 284           status = retrieve_url (url_parsed, url, &file, &redirected, referer,
 285                                  &dt, false, i, true);
 286
 287           if (html_allowed && file && status == RETROK
 288               && (dt & RETROKF) && (dt & TEXTHTML))
 289             {
 290               descend = true;
 291               is_css = false;
 292             }
 293
 294           /* a little different, css_allowed can override content type
 295              lots of web servers serve css with an incorrect content type
 296           */
 297           if (file && status == RETROK
 298               && (dt & RETROKF) &&
 299               ((dt & TEXTCSS) || css_allowed))
 300             {
 301               descend = true;
 302               is_css = true;
 303             }
 304
 305           if (redirected)
 306             {
 307               /* We have been redirected, possibly to another host, or
 308                  different path, or wherever.  Check whether we really
 309                  want to follow it.  */
 310               if (descend)
 311                 {
 312                   if (!descend_redirect_p (redirected, url_parsed, depth,
 313                                            start_url_parsed, blacklist, i))
 314                     descend = false;
 315                   else
 316                     /* Make sure that the old pre-redirect form gets
 317                        blacklisted. */
 318                     string_set_add (blacklist, url);
 319                 }
 320
 321               xfree (url);
 322               url = redirected;
 323             }
 324           else
 325             {
 326               xfree (url);
 327               url = xstrdup (url_parsed->url);
 328             }
 329           url_free(url_parsed);
 330         }
 331
 332       if (opt.spider)
 333         {
 334           visited_url (url, referer);
 335         }
 336
 337       if (descend
 338           && depth >= opt.reclevel && opt.reclevel != INFINITE_RECURSION)
 339         {
 340           if (opt.page_requisites
 341               && (depth == opt.reclevel || depth == opt.reclevel + 1))
 342             {
 343               /* When -p is specified, we are allowed to exceed the
 344                  maximum depth, but only for the "inline" links,
 345                  i.e. those that are needed to display the page.
 346                  Originally this could exceed the depth at most by
 347                  one, but we allow one more level so that the leaf
 348                  pages that contain frames can be loaded
 349                  correctly.  */
 350               dash_p_leaf_HTML = true;
 351             }
 352           else
 353             {
 354               /* Either -p wasn't specified or it was and we've
 355                  already spent the two extra (pseudo-)levels that it
 356                  affords us, so we need to bail out. */
 357               DEBUGP (("Not descending further; at depth %d, max. %d.\n",
 358                        depth, opt.reclevel));
 359               descend = false;
 360             }
 361         }
 362
 363       /* If the downloaded document was HTML or CSS, parse it and enqueue the
 364          links it contains. */
 365
 366       if (descend)
 367         {
 368           bool meta_disallow_follow = false;
 369           struct urlpos *children
 370             = is_css ? get_urls_css_file (file, url) :
 371                        get_urls_html (file, url, &meta_disallow_follow, i);
 372
 373           if (opt.use_robots && meta_disallow_follow)
 374             {
 375               free_urlpos (children);
 376               children = NULL;
 377             }
 378
 379           if (children)
 380             {
 381               struct urlpos *child = children;
 382               struct url *url_parsed = url_parse (url, NULL, i, true);
 383               struct iri *ci;
 384               char *referer_url = url;
 385               bool strip_auth = (url_parsed != NULL
 386                                  && url_parsed->user != NULL);
 387               assert (url_parsed != NULL);
 388
 389               /* Strip auth info if present */
 390               if (strip_auth)
 391                 referer_url = url_string (url_parsed, URL_AUTH_HIDE);
 392
 393               for (; child; child = child->next)
 394                 {
 395                   if (child->ignore_when_downloading)
 396                     continue;
 397                   if (dash_p_leaf_HTML && !child->link_inline_p)
 398                     continue;
 399                   if (download_child_p (child, url_parsed, depth, start_url_parsed,
 400                                         blacklist, i))
 401                     {
 402                       ci = iri_new ();
 403                       set_uri_encoding (ci, i->content_encoding, false);
 404                       url_enqueue (queue, ci, xstrdup (child->url->url),
 405                                    xstrdup (referer_url), depth + 1,
 406                                    child->link_expect_html,
 407                                    child->link_expect_css);
 408                       /* We blacklist the URL we have enqueued, because we
 409                          don't want to enqueue (and hence download) the
 410                          same URL twice.  */
 411                       string_set_add (blacklist, child->url->url);
 412                     }
 413                 }
 414
 415               if (strip_auth)
 416                 xfree (referer_url);
 417               url_free (url_parsed);
 418               free_urlpos (children);
 419             }
 420         }
 421
 422       if (file
 423           && (opt.delete_after
 424               || opt.spider /* opt.recursive is implicitely true */
 425               || !acceptable (file)))
 426         {
 427           /* Either --delete-after was specified, or we loaded this
 428              (otherwise unneeded because of --spider or rejected by -R)
 429              HTML file just to harvest its hyperlinks -- in either case,
 430              delete the local file. */
 431           DEBUGP (("Removing file due to %s in recursive_retrieve():\n",
 432                    opt.delete_after ? "--delete-after" :
 433                    (opt.spider ? "--spider" :
 434                     "recursive rejection criteria")));
 435           logprintf (LOG_VERBOSE,
 436                      (opt.delete_after || opt.spider
 437                       ? _("Removing %s.\n")
 438                       : _("Removing %s since it should be rejected.\n")),
 439                      file);
 440           if (unlink (file))
 441             logprintf (LOG_NOTQUIET, "unlink: %s\n", strerror (errno));
 442           logputs (LOG_VERBOSE, "\n");
 443           register_delete_file (file);
 444         }
 445
 446       xfree (url);
 447       xfree_null (referer);
 448       xfree_null (file);
 449       iri_free (i);
 450     }
 451
 452   /* If anything is left of the queue due to a premature exit, free it
 453      now.  */
 454   {
 455     char *d1, *d2;
 456     int d3;
 457     bool d4, d5;
 458     struct iri *d6;
 459     while (url_dequeue (queue, (struct iri **)&d6,
 460                         (const char **)&d1, (const char **)&d2, &d3, &d4, &d5))
 461       {
 462         iri_free (d6);
 463         xfree (d1);
 464         xfree_null (d2);
 465       }
 466   }
 467   url_queue_delete (queue);
 468
 469   string_set_free (blacklist);
 470
 471   if (opt.quota && total_downloaded_bytes > opt.quota)
 472     return QUOTEXC;
 473   else if (status == FWRITEERR)
 474     return FWRITEERR;
 475   else
 476     return RETROK;
 477 }
 478
 479 /* Based on the context provided by retrieve_tree, decide whether a
 480    URL is to be descended to.  This is only ever called from
 481    retrieve_tree, but is in a separate function for clarity.
 482
 483    The most expensive checks (such as those for robots) are memoized
 484    by storing these URLs to BLACKLIST.  This may or may not help.  It
 485    will help if those URLs are encountered many times.  */
 486
 487 static bool
 488 download_child_p (const struct urlpos *upos, struct url *parent, int depth,
 489                   struct url *start_url_parsed, struct hash_table *blacklist,
 490                   struct iri *iri)
 491 {
 492   struct url *u = upos->url;
 493   const char *url = u->url;
 494   bool u_scheme_like_http;
 495
 496   DEBUGP (("Deciding whether to enqueue \"%s\".\n", url));
 497
 498   if (string_set_contains (blacklist, url))
 499     {
 500       if (opt.spider)
 501         {
 502           char *referrer = url_string (parent, URL_AUTH_HIDE_PASSWD);
 503           DEBUGP (("download_child_p: parent->url is: %s\n", quote (parent->url)));
 504           visited_url (url, referrer);
 505           xfree (referrer);
 506         }
 507       DEBUGP (("Already on the black list.\n"));
 508       goto out;
 509     }
 510
 511   /* Several things to check for:
 512      1. if scheme is not http, and we don't load it
 513      2. check for relative links (if relative_only is set)
 514      3. check for domain
 515      4. check for no-parent
 516      5. check for excludes && includes
 517      6. check for suffix
 518      7. check for same host (if spanhost is unset), with possible
 519      gethostbyname baggage
 520      8. check for robots.txt
 521
 522      Addendum: If the URL is FTP, and it is to be loaded, only the
 523      domain and suffix settings are "stronger".
 524
 525      Note that .html files will get loaded regardless of suffix rules
 526      (but that is remedied later with unlink) unless the depth equals
 527      the maximum depth.
 528
 529      More time- and memory- consuming tests should be put later on
 530      the list.  */
 531
 532   /* Determine whether URL under consideration has a HTTP-like scheme. */
 533   u_scheme_like_http = schemes_are_similar_p (u->scheme, SCHEME_HTTP);
 534
 535   /* 1. Schemes other than HTTP are normally not recursed into. */
 536   if (!u_scheme_like_http && !(u->scheme == SCHEME_FTP && opt.follow_ftp))
 537     {
 538       DEBUGP (("Not following non-HTTP schemes.\n"));
 539       goto out;
 540     }
 541
 542   /* 2. If it is an absolute link and they are not followed, throw it
 543      out.  */
 544   if (u_scheme_like_http)
 545     if (opt.relative_only && !upos->link_relative_p)
 546       {
 547         DEBUGP (("It doesn't really look like a relative link.\n"));
 548         goto out;
 549       }
 550
 551   /* 3. If its domain is not to be accepted/looked-up, chuck it
 552      out.  */
 553   if (!accept_domain (u))
 554     {
 555       DEBUGP (("The domain was not accepted.\n"));
 556       goto out;
 557     }
 558
 559   /* 4. Check for parent directory.
 560
 561      If we descended to a different host or changed the scheme, ignore
 562      opt.no_parent.  Also ignore it for documents needed to display
 563      the parent page when in -p mode.  */
 564   if (opt.no_parent
 565       && schemes_are_similar_p (u->scheme, start_url_parsed->scheme)
 566       && 0 == strcasecmp (u->host, start_url_parsed->host)
 567       && u->port == start_url_parsed->port
 568       && !(opt.page_requisites && upos->link_inline_p))
 569     {
 570       if (!subdir_p (start_url_parsed->dir, u->dir))
 571         {
 572           DEBUGP (("Going to \"%s\" would escape \"%s\" with no_parent on.\n",
 573                    u->dir, start_url_parsed->dir));
 574           goto out;
 575         }
 576     }
 577
 578   /* 5. If the file does not match the acceptance list, or is on the
 579      rejection list, chuck it out.  The same goes for the directory
 580      exclusion and inclusion lists.  */
 581   if (opt.includes || opt.excludes)
 582     {
 583       if (!accdir (u->dir))
 584         {
 585           DEBUGP (("%s (%s) is excluded/not-included.\n", url, u->dir));
 586           goto out;
 587         }
 588     }
 589
 590   /* 6. Check for acceptance/rejection rules.  We ignore these rules
 591      for directories (no file name to match) and for non-leaf HTMLs,
 592      which can lead to other files that do need to be downloaded.  (-p
 593      automatically implies non-leaf because with -p we can, if
 594      necesary, overstep the maximum depth to get the page requisites.)  */
 595   if (u->file[0] != '\0'
 596       && !(has_html_suffix_p (u->file)
 597            /* The exception only applies to non-leaf HTMLs (but -p
 598               always implies non-leaf because we can overstep the
 599               maximum depth to get the requisites): */
 600            && (/* non-leaf */
 601                opt.reclevel == INFINITE_RECURSION
 602                /* also non-leaf */
 603                || depth < opt.reclevel - 1
 604                /* -p, which implies non-leaf (see above) */
 605                || opt.page_requisites)))
 606     {
 607       if (!acceptable (u->file))
 608         {
 609           DEBUGP (("%s (%s) does not match acc/rej rules.\n",
 610                    url, u->file));
 611           goto out;
 612         }
 613     }
 614
 615   /* 7. */
 616   if (schemes_are_similar_p (u->scheme, parent->scheme))
 617     if (!opt.spanhost && 0 != strcasecmp (parent->host, u->host))
 618       {
 619         DEBUGP (("This is not the same hostname as the parent's (%s and %s).\n",
 620                  u->host, parent->host));
 621         goto out;
 622       }
 623
 624   /* 8. */
 625   if (opt.use_robots && u_scheme_like_http)
 626     {
 627       struct robot_specs *specs = res_get_specs (u->host, u->port);
 628       if (!specs)
 629         {
 630           char *rfile;
 631           if (res_retrieve_file (url, &rfile, iri))
 632             {
 633               specs = res_parse_from_file (rfile);
 634
 635               /* Delete the robots.txt file if we chose to either delete the
 636                  files after downloading or we're just running a spider. */
 637               if (opt.delete_after || opt.spider)
 638                 {
 639                   logprintf (LOG_VERBOSE, "Removing %s.\n", rfile);
 640                   if (unlink (rfile))
 641                       logprintf (LOG_NOTQUIET, "unlink: %s\n",
 642                                  strerror (errno));
 643                 }
 644
 645               xfree (rfile);
 646             }
 647           else
 648             {
 649               /* If we cannot get real specs, at least produce
 650                  dummy ones so that we can register them and stop
 651                  trying to retrieve them.  */
 652               specs = res_parse ("", 0);
 653             }
 654           res_register_specs (u->host, u->port, specs);
 655         }
 656
 657       /* Now that we have (or don't have) robots.txt specs, we can
 658          check what they say.  */
 659       if (!res_match_path (specs, u->path))
 660         {
 661           DEBUGP (("Not following %s because robots.txt forbids it.\n", url));
 662           string_set_add (blacklist, url);
 663           goto out;
 664         }
 665     }
 666
 667   /* The URL has passed all the tests.  It can be placed in the
 668      download queue. */
 669   DEBUGP (("Decided to load it.\n"));
 670
 671   return true;
 672
 673  out:
 674   DEBUGP (("Decided NOT to load it.\n"));
 675
 676   return false;
 677 }
 678
 679 /* This function determines whether we will consider downloading the
 680    children of a URL whose download resulted in a redirection,
 681    possibly to another host, etc.  It is needed very rarely, and thus
 682    it is merely a simple-minded wrapper around download_child_p.  */
 683
 684 static bool
 685 descend_redirect_p (const char *redirected, struct url *orig_parsed, int depth,
 686                     struct url *start_url_parsed, struct hash_table *blacklist,
 687                     struct iri *iri)
 688 {
 689   struct url *new_parsed;
 690   struct urlpos *upos;
 691   bool success;
 692
 693   assert (orig_parsed != NULL);
 694
 695   new_parsed = url_parse (redirected, NULL, NULL, false);
 696   assert (new_parsed != NULL);
 697
 698   upos = xnew0 (struct urlpos);
 699   upos->url = new_parsed;
 700
 701   success = download_child_p (upos, orig_parsed, depth,
 702                               start_url_parsed, blacklist, iri);
 703
 704   url_free (new_parsed);
 705   xfree (upos);
 706
 707   if (!success)
 708     DEBUGP (("Redirection \"%s\" failed the test.\n", redirected));
 709
 710   return success;
 711 }
 712
 713 /* vim:set sts=2 sw=2 cino+={s: */