/* Miscellaneous declarations.
- Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+ 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation,
+ Inc.
-This file is part of Wget.
+This file is part of GNU Wget.
-This program is free software; you can redistribute it and/or modify
+GNU Wget is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-This program is distributed in the hope that it will be useful,
+GNU Wget is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with Wget. If not, see <http://www.gnu.org/licenses/>.
-/* This file contains some declarations that don't fit anywhere else.
- It also contains some useful includes, like the obnoxious TIME_H
- inclusion. */
+Additional permission under GNU GPL version 3 section 7
+
+If you modify this program, or any covered work, by linking or
+combining it with the OpenSSL project's OpenSSL library (or a
+modified version of that library), containing parts covered by the
+terms of the OpenSSL or SSLeay licenses, the Free Software Foundation
+grants you additional permission to convey the resulting work.
+Corresponding Source for a non-source form of such a combination
+shall include the source code for the parts of OpenSSL used as well
+as that of the covered work. */
+
+/* This file contains declarations that are universally useful and
+ those that don't fit elsewhere. It also includes sysdep.h which
+ includes some often-needed system includes, like the obnoxious
+ <time.h> inclusion. */
#ifndef WGET_H
#define WGET_H
-#ifndef DEBUG
-# define NDEBUG /* To kill off assertions */
-#endif /* not DEBUG */
+#include "config.h"
-#ifndef PARAMS
-# if PROTOTYPES
-# define PARAMS(args) args
-# else
-# define PARAMS(args) ()
-# endif
+#if ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__)
+# define WINDOWS
+#endif
+
+/* Include these, so random files need not include them. */
+#include "sysdep.h"
+
+/* Disable assertions when debug support is not compiled in. */
+#ifndef ENABLE_DEBUG
+# define NDEBUG
+#endif
+
+/* Is OpenSSL or GNUTLS available? */
+#if defined HAVE_LIBSSL || defined HAVE_LIBSSL32 || defined HAVE_LIBGNUTLS
+# define HAVE_SSL
#endif
/* `gettext (FOO)' is long to write, so we use `_(FOO)'. If NLS is
unavailable, _(STRING) simply returns STRING. */
-#ifdef HAVE_NLS
-# define _(string) gettext (string)
-# ifdef HAVE_LIBINTL_H
-# include <libintl.h>
-# endif /* HAVE_LIBINTL_H */
-#else /* not HAVE_NLS */
-# define _(string) string
-#endif /* not HAVE_NLS */
-
-/* I18N NOTE: You will notice that none of the DEBUG messages are
+#include "gettext.h"
+#define _(string) gettext (string)
+
+/* A pseudo function call that serves as a marker for the automated
+ extraction of messages, but does not call gettext(). The run-time
+ translation is done at a different place in the code. The purpose
+ of the N_("...") call is to make the message snarfer aware that the
+ "..." string needs to be translated. STRING should be a string
+ literal. Concatenated strings and other string expressions won't
+ work. The macro's expansion is not parenthesized, so that it is
+ suitable as initializer for static 'char[]' or 'const char[]'
+ variables. -- explanation partly taken from GNU make. */
+#define N_(string) string
+
+#if ! ENABLE_NLS
+# undef HAVE_WCHAR_H
+# undef HAVE_WCWIDTH
+# undef HAVE_MBTOWC
+#endif /* not ENABLE_NLS */
+
+#if HAVE_WCWIDTH && HAVE_MBTOWC
+# define USE_NLS_PROGRESS_BAR 1
+#else
+/* Just to be a little paranoid about it. */
+# undef USE_NLS_PROGRESS_BAR
+#endif
+
+/* I18N NOTE: You will notice that none of the DEBUGP messages are
marked as translatable. This is intentional, for a few reasons:
1) The debug messages are not meant for the users to look at, but
3) Finally, the debug messages are meant to be a clue for me to
debug problems with Wget. If I get them in a language I don't
- understand, debugging will become a new challenge of its own! :-) */
+ understand, debugging will become a new challenge of its own! */
-
-/* Include these, so random files need not include them. */
-#include "sysdep.h"
-#include "options.h"
/* locale independent replacement for ctype.h */
-#include "safe-ctype.h"
-
-#define DO_NOTHING do {} while (0)
+#include "c-ctype.h"
-/* Print X if debugging is enabled; a no-op otherwise. */
-#ifdef DEBUG
-# define DEBUGP(x) do { if (opt.debug) { debug_logprintf x; } } while (0)
-#else /* not DEBUG */
-# define DEBUGP(x) DO_NOTHING
-#endif /* not DEBUG */
+/* Conditionalize the use of GCC's __attribute__((format)) and
+ __builtin_expect features using macros. */
-/* Make gcc check for the format of logmsg() and debug_logmsg(). */
-#ifdef __GNUC__
+#if defined(__GNUC__) && __GNUC__ >= 3
# define GCC_FORMAT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
-#else /* not __GNUC__ */
+# define LIKELY(exp) __builtin_expect (!!(exp), 1)
+# define UNLIKELY(exp) __builtin_expect ((exp), 0)
+#else
# define GCC_FORMAT_ATTR(a, b)
-#endif /* not __GNUC__ */
-
-/* These are from log.c, but they are used everywhere, so we declare
- them here. */
-enum log_options { LOG_VERBOSE, LOG_NOTQUIET, LOG_NONVERBOSE, LOG_ALWAYS };
-
-#ifdef HAVE_STDARG_H
-void logprintf PARAMS ((enum log_options, const char *, ...))
- GCC_FORMAT_ATTR (2, 3);
-void debug_logprintf PARAMS ((const char *, ...)) GCC_FORMAT_ATTR (1, 2);
-#else /* not HAVE_STDARG_H */
-void logprintf ();
-void debug_logprintf ();
-#endif /* not HAVE_STDARG_H */
-void logputs PARAMS ((enum log_options, const char *));
-
-/* Defined in `utils.c', but used literally everywhere. */
-#ifndef DEBUG_MALLOC
+# define LIKELY(exp) (exp)
+# define UNLIKELY(exp) (exp)
+#endif
-#define xmalloc xmalloc_real
-#define xrealloc xrealloc_real
-#define xstrdup xstrdup_real
-#define xfree free
+/* Execute the following statement if debugging is both enabled at
+ compile-time and requested at run-time; a no-op otherwise. */
-void *xmalloc_real PARAMS ((size_t));
-void *xrealloc_real PARAMS ((void *, size_t));
-char *xstrdup_real PARAMS ((const char *));
+#ifdef ENABLE_DEBUG
+# define IF_DEBUG if (UNLIKELY (opt.debug))
+#else
+# define IF_DEBUG if (0)
+#endif
-#else /* DEBUG_MALLOC */
+/* Print ARGS if debugging is enabled and requested, otherwise do
+ nothing. This must be called with an extra level of parentheses
+ because it's not possible to pass a variable number of arguments to
+ a macro (in portable C89). ARGS are like arguments to printf. */
+
+#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0)
+
+/* Pick an integer type large enough for file sizes, content lengths,
+ and such. Because today's files can be very large, it should be a
+ signed integer at least 64 bits wide. This can't be typedeffed to
+ off_t because: a) off_t is always 32-bit on Windows, and b) we
+ don't necessarily want to tie having a 64-bit type for internal
+ calculations to having LFS support. */
+
+#ifdef WINDOWS
+ /* nothing to do, see mswindows.h */
+#elif SIZEOF_LONG >= 8
+ /* long is large enough, so use it. */
+ typedef long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG
+#elif SIZEOF_LONG_LONG >= 8
+ /* long long is large enough and available, use that */
+ typedef long long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG_LONG
+#elif HAVE_INT64_T
+ typedef int64_t wgint;
+# define SIZEOF_WGINT 8
+#elif SIZEOF_OFF_T >= 8
+ /* In case off_t is typedeffed to a large non-standard type that our
+ tests don't find. */
+ typedef off_t wgint;
+# define SIZEOF_WGINT SIZEOF_OFF_T
+#else
+ /* Fall back to using long, which is always available and in most
+ cases large enough. */
+ typedef long wgint;
+# define SIZEOF_WGINT SIZEOF_LONG
+#endif
-#define xmalloc(s) xmalloc_debug (s, __FILE__, __LINE__)
-#define xfree(p) xfree_debug (p, __FILE__, __LINE__)
-#define xrealloc(p, s) xrealloc_debug (p, s, __FILE__, __LINE__)
-#define xstrdup(p) xstrdup_debug (p, __FILE__, __LINE__)
+/* Pick a strtol-compatible function that will work with wgint. The
+ choices are strtol, strtoll, or our own implementation of strtoll
+ in cmpt.c, activated with NEED_STRTOLL. */
+
+#ifdef WINDOWS
+ /* nothing to do, see mswindows.h */
+#elif SIZEOF_WGINT == SIZEOF_LONG
+# define str_to_wgint strtol
+#elif SIZEOF_WGINT == SIZEOF_LONG_LONG
+# define str_to_wgint strtoll
+# ifndef HAVE_STRTOLL
+# define NEED_STRTOLL
+# define strtoll_type long long
+# endif
+#else
+ /* wgint has a strange size; synthesize strtoll and use it. */
+# define str_to_wgint strtoll
+# define NEED_STRTOLL
+# define strtoll_type wgint
+#endif
-void *xmalloc_debug PARAMS ((size_t, const char *, int));
-void xfree_debug PARAMS ((void *, const char *, int));
-void *xrealloc_debug PARAMS ((void *, size_t, const char *, int));
-char *xstrdup_debug PARAMS ((const char *, const char *, int));
+#define WGINT_MAX TYPE_MAXIMUM (wgint)
-#endif /* DEBUG_MALLOC */
+/* Declare our strtoll replacement. */
+#ifdef NEED_STRTOLL
+strtoll_type strtoll (const char *, char **, int);
+#endif
-/* #### Find a better place for this. */
-/* The log file to which Wget writes to after HUP. */
-#define DEFAULT_LOGFILE "wget-log"
+/* Now define a large numeric type useful for storing sizes of *sums*
+ of downloads, such as the value of the --quota option. This should
+ be a type able to hold 2G+ values even on systems without large
+ file support. (It is useful to limit Wget's download quota to say
+ 10G even if a single file cannot be that large.)
+
+ To make sure we get the largest size possible, we use `double' on
+ systems without a 64-bit integral type. (Since it is used in very
+ few places in Wget, this is acceptable.) */
+
+#if SIZEOF_WGINT >= 8
+/* just use wgint */
+typedef wgint SUM_SIZE_INT;
+#else
+/* On systems without LFS, use double, which buys us integers up to 2^53. */
+typedef double SUM_SIZE_INT;
+#endif
-#define MD5_HASHLEN 16
-\f
-/* Useful macros used across the code: */
+#include "options.h"
-/* Is the string a hpyhen-only? */
-#define HYPHENP(x) (*(x) == '-' && !*((x) + 1))
+/* Everything uses this, so include them here directly. */
+#include <alloca.h>
+#include "xalloc.h"
-/* The smaller value of the two. */
-#define MINVAL(x, y) ((x) < (y) ? (x) : (y))
+/* Likewise for logging functions. */
+#include "log.h"
-/* Convert the ASCII character X to a hex-digit. X should be between
- '0' and '9', or between 'A' and 'F', or between 'a' and 'f'. The
- result is a number between 0 and 15. If X is not a hexadecimal
- digit character, the result is undefined. */
-#define XCHAR_TO_XDIGIT(x) \
- (((x) >= '0' && (x) <= '9') ? \
- ((x) - '0') : (TOUPPER(x) - 'A' + 10))
+/* Likewise for quoting functions. */
+#include "quote.h"
+#include "quotearg.h"
-/* The reverse of the above: convert a HEX digit in the [0, 15] range
- to an ASCII character representing it. The A-F characters are
- always in upper case. */
-#define XDIGIT_TO_XCHAR(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'A'))
+/* Likewise for struct iri definition */
+#include "iri.h"
-/* Like XDIGIT_TO_XCHAR, but produce a lower-case char. */
-#define XDIGIT_TO_xchar(x) (((x) < 10) ? ((x) + '0') : ((x) - 10 + 'a'))
+/* Useful macros used across the code: */
-#define ARRAY_SIZE(array) (sizeof (array) / sizeof (*(array)))
+/* The number of elements in an array. For example:
+ static char a[] = "foo"; -- countof(a) == 4 (note terminating \0)
+ int a[5] = {1, 2}; -- countof(a) == 5
+ char *a[] = { -- countof(a) == 3
+ "foo", "bar", "baz"
+ }; */
+#define countof(array) (sizeof (array) / sizeof ((array)[0]))
+
+/* Zero out a value. */
+#define xzero(x) memset (&(x), '\0', sizeof (x))
+
+/* Convert an ASCII hex digit to the corresponding number between 0
+ and 15. H should be a hexadecimal digit that satisfies isxdigit;
+ otherwise, the result is undefined. */
+#define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : c_toupper (h) - 'A' + 10)
+#define X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
+
+/* The reverse of the above: convert a number in the [0, 16) range to
+ the ASCII representation of the corresponding hexadecimal digit.
+ `+ 0' is there so you can't accidentally use it as an lvalue. */
+#define XNUM_TO_DIGIT(x) ("0123456789ABCDEF"[x] + 0)
+#define XNUM_TO_digit(x) ("0123456789abcdef"[x] + 0)
/* Copy the data delimited with BEG and END to alloca-allocated
- storage, and zero-terminate it. BEG and END are evaluated only
- once, in that order. */
-#define BOUNDED_TO_ALLOCA(beg, end, place) do { \
- const char *DTA_beg = (beg); \
- int DTA_len = (end) - DTA_beg; \
- place = alloca (DTA_len + 1); \
- memcpy (place, DTA_beg, DTA_len); \
- place[DTA_len] = '\0'; \
+ storage, and zero-terminate it. Arguments are evaluated only once,
+ in the order BEG, END, PLACE. */
+#define BOUNDED_TO_ALLOCA(beg, end, place) do { \
+ const char *BTA_beg = (beg); \
+ int BTA_len = (end) - BTA_beg; \
+ char **BTA_dest = &(place); \
+ *BTA_dest = alloca (BTA_len + 1); \
+ memcpy (*BTA_dest, BTA_beg, BTA_len); \
+ (*BTA_dest)[BTA_len] = '\0'; \
} while (0)
/* Return non-zero if string bounded between BEG and END is equal to
STRING_LITERAL. The comparison is case-sensitive. */
-#define BOUNDED_EQUAL(beg, end, string_literal) \
- ((end) - (beg) == sizeof (string_literal) - 1 \
- && !memcmp ((beg), (string_literal), \
- sizeof (string_literal) - 1))
+#define BOUNDED_EQUAL(beg, end, string_literal) \
+ ((end) - (beg) == sizeof (string_literal) - 1 \
+ && !memcmp (beg, string_literal, sizeof (string_literal) - 1))
/* The same as above, except the comparison is case-insensitive. */
-#define BOUNDED_EQUAL_NO_CASE(beg, end, string_literal) \
- ((end) - (beg) == sizeof (string_literal) - 1 \
- && !strncasecmp ((beg), (string_literal), \
- sizeof (string_literal) - 1))
-
-/* Note that this much more elegant definition cannot be used:
-
- #define STRDUP_ALLOCA(str) (strcpy ((char *)alloca (strlen (str) + 1), str))
-
- This is because some compilers don't handle alloca() as argument to
- function correctly. Gcc under Intel has been reported to offend in
- this case. */
-
-#define STRDUP_ALLOCA(ptr, str) do { \
- (ptr) = (char *)alloca (strlen (str) + 1); \
- strcpy (ptr, str); \
+#define BOUNDED_EQUAL_NO_CASE(beg, end, string_literal) \
+ ((end) - (beg) == sizeof (string_literal) - 1 \
+ && !strncasecmp (beg, string_literal, sizeof (string_literal) - 1))
+
+/* Like ptr=strdup(str), but allocates the space for PTR on the stack.
+ This cannot be an expression because this is not portable:
+ #define STRDUP_ALLOCA(str) (strcpy (alloca (strlen (str) + 1), str))
+ The problem is that some compilers can't handle alloca() being an
+ argument to a function. */
+
+#define STRDUP_ALLOCA(ptr, str) do { \
+ char **SA_dest = &(ptr); \
+ const char *SA_src = (str); \
+ *SA_dest = (char *)alloca (strlen (SA_src) + 1); \
+ strcpy (*SA_dest, SA_src); \
} while (0)
-#define ALLOCA_ARRAY(type, len) ((type *) alloca ((len) * sizeof (type)))
-
-#define XREALLOC_ARRAY(ptr, type, len) \
- ((void) (ptr = (type *) xrealloc (ptr, (len) * sizeof (type))))
-
/* Generally useful if you want to avoid arbitrary size limits but
don't need a full dynamic array. Assumes that BASEVAR points to a
malloced array of TYPE objects (or possibly a NULL pointer, if
will realloc BASEVAR as necessary so that it can hold at least
NEEDED_SIZE objects. The reallocing is done by doubling, which
ensures constant amortized time per element. */
-#define DO_REALLOC(basevar, sizevar, needed_size, type) do \
-{ \
- /* Avoid side-effectualness. */ \
- long do_realloc_needed_size = (needed_size); \
- long do_realloc_newsize = 0; \
- while ((sizevar) < (do_realloc_needed_size)) { \
- do_realloc_newsize = 2*(sizevar); \
- if (do_realloc_newsize < 32) \
- do_realloc_newsize = 32; \
- (sizevar) = do_realloc_newsize; \
- } \
- if (do_realloc_newsize) \
- XREALLOC_ARRAY (basevar, type, do_realloc_newsize); \
-} while (0)
-/* Use this for small stack-allocated memory chunks that might grow.
- The initial array is created using alloca(), and this macro
- requests it to grow. If the needed size is larger than the array,
- this macro will use malloc to allocate it to new size, and copy the
- old contents. After that, successive invocations behave just like
- DO_REALLOC. */
-#define DO_REALLOC_FROM_ALLOCA(basevar, sizevar, needed_size, allocap, type) do \
-{ \
- /* Avoid side-effectualness. */ \
- long do_realloc_needed_size = (needed_size); \
- long do_realloc_newsize = 0; \
- while ((sizevar) < (do_realloc_needed_size)) { \
- do_realloc_newsize = 2*(sizevar); \
- if (do_realloc_newsize < 16) \
- do_realloc_newsize = 16; \
- (sizevar) = do_realloc_newsize; \
- } \
- if (do_realloc_newsize) \
- { \
- if (!allocap) \
- XREALLOC_ARRAY (basevar, type, do_realloc_newsize); \
- else \
- { \
- void *drfa_new_basevar = xmalloc (do_realloc_newsize); \
- memcpy (drfa_new_basevar, basevar, sizevar); \
- (basevar) = drfa_new_basevar; \
- allocap = 0; \
- } \
- } \
+#define DO_REALLOC(basevar, sizevar, needed_size, type) do { \
+ long DR_needed_size = (needed_size); \
+ long DR_newsize = 0; \
+ while ((sizevar) < (DR_needed_size)) { \
+ DR_newsize = sizevar << 1; \
+ if (DR_newsize < 16) \
+ DR_newsize = 16; \
+ (sizevar) = DR_newsize; \
+ } \
+ if (DR_newsize) \
+ basevar = xrealloc (basevar, DR_newsize * sizeof (type)); \
} while (0)
-/* Free FOO if it is non-NULL. */
-#define FREE_MAYBE(foo) do { if (foo) xfree (foo); } while (0)
+/* Used to print pointers (usually for debugging). Print pointers
+ using printf ("0x%0*lx", PTR_FORMAT (p)). (%p is too unpredictable;
+ some implementations prepend 0x, while some don't, and most don't
+ 0-pad the address.) */
+#define PTR_FORMAT(p) (int) (2 * sizeof (void *)), (unsigned long) (p)
-/* #### Hack: OPTIONS_DEFINED_HERE is defined in main.c. */
-/* [Is this weird hack really necessary on any compilers? No ANSI C compiler
- should complain about "extern const char *exec_name;" followed by
- "const char *exec_name;". Are we doing this for K&R compilers, or...??
- -- Dan Harkless <wget@harkless.org>] */
-#ifndef OPTIONS_DEFINED_HERE
-extern const char *exec_name;
-#endif
+/* Find the maximum buffer length needed to print an integer of type `x'
+ in base 10. 24082 / 10000 = 8*log_{10}(2). */
+#define MAX_INT_TO_STRING_LEN(x) ((sizeof(x) * 24082 / 10000) + 2)
+extern const char *exec_name;
\f
/* Document type ("dt") flags */
enum
{
- TEXTHTML = 0x0001, /* document is of type text/html */
- RETROKF = 0x0002, /* retrieval was OK */
- HEAD_ONLY = 0x0004, /* only send the HEAD request */
- SEND_NOCACHE = 0x0008, /* send Pragma: no-cache directive */
- ACCEPTRANGES = 0x0010, /* Accept-ranges header was found */
- ADDED_HTML_EXTENSION = 0x0020 /* added ".html" extension due to -E */
+ TEXTHTML = 0x0001, /* document is of type text/html
+ or application/xhtml+xml */
+ RETROKF = 0x0002, /* retrieval was OK */
+ HEAD_ONLY = 0x0004, /* only send the HEAD request */
+ SEND_NOCACHE = 0x0008, /* send Pragma: no-cache directive */
+ ACCEPTRANGES = 0x0010, /* Accept-ranges header was found */
+ ADDED_HTML_EXTENSION = 0x0020, /* added ".html" extension due to -E */
+ TEXTCSS = 0x0040 /* document is of type text/css */
};
-/* Universal error type -- used almost everywhere.
- This is, of course, utter crock. */
+/* Universal error type -- used almost everywhere. Error reporting of
+ this detail is not generally used or needed and should be
+ simplified. */
typedef enum
{
+ /* 0 */
NOCONERROR, HOSTERR, CONSOCKERR, CONERROR, CONSSLERR,
- CONREFUSED, NEWLOCATION, NOTENOUGHMEM, CONPORTERR,
- BINDERR, BINDOK, LISTENERR, ACCEPTERR, ACCEPTOK,
- CONCLOSED, FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR,
- FTPNSFOD, FTPRETROK, FTPUNKNOWNTYPE, FTPRERR,
- FTPREXC, FTPSRVERR, FTPRETRINT, FTPRESTFAIL, URLHTTPS,
- URLOK, URLHTTP, URLFTP, URLFILE, URLUNKNOWN, URLBADPORT,
- URLBADHOST, FOPENERR, FWRITEERR, HOK, HLEXC, HEOF,
- HERR, RETROK, RECLEVELEXC, FTPACCDENIED, WRONGCODE,
- FTPINVPASV, FTPNOPASV,
- CONTNOTSUPPORTED, RETRFINISHED, READERR, TRYLIMEXC,
- URLBADPATTERN, FILEBADFILE, RANGEERR, RETRBADPATTERN,
- RETNOTSUP, ROBOTSOK, NOROBOTS, PROXERR, AUTHFAILED,
- QUOTEXC, WRITEFAILED,
- SSLERRCERTFILE,SSLERRCERTKEY,SSLERRCTXCREATE
+ CONIMPOSSIBLE, NEWLOCATION, NOTENOUGHMEM /* ! */,
+ CONPORTERR /* ! */, CONCLOSED /* ! */,
+ /* 10 */
+ FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR, FTPSYSERR,
+ FTPNSFOD, FTPRETROK /* ! */, FTPUNKNOWNTYPE, FTPRERR, FTPREXC /* ! */,
+ /* 20 */
+ FTPSRVERR, FTPRETRINT, FTPRESTFAIL, URLERROR, FOPENERR,
+ FOPEN_EXCL_ERR, FWRITEERR, HOK /* ! */, HLEXC /* ! */, HEOF,
+ /* 30 */
+ HERR, RETROK, RECLEVELEXC, FTPACCDENIED /* ! */, WRONGCODE,
+ FTPINVPASV, FTPNOPASV, CONTNOTSUPPORTED, RETRUNNEEDED, RETRFINISHED,
+ /* 40 */
+ READERR, TRYLIMEXC, URLBADPATTERN /* ! */, FILEBADFILE /* ! */, RANGEERR,
+ RETRBADPATTERN, RETNOTSUP /* ! */, ROBOTSOK /* ! */, NOROBOTS /* ! */,
+ PROXERR,
+ /* 50 */
+ AUTHFAILED, QUOTEXC, WRITEFAILED, SSLINITFAILED, VERIFCERTERR,
+ UNLINKERR, NEWLOCATION_KEEP_POST, CLOSEFAILED, ATTRMISSING, UNKNOWNATTR,
+
+ WARC_ERR, WARC_TMP_FOPENERR, WARC_TMP_FWRITEERR
} uerr_t;
-typedef unsigned char boolean;
-#ifndef FALSE
-#define FALSE 0
-#endif
-#ifndef TRUE
-#define TRUE 1
-#endif
-
-/* So we can say strcmp(a, b) == EQ rather than strcmp(a, b) == 0 or
- the really awful !strcmp(a, b). */
-#define EQ 0
-
-/* For most options, 0 means no limits, but with -p in the picture, that causes
- a problem on the maximum recursion depth variable. To retain backwards
- compatibility we allow users to consider "0" to be synonymous with "inf" for
- -l, but internally infinite recursion is specified by -1 and 0 means to only
- retrieve the requisites of a single document. */
-#define INFINITE_RECURSION -1
+/* 2005-02-19 SMS.
+ Select an appropriate "orig" suffix and a separator character for
+ adding a unique suffix to a file name.
+
+ A VMS ODS2 file system can not tolerate multiple dots. An ODS5 file
+ system can, but even there not all dots are equal, and heroic effort
+ would be needed to get ".html^.orig" rather than (the less desirable)
+ "^.html.orig". It's more satisfactory always to use "_orig" on VMS
+ (rather than including "vms.h", testing "ods5_dest", and acting
+ accordingly).
+
+ Note that code in various places assumes that this string is five
+ characters long.
+*/
+# ifdef __VMS
+# define ORIG_SFX "_orig"
+# else /* def __VMS */
+# define ORIG_SFX ".orig"
+# endif /* def __VMS [else] */
+
+/* ".NNN" unique-ifying suffix separator character for unique_name() in
+ url.c (and anywhere else). Note that on VMS, the file system's
+ version numbers solve the problem that unique_name() is designed to
+ handle, obviating this whole exercise. Other systems may specify a
+ character different from "." here, if desired.
+*/
+# ifndef __VMS
+# define UNIQ_SEP '.'
+# endif /* ndef __VMS */
#endif /* WGET_H */