1 /* Various functions of utilitarian nature.
2 Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
3 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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 In addition, as a special exception, the Free Software Foundation
22 gives permission to link the code of its release of Wget with the
23 OpenSSL project's "OpenSSL" library (or with modified versions of it
24 that use the same license as the "OpenSSL" library), and distribute
25 the linked executables. You must obey the GNU General Public License
26 in all respects for all of the code used other than "OpenSSL". If you
27 modify this file, you may extend this exception to your version of the
28 file, but you are not obligated to do so. If you do not wish to do
29 so, delete this exception statement from your version. */
37 #else /* not HAVE_STRING_H */
39 #endif /* not HAVE_STRING_H */
40 #include <sys/types.h>
45 # include <sys/mman.h>
54 #ifdef HAVE_SYS_UTIME_H
55 # include <sys/utime.h>
59 # include <libc.h> /* for access() */
64 /* For TIOCGWINSZ and friends: */
65 #ifdef HAVE_SYS_IOCTL_H
66 # include <sys/ioctl.h>
72 /* Needed for run_with_timeout. */
73 #undef USE_SIGNAL_TIMEOUT
80 /* If sigsetjmp is a macro, configure won't pick it up. */
82 # define HAVE_SIGSETJMP
85 # ifdef HAVE_SIGSETJMP
86 # define USE_SIGNAL_TIMEOUT
89 # define USE_SIGNAL_TIMEOUT
102 /* This section implements several wrappers around the basic
103 allocation routines. This is done for two reasons: first, so that
104 the callers of these functions need not consistently check for
105 errors. If there is not enough virtual memory for running Wget,
106 something is seriously wrong, and Wget exits with an appropriate
109 The second reason why these are useful is that, if DEBUG_MALLOC is
110 defined, they also provide a handy (if crude) malloc debugging
111 interface that checks memory leaks. */
113 /* Croak the fatal memory error and bail out with non-zero exit
116 memfatal (const char *what)
118 /* Make sure we don't try to store part of the log line, and thus
120 log_set_save_context (0);
121 logprintf (LOG_ALWAYS, _("%s: %s: Not enough memory.\n"), exec_name, what);
125 /* These functions end with _real because they need to be
126 distinguished from the debugging functions, and from the macros.
129 If memory debugging is not turned on, wget.h defines these:
131 #define xmalloc xmalloc_real
132 #define xrealloc xrealloc_real
133 #define xstrdup xstrdup_real
136 In case of memory debugging, the definitions are a bit more
137 complex, because we want to provide more information, *and* we want
138 to call the debugging code. (The former is the reason why xmalloc
139 and friends need to be macros in the first place.) Then it looks
142 #define xmalloc(a) xmalloc_debug (a, __FILE__, __LINE__)
143 #define xfree(a) xfree_debug (a, __FILE__, __LINE__)
144 #define xrealloc(a, b) xrealloc_debug (a, b, __FILE__, __LINE__)
145 #define xstrdup(a) xstrdup_debug (a, __FILE__, __LINE__)
147 Each of the *_debug function does its magic and calls the real one. */
150 # define STATIC_IF_DEBUG static
152 # define STATIC_IF_DEBUG
155 STATIC_IF_DEBUG void *
156 xmalloc_real (size_t size)
158 void *ptr = malloc (size);
164 STATIC_IF_DEBUG void *
165 xrealloc_real (void *ptr, size_t newsize)
169 /* Not all Un*xes have the feature of realloc() that calling it with
170 a NULL-pointer is the same as malloc(), but it is easy to
173 newptr = realloc (ptr, newsize);
175 newptr = malloc (newsize);
177 memfatal ("realloc");
181 STATIC_IF_DEBUG char *
182 xstrdup_real (const char *s)
188 copy = malloc (l + 1);
191 memcpy (copy, s, l + 1);
192 #else /* HAVE_STRDUP */
196 #endif /* HAVE_STRDUP */
203 /* Crude home-grown routines for debugging some malloc-related
206 * Counting the number of malloc and free invocations, and reporting
207 the "balance", i.e. how many times more malloc was called than it
208 was the case with free.
210 * Making malloc store its entry into a simple array and free remove
211 stuff from that array. At the end, print the pointers which have
212 not been freed, along with the source file and the line number.
213 This also has the side-effect of detecting freeing memory that
216 Note that this kind of memory leak checking strongly depends on
217 every malloc() being followed by a free(), even if the program is
218 about to finish. Wget is careful to free the data structure it
219 allocated in init.c. */
221 static int malloc_count, free_count;
227 } malloc_debug[100000];
229 /* Both register_ptr and unregister_ptr take O(n) operations to run,
230 which can be a real problem. It would be nice to use a hash table
231 for malloc_debug, but the functions in hash.c are not suitable
232 because they can call malloc() themselves. Maybe it would work if
233 the hash table were preallocated to a huge size, and if we set the
234 rehash threshold to 1.0. */
236 /* Register PTR in malloc_debug. Abort if this is not possible
237 (presumably due to the number of current allocations exceeding the
238 size of malloc_debug.) */
241 register_ptr (void *ptr, const char *file, int line)
244 for (i = 0; i < countof (malloc_debug); i++)
245 if (malloc_debug[i].ptr == NULL)
247 malloc_debug[i].ptr = ptr;
248 malloc_debug[i].file = file;
249 malloc_debug[i].line = line;
255 /* Unregister PTR from malloc_debug. Abort if PTR is not present in
256 malloc_debug. (This catches calling free() with a bogus pointer.) */
259 unregister_ptr (void *ptr)
262 for (i = 0; i < countof (malloc_debug); i++)
263 if (malloc_debug[i].ptr == ptr)
265 malloc_debug[i].ptr = NULL;
271 /* Print the malloc debug stats that can be gathered from the above
272 information. Currently this is the count of mallocs, frees, the
273 difference between the two, and the dump of the contents of
274 malloc_debug. The last part are the memory leaks. */
277 print_malloc_debug_stats (void)
280 printf ("\nMalloc: %d\nFree: %d\nBalance: %d\n\n",
281 malloc_count, free_count, malloc_count - free_count);
282 for (i = 0; i < countof (malloc_debug); i++)
283 if (malloc_debug[i].ptr != NULL)
284 printf ("0x%08ld: %s:%d\n", (long)malloc_debug[i].ptr,
285 malloc_debug[i].file, malloc_debug[i].line);
289 xmalloc_debug (size_t size, const char *source_file, int source_line)
291 void *ptr = xmalloc_real (size);
293 register_ptr (ptr, source_file, source_line);
298 xfree_debug (void *ptr, const char *source_file, int source_line)
300 assert (ptr != NULL);
302 unregister_ptr (ptr);
307 xrealloc_debug (void *ptr, size_t newsize, const char *source_file, int source_line)
309 void *newptr = xrealloc_real (ptr, newsize);
313 register_ptr (newptr, source_file, source_line);
315 else if (newptr != ptr)
317 unregister_ptr (ptr);
318 register_ptr (newptr, source_file, source_line);
324 xstrdup_debug (const char *s, const char *source_file, int source_line)
326 char *copy = xstrdup_real (s);
328 register_ptr (copy, source_file, source_line);
332 #endif /* DEBUG_MALLOC */
334 /* Utility function: like xstrdup(), but also lowercases S. */
337 xstrdup_lower (const char *s)
339 char *copy = xstrdup (s);
346 /* Return a count of how many times CHR occurs in STRING. */
349 count_char (const char *string, char chr)
353 for (p = string; *p; p++)
359 /* Copy the string formed by two pointers (one on the beginning, other
360 on the char after the last char) to a new, malloc-ed location.
363 strdupdelim (const char *beg, const char *end)
365 char *res = (char *)xmalloc (end - beg + 1);
366 memcpy (res, beg, end - beg);
367 res[end - beg] = '\0';
371 /* Parse a string containing comma-separated elements, and return a
372 vector of char pointers with the elements. Spaces following the
373 commas are ignored. */
375 sepstring (const char *s)
389 res = (char **)xrealloc (res, (i + 2) * sizeof (char *));
390 res[i] = strdupdelim (p, s);
393 /* Skip the blanks following the ','. */
401 res = (char **)xrealloc (res, (i + 2) * sizeof (char *));
402 res[i] = strdupdelim (p, s);
407 /* Return pointer to a static char[] buffer in which zero-terminated
408 string-representation of TM (in form hh:mm:ss) is printed.
410 If TM is non-NULL, the current time-in-seconds will be stored
413 (#### This is misleading: one would expect TM would be used instead
414 of the current time in that case. This design was probably
415 influenced by the design time(2), and should be changed at some
416 points. No callers use non-NULL TM anyway.) */
419 time_str (time_t *tm)
421 static char output[15];
423 time_t secs = time (tm);
427 /* In case of error, return the empty string. Maybe we should
428 just abort if this happens? */
432 ptm = localtime (&secs);
433 sprintf (output, "%02d:%02d:%02d", ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
437 /* Like the above, but include the date: YYYY-MM-DD hh:mm:ss. */
440 datetime_str (time_t *tm)
442 static char output[20]; /* "YYYY-MM-DD hh:mm:ss" + \0 */
444 time_t secs = time (tm);
448 /* In case of error, return the empty string. Maybe we should
449 just abort if this happens? */
453 ptm = localtime (&secs);
454 sprintf (output, "%04d-%02d-%02d %02d:%02d:%02d",
455 ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday,
456 ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
460 /* The Windows versions of the following two functions are defined in
465 fork_to_background (void)
468 /* Whether we arrange our own version of opt.lfilename here. */
473 opt.lfilename = unique_name (DEFAULT_LOGFILE, 0);
485 /* parent, no error */
486 printf (_("Continuing in background, pid %d.\n"), (int)pid);
488 printf (_("Output will be written to `%s'.\n"), opt.lfilename);
489 exit (0); /* #### should we use _exit()? */
492 /* child: give up the privileges and keep running. */
494 freopen ("/dev/null", "r", stdin);
495 freopen ("/dev/null", "w", stdout);
496 freopen ("/dev/null", "w", stderr);
498 #endif /* not WINDOWS */
500 /* "Touch" FILE, i.e. make its atime and mtime equal to the time
501 specified with TM. */
503 touch (const char *file, time_t tm)
505 #ifdef HAVE_STRUCT_UTIMBUF
506 struct utimbuf times;
507 times.actime = times.modtime = tm;
510 times[0] = times[1] = tm;
513 if (utime (file, ×) == -1)
514 logprintf (LOG_NOTQUIET, "utime(%s): %s\n", file, strerror (errno));
517 /* Checks if FILE is a symbolic link, and removes it if it is. Does
518 nothing under MS-Windows. */
520 remove_link (const char *file)
525 if (lstat (file, &st) == 0 && S_ISLNK (st.st_mode))
527 DEBUGP (("Unlinking %s (symlink).\n", file));
530 logprintf (LOG_VERBOSE, _("Failed to unlink symlink `%s': %s\n"),
531 file, strerror (errno));
536 /* Does FILENAME exist? This is quite a lousy implementation, since
537 it supplies no error codes -- only a yes-or-no answer. Thus it
538 will return that a file does not exist if, e.g., the directory is
539 unreadable. I don't mind it too much currently, though. The
540 proper way should, of course, be to have a third, error state,
541 other than true/false, but that would introduce uncalled-for
542 additional complexity to the callers. */
544 file_exists_p (const char *filename)
547 return access (filename, F_OK) >= 0;
550 return stat (filename, &buf) >= 0;
554 /* Returns 0 if PATH is a directory, 1 otherwise (any kind of file).
555 Returns 0 on error. */
557 file_non_directory_p (const char *path)
560 /* Use lstat() rather than stat() so that symbolic links pointing to
561 directories can be identified correctly. */
562 if (lstat (path, &buf) != 0)
564 return S_ISDIR (buf.st_mode) ? 0 : 1;
567 /* Return the size of file named by FILENAME, or -1 if it cannot be
568 opened or seeked into. */
570 file_size (const char *filename)
573 /* We use fseek rather than stat to determine the file size because
574 that way we can also verify whether the file is readable.
575 Inspired by the POST patch by Arnaud Wylie. */
576 FILE *fp = fopen (filename, "rb");
579 fseek (fp, 0, SEEK_END);
585 /* stat file names named PREFIX.1, PREFIX.2, etc., until one that
586 doesn't exist is found. Return a freshly allocated copy of the
590 unique_name_1 (const char *prefix)
593 int plen = strlen (prefix);
594 char *template = (char *)alloca (plen + 1 + 24);
595 char *template_tail = template + plen;
597 memcpy (template, prefix, plen);
598 *template_tail++ = '.';
601 number_to_string (template_tail, count++);
602 while (file_exists_p (template));
604 return xstrdup (template);
607 /* Return a unique file name, based on FILE.
609 More precisely, if FILE doesn't exist, it is returned unmodified.
610 If not, FILE.1 is tried, then FILE.2, etc. The first FILE.<number>
611 file name that doesn't exist is returned.
613 The resulting file is not created, only verified that it didn't
614 exist at the point in time when the function was called.
615 Therefore, where security matters, don't rely that the file created
616 by this function exists until you open it with O_EXCL or
619 If ALLOW_PASSTHROUGH is 0, it always returns a freshly allocated
620 string. Otherwise, it may return FILE if the file doesn't exist
621 (and therefore doesn't need changing). */
624 unique_name (const char *file, int allow_passthrough)
626 /* If the FILE itself doesn't exist, return it without
628 if (!file_exists_p (file))
629 return allow_passthrough ? (char *)file : xstrdup (file);
631 /* Otherwise, find a numeric suffix that results in unused file name
633 return unique_name_1 (file);
636 /* Create DIRECTORY. If some of the pathname components of DIRECTORY
637 are missing, create them first. In case any mkdir() call fails,
638 return its error status. Returns 0 on successful completion.
640 The behaviour of this function should be identical to the behaviour
641 of `mkdir -p' on systems where mkdir supports the `-p' option. */
643 make_directory (const char *directory)
650 /* Make a copy of dir, to be able to write to it. Otherwise, the
651 function is unsafe if called with a read-only char *argument. */
652 STRDUP_ALLOCA (dir, directory);
654 /* If the first character of dir is '/', skip it (and thus enable
655 creation of absolute-pathname directories. */
656 for (i = (*dir == '/'); 1; ++i)
658 for (; dir[i] && dir[i] != '/'; i++)
663 /* Check whether the directory already exists. Allow creation of
664 of intermediate directories to fail, as the initial path components
665 are not necessarily directories! */
666 if (!file_exists_p (dir))
667 ret = mkdir (dir, 0777);
678 /* Merge BASE with FILE. BASE can be a directory or a file name, FILE
679 should be a file name.
681 file_merge("/foo/bar", "baz") => "/foo/baz"
682 file_merge("/foo/bar/", "baz") => "/foo/bar/baz"
683 file_merge("foo", "bar") => "bar"
685 In other words, it's a simpler and gentler version of uri_merge_1. */
688 file_merge (const char *base, const char *file)
691 const char *cut = (const char *)strrchr (base, '/');
694 return xstrdup (file);
696 result = (char *)xmalloc (cut - base + 1 + strlen (file) + 1);
697 memcpy (result, base, cut - base);
698 result[cut - base] = '/';
699 strcpy (result + (cut - base) + 1, file);
704 static int in_acclist PARAMS ((const char *const *, const char *, int));
706 /* Determine whether a file is acceptable to be followed, according to
707 lists of patterns to accept/reject. */
709 acceptable (const char *s)
713 while (l && s[l] != '/')
720 return (in_acclist ((const char *const *)opt.accepts, s, 1)
721 && !in_acclist ((const char *const *)opt.rejects, s, 1));
723 return in_acclist ((const char *const *)opt.accepts, s, 1);
725 else if (opt.rejects)
726 return !in_acclist ((const char *const *)opt.rejects, s, 1);
730 /* Compare S1 and S2 frontally; S2 must begin with S1. E.g. if S1 is
731 `/something', frontcmp() will return 1 only if S2 begins with
732 `/something'. Otherwise, 0 is returned. */
734 frontcmp (const char *s1, const char *s2)
736 for (; *s1 && *s2 && (*s1 == *s2); ++s1, ++s2);
740 /* Iterate through STRLIST, and return the first element that matches
741 S, through wildcards or front comparison (as appropriate). */
743 proclist (char **strlist, const char *s, enum accd flags)
747 for (x = strlist; *x; x++)
748 if (has_wildcards_p (*x))
750 if (fnmatch (*x, s, FNM_PATHNAME) == 0)
755 char *p = *x + ((flags & ALLABS) && (**x == '/')); /* Remove '/' */
762 /* Returns whether DIRECTORY is acceptable for download, wrt the
763 include/exclude lists.
765 If FLAGS is ALLABS, the leading `/' is ignored in paths; relative
766 and absolute paths may be freely intermixed. */
768 accdir (const char *directory, enum accd flags)
770 /* Remove starting '/'. */
771 if (flags & ALLABS && *directory == '/')
775 if (!proclist (opt.includes, directory, flags))
780 if (proclist (opt.excludes, directory, flags))
786 /* Return non-zero if STRING ends with TAIL. For instance:
788 match_tail ("abc", "bc", 0) -> 1
789 match_tail ("abc", "ab", 0) -> 0
790 match_tail ("abc", "abc", 0) -> 1
792 If FOLD_CASE_P is non-zero, the comparison will be
796 match_tail (const char *string, const char *tail, int fold_case_p)
800 /* We want this to be fast, so we code two loops, one with
801 case-folding, one without. */
805 for (i = strlen (string), j = strlen (tail); i >= 0 && j >= 0; i--, j--)
806 if (string[i] != tail[j])
811 for (i = strlen (string), j = strlen (tail); i >= 0 && j >= 0; i--, j--)
812 if (TOLOWER (string[i]) != TOLOWER (tail[j]))
816 /* If the tail was exhausted, the match was succesful. */
823 /* Checks whether string S matches each element of ACCEPTS. A list
824 element are matched either with fnmatch() or match_tail(),
825 according to whether the element contains wildcards or not.
827 If the BACKWARD is 0, don't do backward comparison -- just compare
830 in_acclist (const char *const *accepts, const char *s, int backward)
832 for (; *accepts; accepts++)
834 if (has_wildcards_p (*accepts))
836 /* fnmatch returns 0 if the pattern *does* match the
838 if (fnmatch (*accepts, s, 0) == 0)
845 if (match_tail (s, *accepts, 0))
850 if (!strcmp (s, *accepts))
858 /* Return the location of STR's suffix (file extension). Examples:
859 suffix ("foo.bar") -> "bar"
860 suffix ("foo.bar.baz") -> "baz"
861 suffix ("/foo/bar") -> NULL
862 suffix ("/foo.bar/baz") -> NULL */
864 suffix (const char *str)
868 for (i = strlen (str); i && str[i] != '/' && str[i] != '.'; i--)
872 return (char *)str + i;
877 /* Return non-zero if FNAME ends with a typical HTML suffix. The
878 following (case-insensitive) suffixes are presumed to be HTML files:
882 ?html (`?' matches one character)
884 #### CAVEAT. This is not necessarily a good indication that FNAME
885 refers to a file that contains HTML! */
887 has_html_suffix_p (const char *fname)
891 if ((suf = suffix (fname)) == NULL)
893 if (!strcasecmp (suf, "html"))
895 if (!strcasecmp (suf, "htm"))
897 if (suf[0] && !strcasecmp (suf + 1, "html"))
902 /* Read a line from FP and return the pointer to freshly allocated
903 storage. The storage space is obtained through malloc() and should
904 be freed with free() when it is no longer needed.
906 The length of the line is not limited, except by available memory.
907 The newline character at the end of line is retained. The line is
908 terminated with a zero character.
910 After end-of-file is encountered without anything being read, NULL
911 is returned. NULL is also returned on error. To distinguish
912 between these two cases, use the stdio function ferror(). */
915 read_whole_line (FILE *fp)
919 char *line = (char *)xmalloc (bufsize);
921 while (fgets (line + length, bufsize - length, fp))
923 length += strlen (line + length);
925 /* Possible for example when reading from a binary file where
926 a line begins with \0. */
929 if (line[length - 1] == '\n')
932 /* fgets() guarantees to read the whole line, or to use up the
933 space we've given it. We can double the buffer
936 line = xrealloc (line, bufsize);
938 if (length == 0 || ferror (fp))
943 if (length + 1 < bufsize)
944 /* Relieve the memory from our exponential greediness. We say
945 `length + 1' because the terminating \0 is not included in
946 LENGTH. We don't need to zero-terminate the string ourselves,
947 though, because fgets() does that. */
948 line = xrealloc (line, length + 1);
952 /* Read FILE into memory. A pointer to `struct file_memory' are
953 returned; use struct element `content' to access file contents, and
954 the element `length' to know the file length. `content' is *not*
955 zero-terminated, and you should *not* read or write beyond the [0,
956 length) range of characters.
958 After you are done with the file contents, call read_file_free to
961 Depending on the operating system and the type of file that is
962 being read, read_file() either mmap's the file into memory, or
963 reads the file into the core using read().
965 If file is named "-", fileno(stdin) is used for reading instead.
966 If you want to read from a real file named "-", use "./-" instead. */
969 read_file (const char *file)
972 struct file_memory *fm;
974 int inhibit_close = 0;
976 /* Some magic in the finest tradition of Perl and its kin: if FILE
977 is "-", just use stdin. */
982 /* Note that we don't inhibit mmap() in this case. If stdin is
983 redirected from a regular file, mmap() will still work. */
986 fd = open (file, O_RDONLY);
989 fm = xmalloc (sizeof (struct file_memory));
994 if (fstat (fd, &buf) < 0)
996 fm->length = buf.st_size;
997 /* NOTE: As far as I know, the callers of this function never
998 modify the file text. Relying on this would enable us to
999 specify PROT_READ and MAP_SHARED for a marginal gain in
1000 efficiency, but at some cost to generality. */
1001 fm->content = mmap (NULL, fm->length, PROT_READ | PROT_WRITE,
1002 MAP_PRIVATE, fd, 0);
1003 if (fm->content == (char *)MAP_FAILED)
1013 /* The most common reason why mmap() fails is that FD does not point
1014 to a plain file. However, it's also possible that mmap() doesn't
1015 work for a particular type of file. Therefore, whenever mmap()
1016 fails, we just fall back to the regular method. */
1017 #endif /* HAVE_MMAP */
1020 size = 512; /* number of bytes fm->contents can
1021 hold at any given time. */
1022 fm->content = xmalloc (size);
1026 if (fm->length > size / 2)
1028 /* #### I'm not sure whether the whole exponential-growth
1029 thing makes sense with kernel read. On Linux at least,
1030 read() refuses to read more than 4K from a file at a
1031 single chunk anyway. But other Unixes might optimize it
1032 better, and it doesn't *hurt* anything, so I'm leaving
1035 /* Normally, we grow SIZE exponentially to make the number
1036 of calls to read() and realloc() logarithmic in relation
1037 to file size. However, read() can read an amount of data
1038 smaller than requested, and it would be unreasonable to
1039 double SIZE every time *something* was read. Therefore,
1040 we double SIZE only when the length exceeds half of the
1041 entire allocated size. */
1043 fm->content = xrealloc (fm->content, size);
1045 nread = read (fd, fm->content + fm->length, size - fm->length);
1047 /* Successful read. */
1048 fm->length += nread;
1058 if (size > fm->length && fm->length != 0)
1059 /* Due to exponential growth of fm->content, the allocated region
1060 might be much larger than what is actually needed. */
1061 fm->content = xrealloc (fm->content, fm->length);
1068 xfree (fm->content);
1073 /* Release the resources held by FM. Specifically, this calls
1074 munmap() or xfree() on fm->content, depending whether mmap or
1075 malloc/read were used to read in the file. It also frees the
1076 memory needed to hold the FM structure itself. */
1079 read_file_free (struct file_memory *fm)
1084 munmap (fm->content, fm->length);
1089 xfree (fm->content);
1094 /* Free the pointers in a NULL-terminated vector of pointers, then
1095 free the pointer itself. */
1097 free_vec (char **vec)
1108 /* Append vector V2 to vector V1. The function frees V2 and
1109 reallocates V1 (thus you may not use the contents of neither
1110 pointer after the call). If V1 is NULL, V2 is returned. */
1112 merge_vecs (char **v1, char **v2)
1122 /* To avoid j == 0 */
1127 for (i = 0; v1[i]; i++);
1129 for (j = 0; v2[j]; j++);
1130 /* Reallocate v1. */
1131 v1 = (char **)xrealloc (v1, (i + j + 1) * sizeof (char **));
1132 memcpy (v1 + i, v2, (j + 1) * sizeof (char *));
1137 /* A set of simple-minded routines to store strings in a linked list.
1138 This used to also be used for searching, but now we have hash
1141 /* It's a shame that these simple things like linked lists and hash
1142 tables (see hash.c) need to be implemented over and over again. It
1143 would be nice to be able to use the routines from glib -- see
1144 www.gtk.org for details. However, that would make Wget depend on
1145 glib, and I want to avoid dependencies to external libraries for
1146 reasons of convenience and portability (I suspect Wget is more
1147 portable than anything ever written for Gnome). */
1149 /* Append an element to the list. If the list has a huge number of
1150 elements, this can get slow because it has to find the list's
1151 ending. If you think you have to call slist_append in a loop,
1152 think about calling slist_prepend() followed by slist_nreverse(). */
1155 slist_append (slist *l, const char *s)
1157 slist *newel = (slist *)xmalloc (sizeof (slist));
1160 newel->string = xstrdup (s);
1165 /* Find the last element. */
1172 /* Prepend S to the list. Unlike slist_append(), this is O(1). */
1175 slist_prepend (slist *l, const char *s)
1177 slist *newel = (slist *)xmalloc (sizeof (slist));
1178 newel->string = xstrdup (s);
1183 /* Destructively reverse L. */
1186 slist_nreverse (slist *l)
1191 slist *next = l->next;
1199 /* Is there a specific entry in the list? */
1201 slist_contains (slist *l, const char *s)
1203 for (; l; l = l->next)
1204 if (!strcmp (l->string, s))
1209 /* Free the whole slist. */
1211 slist_free (slist *l)
1222 /* Sometimes it's useful to create "sets" of strings, i.e. special
1223 hash tables where you want to store strings as keys and merely
1224 query for their existence. Here is a set of utility routines that
1225 makes that transparent. */
1228 string_set_add (struct hash_table *ht, const char *s)
1230 /* First check whether the set element already exists. If it does,
1231 do nothing so that we don't have to free() the old element and
1232 then strdup() a new one. */
1233 if (hash_table_contains (ht, s))
1236 /* We use "1" as value. It provides us a useful and clear arbitrary
1237 value, and it consumes no memory -- the pointers to the same
1238 string "1" will be shared by all the key-value pairs in all `set'
1240 hash_table_put (ht, xstrdup (s), "1");
1243 /* Synonym for hash_table_contains... */
1246 string_set_contains (struct hash_table *ht, const char *s)
1248 return hash_table_contains (ht, s);
1252 string_set_free_mapper (void *key, void *value_ignored, void *arg_ignored)
1259 string_set_free (struct hash_table *ht)
1261 hash_table_map (ht, string_set_free_mapper, NULL);
1262 hash_table_destroy (ht);
1266 free_keys_and_values_mapper (void *key, void *value, void *arg_ignored)
1273 /* Another utility function: call free() on all keys and values of HT. */
1276 free_keys_and_values (struct hash_table *ht)
1278 hash_table_map (ht, free_keys_and_values_mapper, NULL);
1282 /* Engine for legible and legible_very_long; this function works on
1286 legible_1 (const char *repr)
1288 static char outbuf[128];
1293 /* Reset the pointers. */
1296 /* If the number is negative, shift the pointers. */
1302 /* How many digits before the first separator? */
1303 mod = strlen (inptr) % 3;
1305 for (i = 0; i < mod; i++)
1306 *outptr++ = inptr[i];
1307 /* Now insert the rest of them, putting separator before every
1309 for (i1 = i, i = 0; inptr[i1]; i++, i1++)
1311 if (i % 3 == 0 && i1 != 0)
1313 *outptr++ = inptr[i1];
1315 /* Zero-terminate the string. */
1320 /* Legible -- return a static pointer to the legibly printed long. */
1325 /* Print the number into the buffer. */
1326 number_to_string (inbuf, l);
1327 return legible_1 (inbuf);
1330 /* Write a string representation of NUMBER into the provided buffer.
1331 We cannot use sprintf() because we cannot be sure whether the
1332 platform supports printing of what we chose for VERY_LONG_TYPE.
1334 Example: Gcc supports `long long' under many platforms, but on many
1335 of those the native libc knows nothing of it and therefore cannot
1338 How long BUFFER needs to be depends on the platform and the content
1339 of NUMBER. For 64-bit VERY_LONG_TYPE (the most common case), 24
1340 bytes are sufficient. Using more might be a good idea.
1342 This function does not go through the hoops that long_to_string
1343 goes to because it doesn't aspire to be fast. (It's called perhaps
1344 once in a Wget run.) */
1347 very_long_to_string (char *buffer, VERY_LONG_TYPE number)
1352 /* Print the number backwards... */
1355 buffer[i++] = '0' + number % 10;
1360 /* ...and reverse the order of the digits. */
1361 for (j = 0; j < i / 2; j++)
1364 buffer[j] = buffer[i - 1 - j];
1365 buffer[i - 1 - j] = c;
1370 /* The same as legible(), but works on VERY_LONG_TYPE. See sysdep.h. */
1372 legible_very_long (VERY_LONG_TYPE l)
1375 /* Print the number into the buffer. */
1376 very_long_to_string (inbuf, l);
1377 return legible_1 (inbuf);
1380 /* Count the digits in a (long) integer. */
1382 numdigit (long number)
1390 while ((number /= 10) > 0)
1395 /* A half-assed implementation of INT_MAX on machines that don't
1396 bother to define one. */
1398 # define INT_MAX ((int) ~((unsigned)1 << 8 * sizeof (int) - 1))
1401 #define ONE_DIGIT(figure) *p++ = n / (figure) + '0'
1402 #define ONE_DIGIT_ADVANCE(figure) (ONE_DIGIT (figure), n %= (figure))
1404 #define DIGITS_1(figure) ONE_DIGIT (figure)
1405 #define DIGITS_2(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_1 ((figure) / 10)
1406 #define DIGITS_3(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_2 ((figure) / 10)
1407 #define DIGITS_4(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_3 ((figure) / 10)
1408 #define DIGITS_5(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_4 ((figure) / 10)
1409 #define DIGITS_6(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_5 ((figure) / 10)
1410 #define DIGITS_7(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_6 ((figure) / 10)
1411 #define DIGITS_8(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_7 ((figure) / 10)
1412 #define DIGITS_9(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_8 ((figure) / 10)
1413 #define DIGITS_10(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_9 ((figure) / 10)
1415 /* DIGITS_<11-20> are only used on machines with 64-bit longs. */
1417 #define DIGITS_11(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_10 ((figure) / 10)
1418 #define DIGITS_12(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_11 ((figure) / 10)
1419 #define DIGITS_13(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_12 ((figure) / 10)
1420 #define DIGITS_14(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_13 ((figure) / 10)
1421 #define DIGITS_15(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_14 ((figure) / 10)
1422 #define DIGITS_16(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_15 ((figure) / 10)
1423 #define DIGITS_17(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_16 ((figure) / 10)
1424 #define DIGITS_18(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_17 ((figure) / 10)
1425 #define DIGITS_19(figure) ONE_DIGIT_ADVANCE (figure); DIGITS_18 ((figure) / 10)
1427 /* Print NUMBER to BUFFER in base 10. This should be completely
1428 equivalent to `sprintf(buffer, "%ld", number)', only much faster.
1430 The speedup may make a difference in programs that frequently
1431 convert numbers to strings. Some implementations of sprintf,
1432 particularly the one in GNU libc, have been known to be extremely
1433 slow compared to this function.
1435 Return the pointer to the location where the terminating zero was
1436 printed. (Equivalent to calling buffer+strlen(buffer) after the
1439 BUFFER should be big enough to accept as many bytes as you expect
1440 the number to take up. On machines with 64-bit longs the maximum
1441 needed size is 24 bytes. That includes the digits needed for the
1442 largest 64-bit number, the `-' sign in case it's negative, and the
1443 terminating '\0'. */
1446 number_to_string (char *buffer, long number)
1451 #if (SIZEOF_LONG != 4) && (SIZEOF_LONG != 8)
1452 /* We are running in a strange or misconfigured environment. Let
1453 sprintf cope with it. */
1454 sprintf (buffer, "%ld", n);
1455 p += strlen (buffer);
1456 #else /* (SIZEOF_LONG == 4) || (SIZEOF_LONG == 8) */
1462 /* We cannot print a '-' and assign -n to n because -n would
1463 overflow. Let sprintf deal with this border case. */
1464 sprintf (buffer, "%ld", n);
1465 p += strlen (buffer);
1473 if (n < 10) { DIGITS_1 (1); }
1474 else if (n < 100) { DIGITS_2 (10); }
1475 else if (n < 1000) { DIGITS_3 (100); }
1476 else if (n < 10000) { DIGITS_4 (1000); }
1477 else if (n < 100000) { DIGITS_5 (10000); }
1478 else if (n < 1000000) { DIGITS_6 (100000); }
1479 else if (n < 10000000) { DIGITS_7 (1000000); }
1480 else if (n < 100000000) { DIGITS_8 (10000000); }
1481 else if (n < 1000000000) { DIGITS_9 (100000000); }
1482 #if SIZEOF_LONG == 4
1483 /* ``if (1)'' serves only to preserve editor indentation. */
1484 else if (1) { DIGITS_10 (1000000000); }
1485 #else /* SIZEOF_LONG != 4 */
1486 else if (n < 10000000000L) { DIGITS_10 (1000000000L); }
1487 else if (n < 100000000000L) { DIGITS_11 (10000000000L); }
1488 else if (n < 1000000000000L) { DIGITS_12 (100000000000L); }
1489 else if (n < 10000000000000L) { DIGITS_13 (1000000000000L); }
1490 else if (n < 100000000000000L) { DIGITS_14 (10000000000000L); }
1491 else if (n < 1000000000000000L) { DIGITS_15 (100000000000000L); }
1492 else if (n < 10000000000000000L) { DIGITS_16 (1000000000000000L); }
1493 else if (n < 100000000000000000L) { DIGITS_17 (10000000000000000L); }
1494 else if (n < 1000000000000000000L) { DIGITS_18 (100000000000000000L); }
1495 else { DIGITS_19 (1000000000000000000L); }
1496 #endif /* SIZEOF_LONG != 4 */
1499 #endif /* (SIZEOF_LONG == 4) || (SIZEOF_LONG == 8) */
1505 #undef ONE_DIGIT_ADVANCE
1527 /* Support for timers. */
1529 #undef TIMER_WINDOWS
1530 #undef TIMER_GETTIMEOFDAY
1533 /* Depending on the OS and availability of gettimeofday(), one and
1534 only one of the above constants will be defined. Virtually all
1535 modern Unix systems will define TIMER_GETTIMEOFDAY; Windows will
1536 use TIMER_WINDOWS. TIMER_TIME is a catch-all method for
1537 non-Windows systems without gettimeofday.
1539 #### Perhaps we should also support ftime(), which exists on old
1540 BSD 4.2-influenced systems? (It also existed under MS DOS Borland
1541 C, if memory serves me.) */
1544 # define TIMER_WINDOWS
1545 #else /* not WINDOWS */
1546 # ifdef HAVE_GETTIMEOFDAY
1547 # define TIMER_GETTIMEOFDAY
1551 #endif /* not WINDOWS */
1553 #ifdef TIMER_GETTIMEOFDAY
1554 typedef struct timeval wget_sys_time;
1558 typedef time_t wget_sys_time;
1561 #ifdef TIMER_WINDOWS
1562 typedef ULARGE_INTEGER wget_sys_time;
1566 /* The starting point in time which, subtracted from the current
1567 time, yields elapsed time. */
1568 wget_sys_time start;
1570 /* The most recent elapsed time, calculated by wtimer_elapsed().
1571 Measured in milliseconds. */
1572 double elapsed_last;
1574 /* Approximately, the time elapsed between the true start of the
1575 measurement and the time represented by START. */
1576 double elapsed_pre_start;
1579 /* Allocate a timer. It is not legal to do anything with a freshly
1580 allocated timer, except call wtimer_reset() or wtimer_delete(). */
1583 wtimer_allocate (void)
1585 struct wget_timer *wt =
1586 (struct wget_timer *)xmalloc (sizeof (struct wget_timer));
1590 /* Allocate a new timer and reset it. Return the new timer. */
1595 struct wget_timer *wt = wtimer_allocate ();
1600 /* Free the resources associated with the timer. Its further use is
1604 wtimer_delete (struct wget_timer *wt)
1609 /* Store system time to WST. */
1612 wtimer_sys_set (wget_sys_time *wst)
1614 #ifdef TIMER_GETTIMEOFDAY
1615 gettimeofday (wst, NULL);
1622 #ifdef TIMER_WINDOWS
1623 /* We use GetSystemTime to get the elapsed time. MSDN warns that
1624 system clock adjustments can skew the output of GetSystemTime
1625 when used as a timer and gives preference to GetTickCount and
1626 high-resolution timers. But GetTickCount can overflow, and hires
1627 timers are typically used for profiling, not for regular time
1628 measurement. Since we handle clock skew anyway, we just use
1632 GetSystemTime (&st);
1634 /* As recommended by MSDN, we convert SYSTEMTIME to FILETIME, copy
1635 FILETIME to ULARGE_INTEGER, and use regular 64-bit integer
1636 arithmetic on that. */
1637 SystemTimeToFileTime (&st, &ft);
1638 wst->HighPart = ft.dwHighDateTime;
1639 wst->LowPart = ft.dwLowDateTime;
1643 /* Reset timer WT. This establishes the starting point from which
1644 wtimer_elapsed() will return the number of elapsed
1645 milliseconds. It is allowed to reset a previously used timer. */
1648 wtimer_reset (struct wget_timer *wt)
1650 /* Set the start time to the current time. */
1651 wtimer_sys_set (&wt->start);
1652 wt->elapsed_last = 0;
1653 wt->elapsed_pre_start = 0;
1657 wtimer_sys_diff (wget_sys_time *wst1, wget_sys_time *wst2)
1659 #ifdef TIMER_GETTIMEOFDAY
1660 return ((double)(wst1->tv_sec - wst2->tv_sec) * 1000
1661 + (double)(wst1->tv_usec - wst2->tv_usec) / 1000);
1665 return 1000 * (*wst1 - *wst2);
1669 /* VC++ 6 doesn't support direct cast of uint64 to double. To work
1670 around this, we subtract, then convert to signed, then finally to
1672 return (double)(signed __int64)(wst1->QuadPart - wst2->QuadPart) / 10000;
1676 /* Return the number of milliseconds elapsed since the timer was last
1677 reset. It is allowed to call this function more than once to get
1678 increasingly higher elapsed values. These timers handle clock
1682 wtimer_elapsed (struct wget_timer *wt)
1687 wtimer_sys_set (&now);
1688 elapsed = wt->elapsed_pre_start + wtimer_sys_diff (&now, &wt->start);
1690 /* Ideally we'd just return the difference between NOW and
1691 wt->start. However, the system timer can be set back, and we
1692 could return a value smaller than when we were last called, even
1693 a negative value. Both of these would confuse the callers, which
1694 expect us to return monotonically nondecreasing values.
1696 Therefore: if ELAPSED is smaller than its previous known value,
1697 we reset wt->start to the current time and effectively start
1698 measuring from this point. But since we don't want the elapsed
1699 value to start from zero, we set elapsed_pre_start to the last
1700 elapsed time and increment all future calculations by that
1703 if (elapsed < wt->elapsed_last)
1706 wt->elapsed_pre_start = wt->elapsed_last;
1707 elapsed = wt->elapsed_last;
1710 wt->elapsed_last = elapsed;
1714 /* Return the assessed granularity of the timer implementation, in
1715 milliseconds. This is used by code that tries to substitute a
1716 better value for timers that have returned zero. */
1719 wtimer_granularity (void)
1721 #ifdef TIMER_GETTIMEOFDAY
1722 /* Granularity of gettimeofday varies wildly between architectures.
1723 However, it appears that on modern machines it tends to be better
1724 than 1ms. Assume 100 usecs. (Perhaps the configure process
1725 could actually measure this?) */
1733 #ifdef TIMER_WINDOWS
1734 /* According to MSDN, GetSystemTime returns a broken-down time
1735 structure the smallest member of which are milliseconds. */
1740 /* This should probably be at a better place, but it doesn't really
1741 fit into html-parse.c. */
1743 /* The function returns the pointer to the malloc-ed quoted version of
1744 string s. It will recognize and quote numeric and special graphic
1745 entities, as per RFC1866:
1753 No other entities are recognized or replaced. */
1755 html_quote_string (const char *s)
1761 /* Pass through the string, and count the new size. */
1762 for (i = 0; *s; s++, i++)
1765 i += 4; /* `amp;' */
1766 else if (*s == '<' || *s == '>')
1767 i += 3; /* `lt;' and `gt;' */
1768 else if (*s == '\"')
1769 i += 5; /* `quot;' */
1773 res = (char *)xmalloc (i + 1);
1775 for (p = res; *s; s++)
1788 *p++ = (*s == '<' ? 'l' : 'g');
1815 /* Determine the width of the terminal we're running on. If that's
1816 not possible, return 0. */
1819 determine_screen_width (void)
1821 /* If there's a way to get the terminal size using POSIX
1822 tcgetattr(), somebody please tell me. */
1825 #else /* TIOCGWINSZ */
1829 if (opt.lfilename != NULL)
1832 fd = fileno (stderr);
1833 if (ioctl (fd, TIOCGWINSZ, &wsz) < 0)
1834 return 0; /* most likely ENOTTY */
1837 #endif /* TIOCGWINSZ */
1840 /* Return a random number between 0 and MAX-1, inclusive.
1842 If MAX is greater than the value of RAND_MAX+1 on the system, the
1843 returned value will be in the range [0, RAND_MAX]. This may be
1844 fixed in a future release.
1846 The random number generator is seeded automatically the first time
1849 This uses rand() for portability. It has been suggested that
1850 random() offers better randomness, but this is not required for
1851 Wget, so I chose to go for simplicity and use rand
1854 DO NOT use this for cryptographic purposes. It is only meant to be
1855 used in situations where quality of the random numbers returned
1856 doesn't really matter. */
1859 random_number (int max)
1867 srand (time (NULL));
1872 /* On systems that don't define RAND_MAX, assume it to be 2**15 - 1,
1873 and enforce that assumption by masking other bits. */
1875 # define RAND_MAX 32767
1879 /* This is equivalent to rand() % max, but uses the high-order bits
1880 for better randomness on architecture where rand() is implemented
1881 using a simple congruential generator. */
1883 bounded = (double)max * rnd / (RAND_MAX + 1.0);
1884 return (int)bounded;
1887 /* Return a random uniformly distributed floating point number in the
1888 [0, 1) range. The precision of returned numbers is 9 digits.
1890 Modify this to use erand48() where available! */
1895 /* We can't rely on any specific value of RAND_MAX, but I'm pretty
1896 sure it's greater than 1000. */
1897 int rnd1 = random_number (1000);
1898 int rnd2 = random_number (1000);
1899 int rnd3 = random_number (1000);
1900 return rnd1 / 1000.0 + rnd2 / 1000000.0 + rnd3 / 1000000000.0;
1904 /* A debugging function for checking whether an MD5 library works. */
1906 #include "gen-md5.h"
1909 debug_test_md5 (char *buf)
1911 unsigned char raw[16];
1912 static char res[33];
1916 ALLOCA_MD5_CONTEXT (ctx);
1919 gen_md5_update ((unsigned char *)buf, strlen (buf), ctx);
1920 gen_md5_finish (ctx, raw);
1927 *p2++ = XNUM_TO_digit (*p1 >> 4);
1928 *p2++ = XNUM_TO_digit (*p1 & 0xf);
1937 /* Implementation of run_with_timeout, a generic timeout-forcing
1938 routine for systems with Unix-like signal handling. */
1940 #ifdef USE_SIGNAL_TIMEOUT
1941 # ifdef HAVE_SIGSETJMP
1942 # define SETJMP(env) sigsetjmp (env, 1)
1944 static sigjmp_buf run_with_timeout_env;
1947 abort_run_with_timeout (int sig)
1949 assert (sig == SIGALRM);
1950 siglongjmp (run_with_timeout_env, -1);
1952 # else /* not HAVE_SIGSETJMP */
1953 # define SETJMP(env) setjmp (env)
1955 static jmp_buf run_with_timeout_env;
1958 abort_run_with_timeout (int sig)
1960 assert (sig == SIGALRM);
1961 /* We don't have siglongjmp to preserve the set of blocked signals;
1962 if we longjumped out of the handler at this point, SIGALRM would
1963 remain blocked. We must unblock it manually. */
1964 int mask = siggetmask ();
1965 mask &= ~sigmask (SIGALRM);
1968 /* Now it's safe to longjump. */
1969 longjmp (run_with_timeout_env, -1);
1971 # endif /* not HAVE_SIGSETJMP */
1973 /* Arrange for SIGALRM to be delivered in TIMEOUT seconds. This uses
1974 setitimer where available, alarm otherwise.
1976 TIMEOUT should be non-zero. If the timeout value is so small that
1977 it would be rounded to zero, it is rounded to the least legal value
1978 instead (1us for setitimer, 1s for alarm). That ensures that
1979 SIGALRM will be delivered in all cases. */
1982 alarm_set (double timeout)
1985 /* Use the modern itimer interface. */
1986 struct itimerval itv;
1987 memset (&itv, 0, sizeof (itv));
1988 itv.it_value.tv_sec = (long) timeout;
1989 itv.it_value.tv_usec = 1000000L * (timeout - (long)timeout);
1990 if (itv.it_value.tv_sec == 0 && itv.it_value.tv_usec == 0)
1991 /* Ensure that we wait for at least the minimum interval.
1992 Specifying zero would mean "wait forever". */
1993 itv.it_value.tv_usec = 1;
1994 setitimer (ITIMER_REAL, &itv, NULL);
1995 #else /* not ITIMER_REAL */
1996 /* Use the old alarm() interface. */
1997 int secs = (int) timeout;
1999 /* Round TIMEOUTs smaller than 1 to 1, not to zero. This is
2000 because alarm(0) means "never deliver the alarm", i.e. "wait
2001 forever", which is not what someone who specifies a 0.5s
2002 timeout would expect. */
2005 #endif /* not ITIMER_REAL */
2008 /* Cancel the alarm set with alarm_set. */
2014 struct itimerval disable;
2015 memset (&disable, 0, sizeof (disable));
2016 setitimer (ITIMER_REAL, &disable, NULL);
2017 #else /* not ITIMER_REAL */
2019 #endif /* not ITIMER_REAL */
2022 /* Call FUN(ARG), but don't allow it to run for more than TIMEOUT
2023 seconds. Returns non-zero if the function was interrupted with a
2024 timeout, zero otherwise.
2026 This works by setting up SIGALRM to be delivered in TIMEOUT seconds
2027 using setitimer() or alarm(). The timeout is enforced by
2028 longjumping out of the SIGALRM handler. This has several
2029 advantages compared to the traditional approach of relying on
2030 signals causing system calls to exit with EINTR:
2032 * The callback function is *forcibly* interrupted after the
2033 timeout expires, (almost) regardless of what it was doing and
2034 whether it was in a syscall. For example, a calculation that
2035 takes a long time is interrupted as reliably as an IO
2038 * It works with both SYSV and BSD signals because it doesn't
2039 depend on the default setting of SA_RESTART.
2041 * It doesn't special handler setup beyond a simple call to
2042 signal(). (It does use sigsetjmp/siglongjmp, but they're
2045 The only downside is that, if FUN allocates internal resources that
2046 are normally freed prior to exit from the functions, they will be
2047 lost in case of timeout. */
2050 run_with_timeout (double timeout, void (*fun) (void *), void *arg)
2060 signal (SIGALRM, abort_run_with_timeout);
2061 if (SETJMP (run_with_timeout_env) != 0)
2063 /* Longjumped out of FUN with a timeout. */
2064 signal (SIGALRM, SIG_DFL);
2067 alarm_set (timeout);
2070 /* Preserve errno in case alarm() or signal() modifies it. */
2071 saved_errno = errno;
2073 signal (SIGALRM, SIG_DFL);
2074 errno = saved_errno;
2079 #else /* not USE_SIGNAL_TIMEOUT */
2082 /* A stub version of run_with_timeout that just calls FUN(ARG). Don't
2083 define it under Windows, because Windows has its own version of
2084 run_with_timeout that uses threads. */
2087 run_with_timeout (double timeout, void (*fun) (void *), void *arg)
2092 #endif /* not WINDOWS */
2093 #endif /* not USE_SIGNAL_TIMEOUT */