1 /* Conversion of links to local files.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007,
3 2008 Free Software Foundation, Inc.
5 This file is part of GNU Wget.
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.
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.
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/>.
20 Additional permission under GNU GPL version 3 section 7
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. */
38 #endif /* HAVE_UNISTD_H */
49 static struct hash_table *dl_file_url_map;
50 struct hash_table *dl_url_file_map;
52 /* Set of HTML files downloaded in this Wget run, used for link
53 conversion after Wget is done. */
54 struct hash_table *downloaded_html_set;
56 static void convert_links (const char *, struct urlpos *);
58 /* This function is called when the retrieval is done to convert the
59 links that have been downloaded. It has to be called at the end of
60 the retrieval, because only then does Wget know conclusively which
61 URLs have been downloaded, and which not, so it can tell which
62 direction to convert to.
64 The "direction" means that the URLs to the files that have been
65 downloaded get converted to the relative URL which will point to
66 that file. And the other URLs get converted to the remote URL on
69 All the downloaded HTMLs are kept in downloaded_html_files, and
70 downloaded URLs in urls_downloaded. All the information is
71 extracted from these two lists. */
74 convert_all_links (void)
80 struct ptimer *timer = ptimer_new ();
86 if (downloaded_html_set)
87 cnt = hash_table_count (downloaded_html_set);
90 file_array = alloca_array (char *, cnt);
91 string_set_to_array (downloaded_html_set, file_array);
93 for (i = 0; i < cnt; i++)
95 struct urlpos *urls, *cur_url;
97 char *file = file_array[i];
99 /* Determine the URL of the HTML file. get_urls_html will need
101 url = hash_table_get (dl_file_url_map, file);
104 DEBUGP (("Apparently %s has been removed.\n", file));
108 DEBUGP (("Scanning %s (from %s)\n", file, url));
110 /* Parse the HTML file... */
111 urls = get_urls_html (file, url, NULL);
113 /* We don't respect meta_disallow_follow here because, even if
114 the file is not followed, we might still want to convert the
115 links that have been followed from other files. */
117 for (cur_url = urls; cur_url; cur_url = cur_url->next)
120 struct url *u = cur_url->url;
122 if (cur_url->link_base_p)
124 /* Base references have been resolved by our parser, so
125 we turn the base URL into an empty string. (Perhaps
126 we should remove the tag entirely?) */
127 cur_url->convert = CO_NULLIFY_BASE;
131 /* We decide the direction of conversion according to whether
132 a URL was downloaded. Downloaded URLs will be converted
133 ABS2REL, whereas non-downloaded will be converted REL2ABS. */
134 local_name = hash_table_get (dl_url_file_map, u->url);
136 /* Decide on the conversion type. */
139 /* We've downloaded this URL. Convert it to relative
140 form. We do this even if the URL already is in
141 relative form, because our directory structure may
142 not be identical to that on the server (think `-nd',
143 `--cut-dirs', etc.) */
144 cur_url->convert = CO_CONVERT_TO_RELATIVE;
145 cur_url->local_name = xstrdup (local_name);
146 DEBUGP (("will convert url %s to local %s\n", u->url, local_name));
150 /* We haven't downloaded this URL. If it's not already
151 complete (including a full host name), convert it to
152 that form, so it can be reached while browsing this
154 if (!cur_url->link_complete_p)
155 cur_url->convert = CO_CONVERT_TO_COMPLETE;
156 cur_url->local_name = NULL;
157 DEBUGP (("will convert url %s to complete\n", u->url));
161 /* Convert the links in the file. */
162 convert_links (file, urls);
169 secs = ptimer_measure (timer);
170 logprintf (LOG_VERBOSE, _("Converted %d files in %s seconds.\n"),
171 file_count, print_decimal (secs));
173 ptimer_destroy (timer);
176 static void write_backup_file (const char *, downloaded_file_t);
177 static const char *replace_attr (const char *, int, FILE *, const char *);
178 static const char *replace_attr_refresh_hack (const char *, int, FILE *,
180 static char *local_quote_string (const char *);
181 static char *construct_relative (const char *, const char *);
183 /* Change the links in one HTML file. LINKS is a list of links in the
184 document, along with their positions and the desired direction of
187 convert_links (const char *file, struct urlpos *links)
189 struct file_memory *fm;
192 downloaded_file_t downloaded_file_return;
195 int to_url_count = 0, to_file_count = 0;
197 logprintf (LOG_VERBOSE, _("Converting %s... "), file);
200 /* First we do a "dry run": go through the list L and see whether
201 any URL needs to be converted in the first place. If not, just
202 leave the file alone. */
205 for (dry = links; dry; dry = dry->next)
206 if (dry->convert != CO_NOCONVERT)
210 logputs (LOG_VERBOSE, _("nothing to do.\n"));
215 fm = read_file (file);
218 logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
219 file, strerror (errno));
223 downloaded_file_return = downloaded_file (CHECK_FOR_FILE, file);
224 if (opt.backup_converted && downloaded_file_return)
225 write_backup_file (file, downloaded_file_return);
227 /* Before opening the file for writing, unlink the file. This is
228 important if the data in FM is mmaped. In such case, nulling the
229 file, which is what fopen() below does, would make us read all
230 zeroes from the mmaped region. */
231 if (unlink (file) < 0 && errno != ENOENT)
233 logprintf (LOG_NOTQUIET, _("Unable to delete `%s': %s\n"),
234 file, strerror (errno));
238 /* Now open the file for writing. */
239 fp = fopen (file, "wb");
242 logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
243 file, strerror (errno));
248 /* Here we loop through all the URLs in file, replacing those of
249 them that are downloaded with relative references. */
251 for (link = links; link; link = link->next)
253 char *url_start = fm->content + link->pos;
255 if (link->pos >= fm->length)
257 DEBUGP (("Something strange is going on. Please investigate."));
260 /* If the URL is not to be converted, skip it. */
261 if (link->convert == CO_NOCONVERT)
263 DEBUGP (("Skipping %s at position %d.\n", link->url->url, link->pos));
267 /* Echo the file contents, up to the offending URL's opening
268 quote, to the outfile. */
269 fwrite (p, 1, url_start - p, fp);
272 switch (link->convert)
274 case CO_CONVERT_TO_RELATIVE:
275 /* Convert absolute URL to relative. */
277 char *newname = construct_relative (file, link->local_name);
278 char *quoted_newname = local_quote_string (newname);
280 if (!link->link_refresh_p)
281 p = replace_attr (p, link->size, fp, quoted_newname);
283 p = replace_attr_refresh_hack (p, link->size, fp, quoted_newname,
284 link->refresh_timeout);
286 DEBUGP (("TO_RELATIVE: %s to %s at position %d in %s.\n",
287 link->url->url, newname, link->pos, file));
289 xfree (quoted_newname);
293 case CO_CONVERT_TO_COMPLETE:
294 /* Convert the link to absolute URL. */
296 char *newlink = link->url->url;
297 char *quoted_newlink = html_quote_string (newlink);
299 if (!link->link_refresh_p)
300 p = replace_attr (p, link->size, fp, quoted_newlink);
302 p = replace_attr_refresh_hack (p, link->size, fp, quoted_newlink,
303 link->refresh_timeout);
305 DEBUGP (("TO_COMPLETE: <something> to %s at position %d in %s.\n",
306 newlink, link->pos, file));
307 xfree (quoted_newlink);
311 case CO_NULLIFY_BASE:
312 /* Change the base href to "". */
313 p = replace_attr (p, link->size, fp, "");
321 /* Output the rest of the file. */
322 if (p - fm->content < fm->length)
323 fwrite (p, 1, fm->length - (p - fm->content), fp);
327 logprintf (LOG_VERBOSE, "%d-%d\n", to_file_count, to_url_count);
330 /* Construct and return a link that points from BASEFILE to LINKFILE.
331 Both files should be local file names, BASEFILE of the referrering
332 file, and LINKFILE of the referred file.
336 cr("foo", "bar") -> "bar"
337 cr("A/foo", "A/bar") -> "bar"
338 cr("A/foo", "A/B/bar") -> "B/bar"
339 cr("A/X/foo", "A/Y/bar") -> "../Y/bar"
340 cr("X/", "Y/bar") -> "../Y/bar" (trailing slash does matter in BASE)
342 Both files should be absolute or relative, otherwise strange
343 results might ensue. The function makes no special efforts to
344 handle "." and ".." in links, so make sure they're not there
345 (e.g. using path_simplify). */
348 construct_relative (const char *basefile, const char *linkfile)
355 /* First, skip the initial directory components common to both
358 for (b = basefile, l = linkfile; *b == *l && *b != '\0'; ++b, ++l)
361 start = (b - basefile) + 1;
366 /* With common directories out of the way, the situation we have is
368 b - b1/b2/[...]/bfile
369 l - l1/l2/[...]/lfile
371 The link we're constructing needs to be:
372 lnk - ../../l1/l2/[...]/lfile
374 Where the number of ".."'s equals the number of bN directory
377 /* Count the directory components in B. */
379 for (b = basefile; *b; b++)
385 /* Construct LINK as explained above. */
386 link = xmalloc (3 * basedirs + strlen (linkfile) + 1);
387 for (i = 0; i < basedirs; i++)
388 memcpy (link + 3 * i, "../", 3);
389 strcpy (link + 3 * i, linkfile);
393 /* Used by write_backup_file to remember which files have been
395 static struct hash_table *converted_files;
398 write_backup_file (const char *file, downloaded_file_t downloaded_file_return)
400 /* Rather than just writing over the original .html file with the
401 converted version, save the former to *.orig. Note we only do
402 this for files we've _successfully_ downloaded, so we don't
403 clobber .orig files sitting around from previous invocations. */
405 /* Construct the backup filename as the original name plus ".orig". */
406 size_t filename_len = strlen (file);
407 char* filename_plus_orig_suffix;
409 if (downloaded_file_return == FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED)
411 /* Just write "orig" over "html". We need to do it this way
412 because when we're checking to see if we've downloaded the
413 file before (to see if we can skip downloading it), we don't
414 know if it's a text/html file. Therefore we don't know yet
415 at that stage that -E is going to cause us to tack on
416 ".html", so we need to compare vs. the original URL plus
417 ".orig", not the original URL plus ".html.orig". */
418 filename_plus_orig_suffix = alloca (filename_len + 1);
419 strcpy (filename_plus_orig_suffix, file);
420 strcpy ((filename_plus_orig_suffix + filename_len) - 4, "orig");
422 else /* downloaded_file_return == FILE_DOWNLOADED_NORMALLY */
424 /* Append ".orig" to the name. */
425 filename_plus_orig_suffix = alloca (filename_len + sizeof (".orig"));
426 strcpy (filename_plus_orig_suffix, file);
427 strcpy (filename_plus_orig_suffix + filename_len, ".orig");
430 if (!converted_files)
431 converted_files = make_string_hash_table (0);
433 /* We can get called twice on the same URL thanks to the
434 convert_all_links() call in main(). If we write the .orig file
435 each time in such a case, it'll end up containing the first-pass
436 conversion, not the original file. So, see if we've already been
437 called on this file. */
438 if (!string_set_contains (converted_files, file))
440 /* Rename <file> to <file>.orig before former gets written over. */
441 if (rename (file, filename_plus_orig_suffix) != 0)
442 logprintf (LOG_NOTQUIET, _("Cannot back up %s as %s: %s\n"),
443 file, filename_plus_orig_suffix, strerror (errno));
445 /* Remember that we've already written a .orig backup for this file.
446 Note that we never free this memory since we need it till the
447 convert_all_links() call, which is one of the last things the
448 program does before terminating. BTW, I'm not sure if it would be
449 safe to just set 'converted_file_ptr->string' to 'file' below,
450 rather than making a copy of the string... Another note is that I
451 thought I could just add a field to the urlpos structure saying
452 that we'd written a .orig file for this URL, but that didn't work,
453 so I had to make this separate list.
454 -- Dan Harkless <wget@harkless.org>
456 This [adding a field to the urlpos structure] didn't work
457 because convert_file() is called from convert_all_links at
458 the end of the retrieval with a freshly built new urlpos
460 -- Hrvoje Niksic <hniksic@xemacs.org>
462 string_set_add (converted_files, file);
466 static bool find_fragment (const char *, int, const char **, const char **);
468 /* Replace an attribute's original text with NEW_TEXT. */
471 replace_attr (const char *p, int size, FILE *fp, const char *new_text)
473 bool quote_flag = false;
474 char quote_char = '\"'; /* use "..." for quoting, unless the
475 original value is quoted, in which
476 case reuse its quoting char. */
477 const char *frag_beg, *frag_end;
479 /* Structure of our string is:
481 <--- size ---> (with quotes)
484 <--- size --> (no quotes) */
486 if (*p == '\"' || *p == '\'')
491 size -= 2; /* disregard opening and closing quote */
493 putc (quote_char, fp);
494 fputs (new_text, fp);
496 /* Look for fragment identifier, if any. */
497 if (find_fragment (p, size, &frag_beg, &frag_end))
498 fwrite (frag_beg, 1, frag_end - frag_beg, fp);
502 putc (quote_char, fp);
507 /* The same as REPLACE_ATTR, but used when replacing
508 <meta http-equiv=refresh content="new_text"> because we need to
509 append "timeout_value; URL=" before the next_text. */
512 replace_attr_refresh_hack (const char *p, int size, FILE *fp,
513 const char *new_text, int timeout)
516 char *new_with_timeout = (char *)alloca (numdigit (timeout)
520 sprintf (new_with_timeout, "%d; URL=%s", timeout, new_text);
522 return replace_attr (p, size, fp, new_with_timeout);
525 /* Find the first occurrence of '#' in [BEG, BEG+SIZE) that is not
526 preceded by '&'. If the character is not found, return zero. If
527 the character is found, return true and set BP and EP to point to
528 the beginning and end of the region.
530 This is used for finding the fragment indentifiers in URLs. */
533 find_fragment (const char *beg, int size, const char **bp, const char **ep)
535 const char *end = beg + size;
536 bool saw_amp = false;
537 for (; beg < end; beg++)
559 /* Quote FILE for use as local reference to an HTML file.
561 We quote ? as %3F to avoid passing part of the file name as the
562 parameter when browsing the converted file through HTTP. However,
563 it is safe to do this only when `--html-extension' is turned on.
564 This is because converting "index.html?foo=bar" to
565 "index.html%3Ffoo=bar" would break local browsing, as the latter
566 isn't even recognized as an HTML file! However, converting
567 "index.html?foo=bar.html" to "index.html%3Ffoo=bar.html" should be
568 safe for both local and HTTP-served browsing.
570 We always quote "#" as "%23" and "%" as "%25" because those
571 characters have special meanings in URLs. */
574 local_quote_string (const char *file)
579 char *any = strpbrk (file, "?#%");
581 return html_quote_string (file);
583 /* Allocate space assuming the worst-case scenario, each character
584 having to be quoted. */
585 to = newname = (char *)alloca (3 * strlen (file) + 1);
586 for (from = file; *from; from++)
600 if (opt.html_extension)
613 return html_quote_string (newname);
616 /* Book-keeping code for dl_file_url_map, dl_url_file_map,
617 downloaded_html_list, and downloaded_html_set. Other code calls
618 these functions to let us know that a file has been downloaded. */
620 #define ENSURE_TABLES_EXIST do { \
621 if (!dl_file_url_map) \
622 dl_file_url_map = make_string_hash_table (0); \
623 if (!dl_url_file_map) \
624 dl_url_file_map = make_string_hash_table (0); \
627 /* Return true if S1 and S2 are the same, except for "/index.html".
628 The three cases in which it returns one are (substitute any
629 substring for "foo"):
631 m("foo/index.html", "foo/") ==> 1
632 m("foo/", "foo/index.html") ==> 1
633 m("foo", "foo/index.html") ==> 1
634 m("foo", "foo/" ==> 1
635 m("foo", "foo") ==> 1 */
638 match_except_index (const char *s1, const char *s2)
643 /* Skip common substring. */
644 for (i = 0; *s1 && *s2 && *s1 == *s2; s1++, s2++, i++)
647 /* Strings differ at the very beginning -- bail out. We need to
648 check this explicitly to avoid `lng - 1' reading outside the
653 /* Both strings hit EOF -- strings are equal. */
656 /* Strings are randomly different, e.g. "/foo/bar" and "/foo/qux". */
659 /* S1 is the longer one. */
662 /* S2 is the longer one. */
666 /* foo/index.html */ /* or */ /* foo/index.html */
670 /* The right-hand case. */
673 if (*lng == '/' && *(lng + 1) == '\0')
678 return 0 == strcmp (lng, "/index.html");
682 dissociate_urls_from_file_mapper (void *key, void *value, void *arg)
684 char *mapping_url = (char *)key;
685 char *mapping_file = (char *)value;
686 char *file = (char *)arg;
688 if (0 == strcmp (mapping_file, file))
690 hash_table_remove (dl_url_file_map, mapping_url);
692 xfree (mapping_file);
695 /* Continue mapping. */
699 /* Remove all associations from various URLs to FILE from dl_url_file_map. */
702 dissociate_urls_from_file (const char *file)
704 /* Can't use hash_table_iter_* because the table mutates while mapping. */
705 hash_table_for_each (dl_url_file_map, dissociate_urls_from_file_mapper,
709 /* Register that URL has been successfully downloaded to FILE. This
710 is used by the link conversion code to convert references to URLs
711 to references to local files. It is also being used to check if a
712 URL has already been downloaded. */
715 register_download (const char *url, const char *file)
717 char *old_file, *old_url;
721 /* With some forms of retrieval, it is possible, although not likely
722 or particularly desirable. If both are downloaded, the second
723 download will override the first one. When that happens,
724 dissociate the old file name from the URL. */
726 if (hash_table_get_pair (dl_file_url_map, file, &old_file, &old_url))
728 if (0 == strcmp (url, old_url))
729 /* We have somehow managed to download the same URL twice.
733 if (match_except_index (url, old_url)
734 && !hash_table_contains (dl_url_file_map, url))
735 /* The two URLs differ only in the "index.html" ending. For
736 example, one is "http://www.server.com/", and the other is
737 "http://www.server.com/index.html". Don't remove the old
738 one, just add the new one as a non-canonical entry. */
741 hash_table_remove (dl_file_url_map, file);
745 /* Remove all the URLs that point to this file. Yes, there can
746 be more than one such URL, because we store redirections as
747 multiple entries in dl_url_file_map. For example, if URL1
748 redirects to URL2 which gets downloaded to FILE, we map both
749 URL1 and URL2 to FILE in dl_url_file_map. (dl_file_url_map
750 only points to URL2.) When another URL gets loaded to FILE,
751 we want both URL1 and URL2 dissociated from it.
753 This is a relatively expensive operation because it performs
754 a linear search of the whole hash table, but it should be
755 called very rarely, only when two URLs resolve to the same
756 file name, *and* the "<file>.1" extensions are turned off.
757 In other words, almost never. */
758 dissociate_urls_from_file (file);
761 hash_table_put (dl_file_url_map, xstrdup (file), xstrdup (url));
764 /* A URL->FILE mapping is not possible without a FILE->URL mapping.
765 If the latter were present, it should have been removed by the
766 above `if'. So we could write:
768 assert (!hash_table_contains (dl_url_file_map, url));
770 The above is correct when running in recursive mode where the
771 same URL always resolves to the same file. But if you do
776 then the first URL will resolve to "FILE", and the other to
777 "FILE.1". In that case, FILE.1 will not be found in
778 dl_file_url_map, but URL will still point to FILE in
780 if (hash_table_get_pair (dl_url_file_map, url, &old_url, &old_file))
782 hash_table_remove (dl_url_file_map, url);
787 hash_table_put (dl_url_file_map, xstrdup (url), xstrdup (file));
790 /* Register that FROM has been redirected to TO. This assumes that TO
791 is successfully downloaded and already registered using
792 register_download() above. */
795 register_redirection (const char *from, const char *to)
801 file = hash_table_get (dl_url_file_map, to);
802 assert (file != NULL);
803 if (!hash_table_contains (dl_url_file_map, from))
804 hash_table_put (dl_url_file_map, xstrdup (from), xstrdup (file));
807 /* Register that the file has been deleted. */
810 register_delete_file (const char *file)
812 char *old_url, *old_file;
816 if (!hash_table_get_pair (dl_file_url_map, file, &old_file, &old_url))
819 hash_table_remove (dl_file_url_map, file);
822 dissociate_urls_from_file (file);
825 /* Register that FILE is an HTML file that has been downloaded. */
828 register_html (const char *url, const char *file)
830 if (!downloaded_html_set)
831 downloaded_html_set = make_string_hash_table (0);
832 string_set_add (downloaded_html_set, file);
835 static void downloaded_files_free (void);
837 /* Cleanup the data structures associated with this file. */
840 convert_cleanup (void)
844 free_keys_and_values (dl_file_url_map);
845 hash_table_destroy (dl_file_url_map);
846 dl_file_url_map = NULL;
850 free_keys_and_values (dl_url_file_map);
851 hash_table_destroy (dl_url_file_map);
852 dl_url_file_map = NULL;
854 if (downloaded_html_set)
855 string_set_free (downloaded_html_set);
856 downloaded_files_free ();
858 string_set_free (converted_files);
861 /* Book-keeping code for downloaded files that enables extension
864 /* This table should really be merged with dl_file_url_map and
865 downloaded_html_files. This was originally a list, but I changed
866 it to a hash table beause it was actually taking a lot of time to
867 find things in it. */
869 static struct hash_table *downloaded_files_hash;
871 /* We're storing "modes" of type downloaded_file_t in the hash table.
872 However, our hash tables only accept pointers for keys and values.
873 So when we need a pointer, we use the address of a
874 downloaded_file_t variable of static storage. */
876 static downloaded_file_t *
877 downloaded_mode_to_ptr (downloaded_file_t mode)
879 static downloaded_file_t
880 v1 = FILE_NOT_ALREADY_DOWNLOADED,
881 v2 = FILE_DOWNLOADED_NORMALLY,
882 v3 = FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED,
887 case FILE_NOT_ALREADY_DOWNLOADED:
889 case FILE_DOWNLOADED_NORMALLY:
891 case FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED:
899 /* Remembers which files have been downloaded. In the standard case,
900 should be called with mode == FILE_DOWNLOADED_NORMALLY for each
901 file we actually download successfully (i.e. not for ones we have
902 failures on or that we skip due to -N).
904 When we've downloaded a file and tacked on a ".html" extension due
905 to -E, call this function with
906 FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED rather than
907 FILE_DOWNLOADED_NORMALLY.
909 If you just want to check if a file has been previously added
910 without adding it, call with mode == CHECK_FOR_FILE. Please be
911 sure to call this function with local filenames, not remote
915 downloaded_file (downloaded_file_t mode, const char *file)
917 downloaded_file_t *ptr;
919 if (mode == CHECK_FOR_FILE)
921 if (!downloaded_files_hash)
922 return FILE_NOT_ALREADY_DOWNLOADED;
923 ptr = hash_table_get (downloaded_files_hash, file);
925 return FILE_NOT_ALREADY_DOWNLOADED;
929 if (!downloaded_files_hash)
930 downloaded_files_hash = make_string_hash_table (0);
932 ptr = hash_table_get (downloaded_files_hash, file);
936 ptr = downloaded_mode_to_ptr (mode);
937 hash_table_put (downloaded_files_hash, xstrdup (file), ptr);
939 return FILE_NOT_ALREADY_DOWNLOADED;
943 downloaded_files_free (void)
945 if (downloaded_files_hash)
947 hash_table_iterator iter;
948 for (hash_table_iterate (downloaded_files_hash, &iter);
949 hash_table_iter_next (&iter);
952 hash_table_destroy (downloaded_files_hash);
953 downloaded_files_hash = NULL;
957 /* The function returns the pointer to the malloc-ed quoted version of
958 string s. It will recognize and quote numeric and special graphic
959 entities, as per RFC1866:
967 No other entities are recognized or replaced. */
969 html_quote_string (const char *s)
975 /* Pass through the string, and count the new size. */
976 for (i = 0; *s; s++, i++)
980 else if (*s == '<' || *s == '>')
981 i += 3; /* `lt;' and `gt;' */
983 i += 5; /* `quot;' */
987 res = xmalloc (i + 1);
989 for (p = res; *s; s++)
1002 *p++ = (*s == '<' ? 'l' : 'g');