1 /* Conversion of links to local files.
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
3 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 */
52 static struct hash_table *dl_file_url_map;
53 struct hash_table *dl_url_file_map;
55 /* Set of HTML/CSS files downloaded in this Wget run, used for link
56 conversion after Wget is done. */
57 struct hash_table *downloaded_html_set;
58 struct hash_table *downloaded_css_set;
60 static void convert_links (const char *, struct urlpos *);
64 convert_links_in_hashtable (struct hash_table *downloaded_set,
75 cnt = hash_table_count (downloaded_set);
78 file_array = alloca_array (char *, cnt);
79 string_set_to_array (downloaded_set, file_array);
81 for (i = 0; i < cnt; i++)
83 struct urlpos *urls, *cur_url;
85 char *file = file_array[i];
87 /* Determine the URL of the file. get_urls_{html,css} will need
89 url = hash_table_get (dl_file_url_map, file);
92 DEBUGP (("Apparently %s has been removed.\n", file));
96 DEBUGP (("Scanning %s (from %s)\n", file, url));
98 /* Parse the file... */
99 urls = is_css ? get_urls_css_file (file, url) :
100 get_urls_html (file, url, NULL, NULL);
102 /* We don't respect meta_disallow_follow here because, even if
103 the file is not followed, we might still want to convert the
104 links that have been followed from other files. */
106 for (cur_url = urls; cur_url; cur_url = cur_url->next)
112 if (cur_url->link_base_p)
114 /* Base references have been resolved by our parser, so
115 we turn the base URL into an empty string. (Perhaps
116 we should remove the tag entirely?) */
117 cur_url->convert = CO_NULLIFY_BASE;
121 /* We decide the direction of conversion according to whether
122 a URL was downloaded. Downloaded URLs will be converted
123 ABS2REL, whereas non-downloaded will be converted REL2ABS. */
126 set_uri_encoding (pi, opt.locale, true);
128 u = url_parse (cur_url->url->url, NULL, pi, true);
129 local_name = hash_table_get (dl_url_file_map, u->url);
131 /* Decide on the conversion type. */
134 /* We've downloaded this URL. Convert it to relative
135 form. We do this even if the URL already is in
136 relative form, because our directory structure may
137 not be identical to that on the server (think `-nd',
138 `--cut-dirs', etc.) */
139 cur_url->convert = CO_CONVERT_TO_RELATIVE;
140 cur_url->local_name = xstrdup (local_name);
141 DEBUGP (("will convert url %s to local %s\n", u->url, local_name));
145 /* We haven't downloaded this URL. If it's not already
146 complete (including a full host name), convert it to
147 that form, so it can be reached while browsing this
149 if (!cur_url->link_complete_p)
150 cur_url->convert = CO_CONVERT_TO_COMPLETE;
151 cur_url->local_name = NULL;
152 DEBUGP (("will convert url %s to complete\n", u->url));
159 /* Convert the links in the file. */
160 convert_links (file, urls);
168 /* This function is called when the retrieval is done to convert the
169 links that have been downloaded. It has to be called at the end of
170 the retrieval, because only then does Wget know conclusively which
171 URLs have been downloaded, and which not, so it can tell which
172 direction to convert to.
174 The "direction" means that the URLs to the files that have been
175 downloaded get converted to the relative URL which will point to
176 that file. And the other URLs get converted to the remote URL on
179 All the downloaded HTMLs are kept in downloaded_html_files, and
180 downloaded URLs in urls_downloaded. All the information is
181 extracted from these two lists. */
184 convert_all_links (void)
189 struct ptimer *timer = ptimer_new ();
191 convert_links_in_hashtable (downloaded_html_set, 0, &file_count);
192 convert_links_in_hashtable (downloaded_css_set, 1, &file_count);
194 secs = ptimer_measure (timer);
195 logprintf (LOG_VERBOSE, _("Converted %d files in %s seconds.\n"),
196 file_count, print_decimal (secs));
198 ptimer_destroy (timer);
201 static void write_backup_file (const char *, downloaded_file_t);
202 static const char *replace_plain (const char*, int, FILE*, const char *);
203 static const char *replace_attr (const char *, int, FILE *, const char *);
204 static const char *replace_attr_refresh_hack (const char *, int, FILE *,
206 static char *local_quote_string (const char *, bool);
207 static char *construct_relative (const char *, const char *);
209 /* Change the links in one file. LINKS is a list of links in the
210 document, along with their positions and the desired direction of
213 convert_links (const char *file, struct urlpos *links)
215 struct file_memory *fm;
218 downloaded_file_t downloaded_file_return;
221 int to_url_count = 0, to_file_count = 0;
223 logprintf (LOG_VERBOSE, _("Converting %s... "), file);
226 /* First we do a "dry run": go through the list L and see whether
227 any URL needs to be converted in the first place. If not, just
228 leave the file alone. */
231 for (dry = links; dry; dry = dry->next)
232 if (dry->convert != CO_NOCONVERT)
236 logputs (LOG_VERBOSE, _("nothing to do.\n"));
241 fm = wget_read_file (file);
244 logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
245 file, strerror (errno));
249 downloaded_file_return = downloaded_file (CHECK_FOR_FILE, file);
250 if (opt.backup_converted && downloaded_file_return)
251 write_backup_file (file, downloaded_file_return);
253 /* Before opening the file for writing, unlink the file. This is
254 important if the data in FM is mmaped. In such case, nulling the
255 file, which is what fopen() below does, would make us read all
256 zeroes from the mmaped region. */
257 if (unlink (file) < 0 && errno != ENOENT)
259 logprintf (LOG_NOTQUIET, _("Unable to delete %s: %s\n"),
260 quote (file), strerror (errno));
261 wget_read_file_free (fm);
264 /* Now open the file for writing. */
265 fp = fopen (file, "wb");
268 logprintf (LOG_NOTQUIET, _("Cannot convert links in %s: %s\n"),
269 file, strerror (errno));
270 wget_read_file_free (fm);
274 /* Here we loop through all the URLs in file, replacing those of
275 them that are downloaded with relative references. */
277 for (link = links; link; link = link->next)
279 char *url_start = fm->content + link->pos;
281 if (link->pos >= fm->length)
283 DEBUGP (("Something strange is going on. Please investigate."));
286 /* If the URL is not to be converted, skip it. */
287 if (link->convert == CO_NOCONVERT)
289 DEBUGP (("Skipping %s at position %d.\n", link->url->url, link->pos));
293 /* Echo the file contents, up to the offending URL's opening
294 quote, to the outfile. */
295 fwrite (p, 1, url_start - p, fp);
298 switch (link->convert)
300 case CO_CONVERT_TO_RELATIVE:
301 /* Convert absolute URL to relative. */
303 char *newname = construct_relative (file, link->local_name);
304 char *quoted_newname = local_quote_string (newname,
307 if (link->link_css_p)
308 p = replace_plain (p, link->size, fp, quoted_newname);
309 else if (!link->link_refresh_p)
310 p = replace_attr (p, link->size, fp, quoted_newname);
312 p = replace_attr_refresh_hack (p, link->size, fp, quoted_newname,
313 link->refresh_timeout);
315 DEBUGP (("TO_RELATIVE: %s to %s at position %d in %s.\n",
316 link->url->url, newname, link->pos, file));
318 xfree (quoted_newname);
322 case CO_CONVERT_TO_COMPLETE:
323 /* Convert the link to absolute URL. */
325 char *newlink = link->url->url;
326 char *quoted_newlink = html_quote_string (newlink);
328 if (link->link_css_p)
329 p = replace_plain (p, link->size, fp, newlink);
330 else if (!link->link_refresh_p)
331 p = replace_attr (p, link->size, fp, quoted_newlink);
333 p = replace_attr_refresh_hack (p, link->size, fp, quoted_newlink,
334 link->refresh_timeout);
336 DEBUGP (("TO_COMPLETE: <something> to %s at position %d in %s.\n",
337 newlink, link->pos, file));
338 xfree (quoted_newlink);
342 case CO_NULLIFY_BASE:
343 /* Change the base href to "". */
344 p = replace_attr (p, link->size, fp, "");
352 /* Output the rest of the file. */
353 if (p - fm->content < fm->length)
354 fwrite (p, 1, fm->length - (p - fm->content), fp);
356 wget_read_file_free (fm);
358 logprintf (LOG_VERBOSE, "%d-%d\n", to_file_count, to_url_count);
361 /* Construct and return a link that points from BASEFILE to LINKFILE.
362 Both files should be local file names, BASEFILE of the referrering
363 file, and LINKFILE of the referred file.
367 cr("foo", "bar") -> "bar"
368 cr("A/foo", "A/bar") -> "bar"
369 cr("A/foo", "A/B/bar") -> "B/bar"
370 cr("A/X/foo", "A/Y/bar") -> "../Y/bar"
371 cr("X/", "Y/bar") -> "../Y/bar" (trailing slash does matter in BASE)
373 Both files should be absolute or relative, otherwise strange
374 results might ensue. The function makes no special efforts to
375 handle "." and ".." in links, so make sure they're not there
376 (e.g. using path_simplify). */
379 construct_relative (const char *basefile, const char *linkfile)
386 /* First, skip the initial directory components common to both
389 for (b = basefile, l = linkfile; *b == *l && *b != '\0'; ++b, ++l)
392 start = (b - basefile) + 1;
397 /* With common directories out of the way, the situation we have is
399 b - b1/b2/[...]/bfile
400 l - l1/l2/[...]/lfile
402 The link we're constructing needs to be:
403 lnk - ../../l1/l2/[...]/lfile
405 Where the number of ".."'s equals the number of bN directory
408 /* Count the directory components in B. */
410 for (b = basefile; *b; b++)
416 /* Construct LINK as explained above. */
417 link = xmalloc (3 * basedirs + strlen (linkfile) + 1);
418 for (i = 0; i < basedirs; i++)
419 memcpy (link + 3 * i, "../", 3);
420 strcpy (link + 3 * i, linkfile);
424 /* Used by write_backup_file to remember which files have been
426 static struct hash_table *converted_files;
429 write_backup_file (const char *file, downloaded_file_t downloaded_file_return)
431 /* Rather than just writing over the original .html file with the
432 converted version, save the former to *.orig. Note we only do
433 this for files we've _successfully_ downloaded, so we don't
434 clobber .orig files sitting around from previous invocations.
435 On VMS, use "_orig" instead of ".orig". See "wget.h". */
437 /* Construct the backup filename as the original name plus ".orig". */
438 size_t filename_len = strlen (file);
439 char* filename_plus_orig_suffix;
441 /* TODO: hack this to work with css files */
442 if (downloaded_file_return == FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED)
444 /* Just write "orig" over "html". We need to do it this way
445 because when we're checking to see if we've downloaded the
446 file before (to see if we can skip downloading it), we don't
447 know if it's a text/html file. Therefore we don't know yet
448 at that stage that -E is going to cause us to tack on
449 ".html", so we need to compare vs. the original URL plus
450 ".orig", not the original URL plus ".html.orig". */
451 filename_plus_orig_suffix = alloca (filename_len + 1);
452 strcpy (filename_plus_orig_suffix, file);
453 strcpy ((filename_plus_orig_suffix + filename_len) - 4, "orig");
455 else /* downloaded_file_return == FILE_DOWNLOADED_NORMALLY */
457 /* Append ".orig" to the name. */
458 filename_plus_orig_suffix = alloca (filename_len + sizeof (ORIG_SFX));
459 strcpy (filename_plus_orig_suffix, file);
460 strcpy (filename_plus_orig_suffix + filename_len, ORIG_SFX);
463 if (!converted_files)
464 converted_files = make_string_hash_table (0);
466 /* We can get called twice on the same URL thanks to the
467 convert_all_links() call in main(). If we write the .orig file
468 each time in such a case, it'll end up containing the first-pass
469 conversion, not the original file. So, see if we've already been
470 called on this file. */
471 if (!string_set_contains (converted_files, file))
473 /* Rename <file> to <file>.orig before former gets written over. */
474 if (rename (file, filename_plus_orig_suffix) != 0)
475 logprintf (LOG_NOTQUIET, _("Cannot back up %s as %s: %s\n"),
476 file, filename_plus_orig_suffix, strerror (errno));
478 /* Remember that we've already written a .orig backup for this file.
479 Note that we never free this memory since we need it till the
480 convert_all_links() call, which is one of the last things the
481 program does before terminating. BTW, I'm not sure if it would be
482 safe to just set 'converted_file_ptr->string' to 'file' below,
483 rather than making a copy of the string... Another note is that I
484 thought I could just add a field to the urlpos structure saying
485 that we'd written a .orig file for this URL, but that didn't work,
486 so I had to make this separate list.
487 -- Dan Harkless <wget@harkless.org>
489 This [adding a field to the urlpos structure] didn't work
490 because convert_file() is called from convert_all_links at
491 the end of the retrieval with a freshly built new urlpos
493 -- Hrvoje Niksic <hniksic@xemacs.org>
495 string_set_add (converted_files, file);
499 static bool find_fragment (const char *, int, const char **, const char **);
501 /* Replace a string with NEW_TEXT. Ignore quoting. */
503 replace_plain (const char *p, int size, FILE *fp, const char *new_text)
505 fputs (new_text, fp);
510 /* Replace an attribute's original text with NEW_TEXT. */
513 replace_attr (const char *p, int size, FILE *fp, const char *new_text)
515 bool quote_flag = false;
516 char quote_char = '\"'; /* use "..." for quoting, unless the
517 original value is quoted, in which
518 case reuse its quoting char. */
519 const char *frag_beg, *frag_end;
521 /* Structure of our string is:
523 <--- size ---> (with quotes)
526 <--- size --> (no quotes) */
528 if (*p == '\"' || *p == '\'')
533 size -= 2; /* disregard opening and closing quote */
535 putc (quote_char, fp);
536 fputs (new_text, fp);
538 /* Look for fragment identifier, if any. */
539 if (find_fragment (p, size, &frag_beg, &frag_end))
540 fwrite (frag_beg, 1, frag_end - frag_beg, fp);
544 putc (quote_char, fp);
549 /* The same as REPLACE_ATTR, but used when replacing
550 <meta http-equiv=refresh content="new_text"> because we need to
551 append "timeout_value; URL=" before the next_text. */
554 replace_attr_refresh_hack (const char *p, int size, FILE *fp,
555 const char *new_text, int timeout)
558 char *new_with_timeout = (char *)alloca (numdigit (timeout)
562 sprintf (new_with_timeout, "%d; URL=%s", timeout, new_text);
564 return replace_attr (p, size, fp, new_with_timeout);
567 /* Find the first occurrence of '#' in [BEG, BEG+SIZE) that is not
568 preceded by '&'. If the character is not found, return zero. If
569 the character is found, return true and set BP and EP to point to
570 the beginning and end of the region.
572 This is used for finding the fragment indentifiers in URLs. */
575 find_fragment (const char *beg, int size, const char **bp, const char **ep)
577 const char *end = beg + size;
578 bool saw_amp = false;
579 for (; beg < end; beg++)
601 /* Quote FILE for use as local reference to an HTML file.
603 We quote ? as %3F to avoid passing part of the file name as the
604 parameter when browsing the converted file through HTTP. However,
605 it is safe to do this only when `--adjust-extension' is turned on.
606 This is because converting "index.html?foo=bar" to
607 "index.html%3Ffoo=bar" would break local browsing, as the latter
608 isn't even recognized as an HTML file! However, converting
609 "index.html?foo=bar.html" to "index.html%3Ffoo=bar.html" should be
610 safe for both local and HTTP-served browsing.
612 We always quote "#" as "%23", "%" as "%25" and ";" as "%3B"
613 because those characters have special meanings in URLs. */
616 local_quote_string (const char *file, bool no_html_quote)
621 char *any = strpbrk (file, "?#%;");
623 return no_html_quote ? strdup (file) : html_quote_string (file);
625 /* Allocate space assuming the worst-case scenario, each character
626 having to be quoted. */
627 to = newname = (char *)alloca (3 * strlen (file) + 1);
628 for (from = file; *from; from++)
647 if (opt.adjust_extension)
660 return no_html_quote ? strdup (newname) : html_quote_string (newname);
663 /* Book-keeping code for dl_file_url_map, dl_url_file_map,
664 downloaded_html_list, and downloaded_html_set. Other code calls
665 these functions to let us know that a file has been downloaded. */
667 #define ENSURE_TABLES_EXIST do { \
668 if (!dl_file_url_map) \
669 dl_file_url_map = make_string_hash_table (0); \
670 if (!dl_url_file_map) \
671 dl_url_file_map = make_string_hash_table (0); \
674 /* Return true if S1 and S2 are the same, except for "/index.html".
675 The three cases in which it returns one are (substitute any
676 substring for "foo"):
678 m("foo/index.html", "foo/") ==> 1
679 m("foo/", "foo/index.html") ==> 1
680 m("foo", "foo/index.html") ==> 1
681 m("foo", "foo/" ==> 1
682 m("foo", "foo") ==> 1 */
685 match_except_index (const char *s1, const char *s2)
690 /* Skip common substring. */
691 for (i = 0; *s1 && *s2 && *s1 == *s2; s1++, s2++, i++)
694 /* Strings differ at the very beginning -- bail out. We need to
695 check this explicitly to avoid `lng - 1' reading outside the
700 /* Both strings hit EOF -- strings are equal. */
703 /* Strings are randomly different, e.g. "/foo/bar" and "/foo/qux". */
706 /* S1 is the longer one. */
709 /* S2 is the longer one. */
713 /* foo/index.html */ /* or */ /* foo/index.html */
717 /* The right-hand case. */
720 if (*lng == '/' && *(lng + 1) == '\0')
725 return 0 == strcmp (lng, "/index.html");
729 dissociate_urls_from_file_mapper (void *key, void *value, void *arg)
731 char *mapping_url = (char *)key;
732 char *mapping_file = (char *)value;
733 char *file = (char *)arg;
735 if (0 == strcmp (mapping_file, file))
737 hash_table_remove (dl_url_file_map, mapping_url);
739 xfree (mapping_file);
742 /* Continue mapping. */
746 /* Remove all associations from various URLs to FILE from dl_url_file_map. */
749 dissociate_urls_from_file (const char *file)
751 /* Can't use hash_table_iter_* because the table mutates while mapping. */
752 hash_table_for_each (dl_url_file_map, dissociate_urls_from_file_mapper,
756 /* Register that URL has been successfully downloaded to FILE. This
757 is used by the link conversion code to convert references to URLs
758 to references to local files. It is also being used to check if a
759 URL has already been downloaded. */
762 register_download (const char *url, const char *file)
764 char *old_file, *old_url;
768 /* With some forms of retrieval, it is possible, although not likely
769 or particularly desirable. If both are downloaded, the second
770 download will override the first one. When that happens,
771 dissociate the old file name from the URL. */
773 if (hash_table_get_pair (dl_file_url_map, file, &old_file, &old_url))
775 if (0 == strcmp (url, old_url))
776 /* We have somehow managed to download the same URL twice.
780 if (match_except_index (url, old_url)
781 && !hash_table_contains (dl_url_file_map, url))
782 /* The two URLs differ only in the "index.html" ending. For
783 example, one is "http://www.server.com/", and the other is
784 "http://www.server.com/index.html". Don't remove the old
785 one, just add the new one as a non-canonical entry. */
788 hash_table_remove (dl_file_url_map, file);
792 /* Remove all the URLs that point to this file. Yes, there can
793 be more than one such URL, because we store redirections as
794 multiple entries in dl_url_file_map. For example, if URL1
795 redirects to URL2 which gets downloaded to FILE, we map both
796 URL1 and URL2 to FILE in dl_url_file_map. (dl_file_url_map
797 only points to URL2.) When another URL gets loaded to FILE,
798 we want both URL1 and URL2 dissociated from it.
800 This is a relatively expensive operation because it performs
801 a linear search of the whole hash table, but it should be
802 called very rarely, only when two URLs resolve to the same
803 file name, *and* the "<file>.1" extensions are turned off.
804 In other words, almost never. */
805 dissociate_urls_from_file (file);
808 hash_table_put (dl_file_url_map, xstrdup (file), xstrdup (url));
811 /* A URL->FILE mapping is not possible without a FILE->URL mapping.
812 If the latter were present, it should have been removed by the
813 above `if'. So we could write:
815 assert (!hash_table_contains (dl_url_file_map, url));
817 The above is correct when running in recursive mode where the
818 same URL always resolves to the same file. But if you do
823 then the first URL will resolve to "FILE", and the other to
824 "FILE.1". In that case, FILE.1 will not be found in
825 dl_file_url_map, but URL will still point to FILE in
827 if (hash_table_get_pair (dl_url_file_map, url, &old_url, &old_file))
829 hash_table_remove (dl_url_file_map, url);
834 hash_table_put (dl_url_file_map, xstrdup (url), xstrdup (file));
837 /* Register that FROM has been redirected to TO. This assumes that TO
838 is successfully downloaded and already registered using
839 register_download() above. */
842 register_redirection (const char *from, const char *to)
848 file = hash_table_get (dl_url_file_map, to);
849 assert (file != NULL);
850 if (!hash_table_contains (dl_url_file_map, from))
851 hash_table_put (dl_url_file_map, xstrdup (from), xstrdup (file));
854 /* Register that the file has been deleted. */
857 register_delete_file (const char *file)
859 char *old_url, *old_file;
863 if (!hash_table_get_pair (dl_file_url_map, file, &old_file, &old_url))
866 hash_table_remove (dl_file_url_map, file);
869 dissociate_urls_from_file (file);
872 /* Register that FILE is an HTML file that has been downloaded. */
875 register_html (const char *url, const char *file)
877 if (!downloaded_html_set)
878 downloaded_html_set = make_string_hash_table (0);
879 string_set_add (downloaded_html_set, file);
882 /* Register that FILE is a CSS file that has been downloaded. */
885 register_css (const char *url, const char *file)
887 if (!downloaded_css_set)
888 downloaded_css_set = make_string_hash_table (0);
889 string_set_add (downloaded_css_set, file);
892 static void downloaded_files_free (void);
894 /* Cleanup the data structures associated with this file. */
897 convert_cleanup (void)
901 free_keys_and_values (dl_file_url_map);
902 hash_table_destroy (dl_file_url_map);
903 dl_file_url_map = NULL;
907 free_keys_and_values (dl_url_file_map);
908 hash_table_destroy (dl_url_file_map);
909 dl_url_file_map = NULL;
911 if (downloaded_html_set)
912 string_set_free (downloaded_html_set);
913 downloaded_files_free ();
915 string_set_free (converted_files);
918 /* Book-keeping code for downloaded files that enables extension
921 /* This table should really be merged with dl_file_url_map and
922 downloaded_html_files. This was originally a list, but I changed
923 it to a hash table beause it was actually taking a lot of time to
924 find things in it. */
926 static struct hash_table *downloaded_files_hash;
928 /* We're storing "modes" of type downloaded_file_t in the hash table.
929 However, our hash tables only accept pointers for keys and values.
930 So when we need a pointer, we use the address of a
931 downloaded_file_t variable of static storage. */
933 static downloaded_file_t *
934 downloaded_mode_to_ptr (downloaded_file_t mode)
936 static downloaded_file_t
937 v1 = FILE_NOT_ALREADY_DOWNLOADED,
938 v2 = FILE_DOWNLOADED_NORMALLY,
939 v3 = FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED,
944 case FILE_NOT_ALREADY_DOWNLOADED:
946 case FILE_DOWNLOADED_NORMALLY:
948 case FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED:
956 /* Remembers which files have been downloaded. In the standard case,
957 should be called with mode == FILE_DOWNLOADED_NORMALLY for each
958 file we actually download successfully (i.e. not for ones we have
959 failures on or that we skip due to -N).
961 When we've downloaded a file and tacked on a ".html" extension due
962 to -E, call this function with
963 FILE_DOWNLOADED_AND_HTML_EXTENSION_ADDED rather than
964 FILE_DOWNLOADED_NORMALLY.
966 If you just want to check if a file has been previously added
967 without adding it, call with mode == CHECK_FOR_FILE. Please be
968 sure to call this function with local filenames, not remote
972 downloaded_file (downloaded_file_t mode, const char *file)
974 downloaded_file_t *ptr;
976 if (mode == CHECK_FOR_FILE)
978 if (!downloaded_files_hash)
979 return FILE_NOT_ALREADY_DOWNLOADED;
980 ptr = hash_table_get (downloaded_files_hash, file);
982 return FILE_NOT_ALREADY_DOWNLOADED;
986 if (!downloaded_files_hash)
987 downloaded_files_hash = make_string_hash_table (0);
989 ptr = hash_table_get (downloaded_files_hash, file);
993 ptr = downloaded_mode_to_ptr (mode);
994 hash_table_put (downloaded_files_hash, xstrdup (file), ptr);
996 return FILE_NOT_ALREADY_DOWNLOADED;
1000 downloaded_files_free (void)
1002 if (downloaded_files_hash)
1004 hash_table_iterator iter;
1005 for (hash_table_iterate (downloaded_files_hash, &iter);
1006 hash_table_iter_next (&iter);
1009 hash_table_destroy (downloaded_files_hash);
1010 downloaded_files_hash = NULL;
1014 /* The function returns the pointer to the malloc-ed quoted version of
1015 string s. It will recognize and quote numeric and special graphic
1016 entities, as per RFC1866:
1024 No other entities are recognized or replaced. */
1026 html_quote_string (const char *s)
1032 /* Pass through the string, and count the new size. */
1033 for (i = 0; *s; s++, i++)
1036 i += 4; /* `amp;' */
1037 else if (*s == '<' || *s == '>')
1038 i += 3; /* `lt;' and `gt;' */
1039 else if (*s == '\"')
1040 i += 5; /* `quot;' */
1044 res = xmalloc (i + 1);
1046 for (p = res; *s; s++)
1059 *p++ = (*s == '<' ? 'l' : 'g');