sjero.net Git - wget/blob - src/html-url.c

   1 /* Collect URLs from HTML source.
   2    Copyright (C) 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 #ifdef HAVE_STRING_H
  24 # include <string.h>
  25 #else
  26 # include <strings.h>
  27 #endif
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31
  32 #include "wget.h"
  33 #include "html-parse.h"
  34 #include "url.h"
  35 #include "utils.h"
  36
  37 #ifndef errno
  38 extern int errno;
  39 #endif
  40
  41 enum tag_category { TC_LINK, TC_SPEC };
  42
  43 /* Here we try to categorize the known tags.  Each tag has its ID and
  44    cetegory.  Category TC_LINK means that one or more of its
  45    attributes contain links that should be retrieved.  TC_SPEC means
  46    that the tag is specific in some way, and has to be handled
  47    specially. */
  48 static struct {
  49   const char *name;
  50   enum tag_category category;
  51 } known_tags[] = {
  52 #define TAG_A           0
  53   { "a",        TC_LINK },
  54 #define TAG_APPLET      1
  55   { "applet",   TC_LINK },
  56 #define TAG_AREA        2
  57   { "area",     TC_LINK },
  58 #define TAG_BASE        3
  59   { "base",     TC_SPEC },
  60 #define TAG_BGSOUND     4
  61   { "bgsound",  TC_LINK },
  62 #define TAG_BODY        5
  63   { "body",     TC_LINK },
  64 #define TAG_EMBED       6
  65   { "embed",    TC_LINK },
  66 #define TAG_FIG         7
  67   { "fig",      TC_LINK },
  68 #define TAG_FRAME       8
  69   { "frame",    TC_LINK },
  70 #define TAG_IFRAME      9
  71   { "iframe",   TC_LINK },
  72 #define TAG_IMG         10
  73   { "img",      TC_LINK },
  74 #define TAG_INPUT       11
  75   { "input",    TC_LINK },
  76 #define TAG_LAYER       12
  77   { "layer",    TC_LINK },
  78 #define TAG_LINK        13
  79   { "link",     TC_SPEC },
  80 #define TAG_META        14
  81   { "meta",     TC_SPEC },
  82 #define TAG_OVERLAY     15
  83   { "overlay",  TC_LINK },
  84 #define TAG_SCRIPT      16
  85   { "script",   TC_LINK },
  86 #define TAG_TABLE       17
  87   { "table",    TC_LINK },
  88 #define TAG_TD          18
  89   { "td",       TC_LINK },
  90 #define TAG_TH          19
  91   { "th",       TC_LINK }
  92 };
  93
  94
  95 /* Flags for specific url-attr pairs handled through TC_LINK: */
  96
  97 /* This tag points to an external document not necessary for rendering this
  98    document (i.e. it's not an inlined image, stylesheet, etc.). */
  99 #define AF_EXTERNAL 1
 100
 101
 102 /* For tags handled by TC_LINK: attributes that contain URLs to
 103    download. */
 104 static struct {
 105   int tagid;
 106   const char *attr_name;
 107   int flags;
 108 } url_tag_attr_map[] = {
 109   { TAG_A,              "href",         AF_EXTERNAL },
 110   { TAG_APPLET,         "code",         0 },
 111   { TAG_AREA,           "href",         AF_EXTERNAL },
 112   { TAG_BGSOUND,        "src",          0 },
 113   { TAG_BODY,           "background",   0 },
 114   { TAG_EMBED,          "src",          0 },
 115   { TAG_FIG,            "src",          0 },
 116   { TAG_FRAME,          "src",          0 },
 117   { TAG_IFRAME,         "src",          0 },
 118   { TAG_IMG,            "href",         0 },
 119   { TAG_IMG,            "lowsrc",       0 },
 120   { TAG_IMG,            "src",          0 },
 121   { TAG_INPUT,          "src",          0 },
 122   { TAG_LAYER,          "src",          0 },
 123   { TAG_OVERLAY,        "src",          0 },
 124   { TAG_SCRIPT,         "src",          0 },
 125   { TAG_TABLE,          "background",   0 },
 126   { TAG_TD,             "background",   0 },
 127   { TAG_TH,             "background",   0 }
 128 };
 129
 130 /* The lists of interesting tags and attributes are built dynamically,
 131    from the information above.  However, some places in the code refer
 132    to the attributes not mentioned here.  We add them manually.  */
 133 static const char *additional_attributes[] = {
 134   "rel",                        /* for TAG_LINK */
 135   "http-equiv",                 /* for TAG_META */
 136   "name",                       /* for TAG_META */
 137   "content"                     /* for TAG_META */
 138 };
 139
 140 static const char **interesting_tags;
 141 static const char **interesting_attributes;
 142
 143 static void
 144 init_interesting (void)
 145 {
 146   /* Init the variables interesting_tags and interesting_attributes
 147      that are used by the HTML parser to know which tags and
 148      attributes we're interested in.  We initialize this only once,
 149      for performance reasons.
 150
 151      Here we also make sure that what we put in interesting_tags
 152      matches the user's preferences as specified through --ignore-tags
 153      and --follow-tags.  */
 154
 155   {
 156     int i, ind = 0;
 157     int size = ARRAY_SIZE (known_tags);
 158     interesting_tags = (const char **)xmalloc ((size + 1) * sizeof (char *));
 159
 160     for (i = 0; i < size; i++)
 161       {
 162         const char *name = known_tags[i].name;
 163
 164         /* Normally here we could say:
 165            interesting_tags[i] = name;
 166            But we need to respect the settings of --ignore-tags and
 167            --follow-tags, so the code gets a bit hairier.  */
 168
 169         if (opt.ignore_tags)
 170           {
 171             /* --ignore-tags was specified.  Do not match these
 172                specific tags.  --ignore-tags takes precedence over
 173                --follow-tags, so we process --ignore first and fall
 174                through if there's no match. */
 175             int j, lose = 0;
 176             for (j = 0; opt.ignore_tags[j] != NULL; j++)
 177               /* Loop through all the tags this user doesn't care about. */
 178               if (strcasecmp(opt.ignore_tags[j], name) == EQ)
 179                 {
 180                   lose = 1;
 181                   break;
 182                 }
 183             if (lose)
 184               continue;
 185           }
 186
 187         if (opt.follow_tags)
 188           {
 189             /* --follow-tags was specified.  Only match these specific tags, so
 190                continue back to top of for if we don't match one of them. */
 191             int j, win = 0;
 192             for (j = 0; opt.follow_tags[j] != NULL; j++)
 193               /* Loop through all the tags this user cares about. */
 194               if (strcasecmp(opt.follow_tags[j], name) == EQ)
 195                 {
 196                   win = 1;
 197                   break;
 198                 }
 199             if (!win)
 200               continue;  /* wasn't one of the explicitly desired tags */
 201           }
 202
 203         /* If we get to here, --follow-tags isn't being used or the
 204            tag is among the ones that are followed, and --ignore-tags,
 205            if specified, didn't include this tag, so it's an
 206            "interesting" one. */
 207         interesting_tags[ind++] = name;
 208       }
 209     interesting_tags[ind] = NULL;
 210   }
 211
 212   /* The same for attributes, except we loop through url_tag_attr_map.
 213      Here we also need to make sure that the list of attributes is
 214      unique, and to include the attributes from additional_attributes.  */
 215   {
 216     int i, ind;
 217     const char **att = xmalloc ((ARRAY_SIZE (additional_attributes) + 1)
 218                                 * sizeof (char *));
 219     /* First copy the "additional" attributes. */
 220     for (i = 0; i < ARRAY_SIZE (additional_attributes); i++)
 221       att[i] = additional_attributes[i];
 222     ind = i;
 223     att[ind] = NULL;
 224     for (i = 0; i < ARRAY_SIZE (url_tag_attr_map); i++)
 225       {
 226         int j, seen = 0;
 227         const char *look_for = url_tag_attr_map[i].attr_name;
 228         for (j = 0; j < ind - 1; j++)
 229           if (!strcmp (att[j], look_for))
 230             {
 231               seen = 1;
 232               break;
 233             }
 234         if (!seen)
 235           {
 236             att = xrealloc (att, (ind + 2) * sizeof (*att));
 237             att[ind++] = look_for;
 238             att[ind] = NULL;
 239           }
 240       }
 241     interesting_attributes = att;
 242   }
 243 }
 244
 245 static int
 246 find_tag (const char *tag_name)
 247 {
 248   int i;
 249
 250   /* This is linear search; if the number of tags grow, we can switch
 251      to binary search.  */
 252
 253   for (i = 0; i < ARRAY_SIZE (known_tags); i++)
 254     {
 255       int cmp = strcasecmp (known_tags[i].name, tag_name);
 256       /* known_tags are sorted alphabetically, so we can
 257          micro-optimize.  */
 258       if (cmp > 0)
 259         break;
 260       else if (cmp == 0)
 261         return i;
 262     }
 263   return -1;
 264 }
 265
 266 /* Find the value of attribute named NAME in the taginfo TAG.  If the
 267    attribute is not present, return NULL.  If ATTRID is non-NULL, the
 268    exact identity of the attribute will be returned.  */
 269 static char *
 270 find_attr (struct taginfo *tag, const char *name, int *attrid)
 271 {
 272   int i;
 273   for (i = 0; i < tag->nattrs; i++)
 274     if (!strcasecmp (tag->attrs[i].name, name))
 275       {
 276         if (attrid)
 277           *attrid = i;
 278         return tag->attrs[i].value;
 279       }
 280   return NULL;
 281 }
 282
 283 struct collect_urls_closure {
 284   char *text;                   /* HTML text. */
 285   char *base;                   /* Base URI of the document, possibly
 286                                    changed through <base href=...>. */
 287   struct urlpos *head, *tail;   /* List of URLs */
 288   const char *parent_base;      /* Base of the current document. */
 289   const char *document_file;    /* File name of this document. */
 290   int nofollow;                 /* whether NOFOLLOW was specified in a
 291                                    <meta name=robots> tag. */
 292 };
 293
 294 /* Resolve LINK_URI and append it to closure->tail.  TAG and ATTRID
 295    are the necessary context to store the position and size.  */
 296
 297 static struct urlpos *
 298 handle_link (struct collect_urls_closure *closure, const char *link_uri,
 299              struct taginfo *tag, int attrid)
 300 {
 301   int link_has_scheme = url_has_scheme (link_uri);
 302   struct urlpos *newel;
 303   const char *base = closure->base ? closure->base : closure->parent_base;
 304   struct url *url;
 305
 306   if (!base)
 307     {
 308       DEBUGP (("%s: no base, merge will use \"%s\".\n",
 309                closure->document_file, link_uri));
 310
 311       if (!link_has_scheme)
 312         {
 313           /* We have no base, and the link does not have a host
 314              attached to it.  Nothing we can do.  */
 315           /* #### Should we print a warning here?  Wget 1.5.x used to.  */
 316           return NULL;
 317         }
 318
 319       url = url_parse (link_uri, NULL);
 320       if (!url)
 321         {
 322           DEBUGP (("%s: link \"%s\" doesn't parse.\n",
 323                    closure->document_file, link_uri));
 324           return NULL;
 325         }
 326     }
 327   else
 328     {
 329       /* Merge BASE with LINK_URI, but also make sure the result is
 330          canonicalized, i.e. that "../" have been resolved.
 331          (parse_url will do that for us.) */
 332
 333       char *complete_uri = uri_merge (base, link_uri);
 334
 335       DEBUGP (("%s: merge(\"%s\", \"%s\") -> %s\n",
 336                closure->document_file, base, link_uri, complete_uri));
 337
 338       url = url_parse (complete_uri, NULL);
 339       if (!url)
 340         {
 341           DEBUGP (("%s: merged link \"%s\" doesn't parse.\n",
 342                    closure->document_file, complete_uri));
 343           xfree (complete_uri);
 344           return NULL;
 345         }
 346       xfree (complete_uri);
 347     }
 348
 349   newel = (struct urlpos *)xmalloc (sizeof (struct urlpos));
 350
 351   memset (newel, 0, sizeof (*newel));
 352   newel->next = NULL;
 353   newel->url = url;
 354   newel->pos = tag->attrs[attrid].value_raw_beginning - closure->text;
 355   newel->size = tag->attrs[attrid].value_raw_size;
 356
 357   /* A URL is relative if the host is not named, and the name does not
 358      start with `/'.  */
 359   if (!link_has_scheme && *link_uri != '/')
 360     newel->link_relative_p = 1;
 361   else if (link_has_scheme)
 362     newel->link_complete_p = 1;
 363
 364   if (closure->tail)
 365     {
 366       closure->tail->next = newel;
 367       closure->tail = newel;
 368     }
 369   else
 370     closure->tail = closure->head = newel;
 371
 372   return newel;
 373 }
 374
 375 /* Examine name and attributes of TAG and take appropriate action.
 376    What will be done depends on TAG's category and attribute values.
 377    Tags of TC_LINK category have attributes that contain links to
 378    follow; tags of TC_SPEC category need to be handled specially.
 379
 380    #### It would be nice to split this into several functions.  */
 381
 382 static void
 383 collect_tags_mapper (struct taginfo *tag, void *arg)
 384 {
 385   struct collect_urls_closure *closure = (struct collect_urls_closure *)arg;
 386   int tagid = find_tag (tag->name);
 387   assert (tagid != -1);
 388
 389   switch (known_tags[tagid].category)
 390     {
 391     case TC_LINK:
 392       {
 393         int i, id, first;
 394         int size = ARRAY_SIZE (url_tag_attr_map);
 395         for (i = 0; i < size; i++)
 396           if (url_tag_attr_map[i].tagid == tagid)
 397             break;
 398         /* We've found the index of url_tag_attr_map where the
 399            attributes of our tags begin.  Now, look for every one of
 400            them, and handle it.  */
 401         /* Need to process the attributes in the order they appear in
 402            the tag, as this is required if we convert links.  */
 403         first = i;
 404         for (id = 0; id < tag->nattrs; id++)
 405           {
 406             /* This nested loop may seem inefficient (O(n^2)), but it's
 407                not, since the number of attributes (n) we loop over is
 408                extremely small.  In the worst case of IMG with all its
 409                possible attributes, n^2 will be only 9.  */
 410             for (i = first; (i < size && url_tag_attr_map[i].tagid == tagid);
 411                  i++)
 412               {
 413                 if (0 == strcasecmp (tag->attrs[id].name,
 414                                      url_tag_attr_map[i].attr_name))
 415                   {
 416                     char *attr_value = tag->attrs[id].value;
 417                     if (attr_value)
 418                       {
 419                         struct urlpos *entry;
 420                         entry = handle_link (closure, attr_value, tag, id);
 421                         if (entry != NULL
 422                             && !(url_tag_attr_map[i].flags & AF_EXTERNAL))
 423                           entry->link_inline_p = 1;
 424                       }
 425                   }
 426               }
 427           }
 428       }
 429       break;
 430     case TC_SPEC:
 431       switch (tagid)
 432         {
 433         case TAG_BASE:
 434           {
 435             struct urlpos *base_urlpos;
 436             int id;
 437             char *newbase = find_attr (tag, "href", &id);
 438             if (!newbase)
 439               break;
 440
 441             base_urlpos = handle_link (closure, newbase, tag, id);
 442             if (!base_urlpos)
 443               break;
 444             base_urlpos->ignore_when_downloading = 1;
 445             base_urlpos->link_base_p = 1;
 446
 447             if (closure->base)
 448               xfree (closure->base);
 449             if (closure->parent_base)
 450               closure->base = uri_merge (closure->parent_base, newbase);
 451             else
 452               closure->base = xstrdup (newbase);
 453           }
 454           break;
 455         case TAG_LINK:
 456           {
 457             int id;
 458             char *href = find_attr (tag, "href", &id);
 459
 460             /* All <link href="..."> link references are external,
 461                except for <link rel="stylesheet" href="...">.  */
 462             if (href)
 463               {
 464                 struct urlpos *entry;
 465                 entry = handle_link (closure, href, tag, id);
 466                 if (entry != NULL)
 467                   {
 468                     char *rel  = find_attr (tag, "rel", NULL);
 469                     if (rel && 0 == strcasecmp (rel, "stylesheet"))
 470                       entry->link_inline_p = 1;
 471                   }
 472               }
 473           }
 474           break;
 475         case TAG_META:
 476           /* Some pages use a META tag to specify that the page be
 477              refreshed by a new page after a given number of seconds.
 478              The general format for this is:
 479
 480              <meta http-equiv=Refresh content="NUMBER; URL=index2.html">
 481
 482              So we just need to skip past the "NUMBER; URL=" garbage
 483              to get to the URL.  */
 484           {
 485             char *name = find_attr (tag, "name", NULL);
 486             char *http_equiv = find_attr (tag, "http-equiv", NULL);
 487             if (http_equiv && !strcasecmp (http_equiv, "refresh"))
 488               {
 489                 struct urlpos *entry;
 490
 491                 int id;
 492                 char *p, *refresh = find_attr (tag, "content", &id);
 493                 int timeout = 0;
 494
 495                 for (p = refresh; ISDIGIT (*p); p++)
 496                   timeout = 10 * timeout + *p - '0';
 497                 if (*p++ != ';')
 498                   return;
 499
 500                 while (ISSPACE (*p))
 501                   ++p;
 502                 if (!(TOUPPER (*p) == 'U'
 503                       && TOUPPER (*(p + 1)) == 'R'
 504                       && TOUPPER (*(p + 2)) == 'L'
 505                       && *(p + 3) == '='))
 506                   return;
 507                 p += 4;
 508                 while (ISSPACE (*p))
 509                   ++p;
 510
 511                 entry = handle_link (closure, p, tag, id);
 512                 if (entry)
 513                   {
 514                     entry->link_refresh_p = 1;
 515                     entry->refresh_timeout = timeout;
 516                   }
 517               }
 518             else if (name && !strcasecmp (name, "robots"))
 519               {
 520                 /* Handle stuff like:
 521                    <meta name="robots" content="index,nofollow"> */
 522                 char *content = find_attr (tag, "content", NULL);
 523                 if (!content)
 524                   return;
 525                 if (!strcasecmp (content, "none"))
 526                   closure->nofollow = 1;
 527                 else
 528                   {
 529                     while (*content)
 530                       {
 531                         /* Find the next occurrence of ',' or the end of
 532                            the string.  */
 533                         char *end = strchr (content, ',');
 534                         if (end)
 535                           ++end;
 536                         else
 537                           end = content + strlen (content);
 538                         if (!strncasecmp (content, "nofollow", end - content))
 539                           closure->nofollow = 1;
 540                         content = end;
 541                       }
 542                   }
 543               }
 544           }
 545           break;
 546         default:
 547           /* Category is TC_SPEC, but tag name is unhandled.  This
 548              must not be.  */
 549           abort ();
 550         }
 551       break;
 552     }
 553 }
 554
 555 /* Analyze HTML tags FILE and construct a list of URLs referenced from
 556    it.  It merges relative links in FILE with URL.  It is aware of
 557    <base href=...> and does the right thing.  */
 558 struct urlpos *
 559 get_urls_html (const char *file, const char *url, int *meta_disallow_follow)
 560 {
 561   struct file_memory *fm;
 562   struct collect_urls_closure closure;
 563
 564   /* Load the file. */
 565   fm = read_file (file);
 566   if (!fm)
 567     {
 568       logprintf (LOG_NOTQUIET, "%s: %s\n", file, strerror (errno));
 569       return NULL;
 570     }
 571   DEBUGP (("Loaded %s (size %ld).\n", file, fm->length));
 572
 573   closure.text = fm->content;
 574   closure.head = closure.tail = NULL;
 575   closure.base = NULL;
 576   closure.parent_base = url ? url : opt.base_href;
 577   closure.document_file = file;
 578   closure.nofollow = 0;
 579
 580   if (!interesting_tags)
 581     init_interesting ();
 582
 583   map_html_tags (fm->content, fm->length, interesting_tags,
 584                  interesting_attributes, collect_tags_mapper, &closure);
 585
 586   DEBUGP (("no-follow in %s: %d\n", file, closure.nofollow));
 587   if (meta_disallow_follow)
 588     *meta_disallow_follow = closure.nofollow;
 589
 590   FREE_MAYBE (closure.base);
 591   read_file_free (fm);
 592   return closure.head;
 593 }
 594
 595 void
 596 cleanup_html_url (void)
 597 {
 598   FREE_MAYBE (interesting_tags);
 599   FREE_MAYBE (interesting_attributes);
 600 }