sjero.net Git - wget/blob - src/wget.h

   1 /* Miscellaneous declarations.
   2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003,
   3    2004, 2005, 2006, 2007 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Wget.
   6
   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.
  11
  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.
  16
  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/>.
  19
  20 In addition, as a special exception, the Free Software Foundation
  21 gives permission to link the code of its release of Wget with the
  22 OpenSSL project's "OpenSSL" library (or with modified versions of it
  23 that use the same license as the "OpenSSL" library), and distribute
  24 the linked executables.  You must obey the GNU General Public License
  25 in all respects for all of the code used other than "OpenSSL".  If you
  26 modify this file, you may extend this exception to your version of the
  27 file, but you are not obligated to do so.  If you do not wish to do
  28 so, delete this exception statement from your version.  */
  29
  30 /* This file contains declarations that are universally useful and
  31    those that don't fit elsewhere.  It also includes sysdep.h which
  32    includes some often-needed system includes, like the obnoxious
  33    <time.h> inclusion.  */
  34
  35 #ifndef WGET_H
  36 #define WGET_H
  37
  38 /* Disable assertions when debug support is not compiled in. */
  39 #ifndef ENABLE_DEBUG
  40 # define NDEBUG
  41 #endif
  42
  43 /* Is OpenSSL or GNUTLS available? */
  44 #if defined HAVE_LIBSSL || defined HAVE_LIBGNUTLS
  45 # define HAVE_SSL
  46 #endif
  47
  48 /* `gettext (FOO)' is long to write, so we use `_(FOO)'.  If NLS is
  49    unavailable, _(STRING) simply returns STRING.  */
  50 #ifdef HAVE_NLS
  51 # define _(string) gettext (string)
  52 # ifdef HAVE_LIBINTL_H
  53 #  include <libintl.h>
  54 # else  /* not HAVE_LIBINTL_H */
  55    const char *gettext ();
  56 # endif /* not HAVE_LIBINTL_H */
  57 #else  /* not HAVE_NLS */
  58 # define _(string) (string)
  59 # define ngettext(sing, plur, num)  ((num) == 1 ? (sing) : (plur))
  60 #endif /* not HAVE_NLS */
  61
  62 /* A pseudo function call that serves as a marker for the automated
  63    extraction of messages, but does not call gettext().  The run-time
  64    translation is done at a different place in the code.  The purpose
  65    of the N_("...") call is to make the message snarfer aware that the
  66    "..." string needs to be translated.  STRING should be a string
  67    literal.  Concatenated strings and other string expressions won't
  68    work.  The macro's expansion is not parenthesized, so that it is
  69    suitable as initializer for static 'char[]' or 'const char[]'
  70    variables.  -- explanation partly taken from GNU make.  */
  71 #define N_(string) string
  72
  73 /* I18N NOTE: You will notice that none of the DEBUGP messages are
  74    marked as translatable.  This is intentional, for a few reasons:
  75
  76    1) The debug messages are not meant for the users to look at, but
  77    for the developers; as such, they should be considered more like
  78    source comments than real program output.
  79
  80    2) The messages are numerous, and yet they are random and frivolous
  81    ("double yuck!" and such).  There would be a lot of work with no
  82    gain.
  83
  84    3) Finally, the debug messages are meant to be a clue for me to
  85    debug problems with Wget.  If I get them in a language I don't
  86    understand, debugging will become a new challenge of its own!  */
  87
  88
  89 /* Include these, so random files need not include them.  */
  90 #include "sysdep.h"
  91 /* locale independent replacement for ctype.h */
  92 #include "safe-ctype.h"
  93
  94 /* Conditionalize the use of GCC's __attribute__((format)) and
  95    __builtin_expect features using macros.  */
  96
  97 #if defined(__GNUC__) && __GNUC__ >= 3
  98 # define GCC_FORMAT_ATTR(a, b) __attribute__ ((format (printf, a, b)))
  99 # define LIKELY(exp)   __builtin_expect (!!(exp), 1)
 100 # define UNLIKELY(exp) __builtin_expect ((exp), 0)
 101 #else
 102 # define GCC_FORMAT_ATTR(a, b)
 103 # define LIKELY(exp)   (exp)
 104 # define UNLIKELY(exp) (exp)
 105 #endif
 106
 107 /* Execute the following statement if debugging is both enabled at
 108    compile-time and requested at run-time; a no-op otherwise.  */
 109
 110 #ifdef ENABLE_DEBUG
 111 # define IF_DEBUG if (UNLIKELY (opt.debug))
 112 #else
 113 # define IF_DEBUG if (0)
 114 #endif
 115
 116 /* Print ARGS if debugging is enabled and requested, otherwise do
 117    nothing.  This must be called with an extra level of parentheses
 118    because it's not possible to pass a variable number of arguments to
 119    a macro (in portable C89).  ARGS are like arguments to printf.  */
 120
 121 #define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0)
 122
 123 /* Pick an integer type large enough for file sizes, content lengths,
 124    and such.  Because today's files can be very large, it should be a
 125    signed integer at least 64 bits wide.  This can't be typedeffed to
 126    off_t because: a) off_t is always 32-bit on Windows, and b) we
 127    don't necessarily want to tie having a 64-bit type for internal
 128    calculations to having LFS support.  */
 129
 130 #ifdef WINDOWS
 131   /* nothing to do, see mswindows.h */
 132 #elif SIZEOF_LONG >= 8
 133   /* long is large enough, so use it. */
 134   typedef long wgint;
 135 # define SIZEOF_WGINT SIZEOF_LONG
 136 #elif SIZEOF_LONG_LONG >= 8
 137   /* long long is large enough and available, use that */
 138   typedef long long wgint;
 139 # define SIZEOF_WGINT SIZEOF_LONG_LONG
 140 #elif HAVE_INT64_T
 141   typedef int64_t wgint;
 142 # define SIZEOF_WGINT 8
 143 #elif SIZEOF_OFF_T >= 8
 144   /* In case off_t is typedeffed to a large non-standard type that our
 145      tests don't find. */
 146   typedef off_t wgint;
 147 # define SIZEOF_WGINT SIZEOF_OFF_T
 148 #else
 149   /* Fall back to using long, which is always available and in most
 150      cases large enough. */
 151 typedef long off_t;
 152 # define SIZEOF_WGINT SIZEOF_LONG
 153 #endif
 154
 155 /* Pick a strtol-compatible function that will work with wgint.  The
 156    choices are strtol, strtoll, or our own implementation of strtoll
 157    in cmpt.c, activated with NEED_STRTOLL.  */
 158
 159 #ifdef WINDOWS
 160   /* nothing to do, see mswindows.h */
 161 #elif SIZEOF_WGINT == SIZEOF_LONG
 162 # define str_to_wgint strtol
 163 #elif SIZEOF_WGINT == SIZEOF_LONG_LONG
 164 # define str_to_wgint strtoll
 165 # ifndef HAVE_STRTOLL
 166 #  define NEED_STRTOLL
 167 #  define strtoll_type long long
 168 # endif
 169 #else
 170   /* wgint has a strange size; synthesize strtoll and use it. */
 171 # define str_to_wgint strtoll
 172 # define NEED_STRTOLL
 173 # define strtoll_type wgint
 174 #endif
 175
 176 #define WGINT_MAX TYPE_MAXIMUM (wgint)
 177
 178 /* Declare our strtoll replacement. */
 179 #ifdef NEED_STRTOLL
 180 strtoll_type strtoll (const char *, char **, int);
 181 #endif
 182
 183 /* Now define a large numeric type useful for storing sizes of *sums*
 184    of downloads, such as the value of the --quota option.  This should
 185    be a type able to hold 2G+ values even on systems without large
 186    file support.  (It is useful to limit Wget's download quota to say
 187    10G even if a single file cannot be that large.)
 188
 189    To make sure we get the largest size possible, we use `double' on
 190    systems without a 64-bit integral type.  (Since it is used in very
 191    few places in Wget, this is acceptable.)  */
 192
 193 #if SIZEOF_WGINT >= 8
 194 /* just use wgint */
 195 typedef wgint SUM_SIZE_INT;
 196 #else
 197 /* On systems without LFS, use double, which buys us integers up to 2^53. */
 198 typedef double SUM_SIZE_INT;
 199 #endif
 200
 201 #include "options.h"
 202
 203 /* Everything uses this, so include them here directly.  */
 204 #include "xmalloc.h"
 205
 206 /* Likewise for logging functions.  */
 207 #include "log.h"
 208 \f
 209 /* Useful macros used across the code: */
 210
 211 /* The number of elements in an array.  For example:
 212    static char a[] = "foo";     -- countof(a) == 4 (note terminating \0)
 213    int a[5] = {1, 2};           -- countof(a) == 5
 214    char *a[] = {                -- countof(a) == 3
 215      "foo", "bar", "baz"
 216    }; */
 217 #define countof(array) (sizeof (array) / sizeof ((array)[0]))
 218
 219 /* Zero out a value.  */
 220 #define xzero(x) memset (&(x), '\0', sizeof (x))
 221
 222 /* Convert an ASCII hex digit to the corresponding number between 0
 223    and 15.  H should be a hexadecimal digit that satisfies isxdigit;
 224    otherwise, the result is undefined.  */
 225 #define XDIGIT_TO_NUM(h) ((h) < 'A' ? (h) - '0' : TOUPPER (h) - 'A' + 10)
 226 #define X2DIGITS_TO_NUM(h1, h2) ((XDIGIT_TO_NUM (h1) << 4) + XDIGIT_TO_NUM (h2))
 227
 228 /* The reverse of the above: convert a number in the [0, 16) range to
 229    the ASCII representation of the corresponding hexadecimal digit.
 230    `+ 0' is there so you can't accidentally use it as an lvalue.  */
 231 #define XNUM_TO_DIGIT(x) ("0123456789ABCDEF"[x] + 0)
 232 #define XNUM_TO_digit(x) ("0123456789abcdef"[x] + 0)
 233
 234 /* Copy the data delimited with BEG and END to alloca-allocated
 235    storage, and zero-terminate it.  Arguments are evaluated only once,
 236    in the order BEG, END, PLACE.  */
 237 #define BOUNDED_TO_ALLOCA(beg, end, place) do { \
 238   const char *BTA_beg = (beg);                  \
 239   int BTA_len = (end) - BTA_beg;                \
 240   char **BTA_dest = &(place);                   \
 241   *BTA_dest = alloca (BTA_len + 1);             \
 242   memcpy (*BTA_dest, BTA_beg, BTA_len);         \
 243   (*BTA_dest)[BTA_len] = '\0';                  \
 244 } while (0)
 245
 246 /* Return non-zero if string bounded between BEG and END is equal to
 247    STRING_LITERAL.  The comparison is case-sensitive.  */
 248 #define BOUNDED_EQUAL(beg, end, string_literal)                         \
 249   ((end) - (beg) == sizeof (string_literal) - 1                         \
 250    && !memcmp (beg, string_literal, sizeof (string_literal) - 1))
 251
 252 /* The same as above, except the comparison is case-insensitive. */
 253 #define BOUNDED_EQUAL_NO_CASE(beg, end, string_literal)                 \
 254   ((end) - (beg) == sizeof (string_literal) - 1                         \
 255    && !strncasecmp (beg, string_literal, sizeof (string_literal) - 1))
 256
 257 /* Like ptr=strdup(str), but allocates the space for PTR on the stack.
 258    This cannot be an expression because this is not portable:
 259      #define STRDUP_ALLOCA(str) (strcpy (alloca (strlen (str) + 1), str))
 260    The problem is that some compilers can't handle alloca() being an
 261    argument to a function.  */
 262
 263 #define STRDUP_ALLOCA(ptr, str) do {                    \
 264   char **SA_dest = &(ptr);                              \
 265   const char *SA_src = (str);                           \
 266   *SA_dest = (char *)alloca (strlen (SA_src) + 1);      \
 267   strcpy (*SA_dest, SA_src);                            \
 268 } while (0)
 269
 270 /* Generally useful if you want to avoid arbitrary size limits but
 271    don't need a full dynamic array.  Assumes that BASEVAR points to a
 272    malloced array of TYPE objects (or possibly a NULL pointer, if
 273    SIZEVAR is 0), with the total size stored in SIZEVAR.  This macro
 274    will realloc BASEVAR as necessary so that it can hold at least
 275    NEEDED_SIZE objects.  The reallocing is done by doubling, which
 276    ensures constant amortized time per element.  */
 277
 278 #define DO_REALLOC(basevar, sizevar, needed_size, type) do {            \
 279   long DR_needed_size = (needed_size);                                  \
 280   long DR_newsize = 0;                                                  \
 281   while ((sizevar) < (DR_needed_size)) {                                \
 282     DR_newsize = sizevar << 1;                                          \
 283     if (DR_newsize < 16)                                                \
 284       DR_newsize = 16;                                                  \
 285     (sizevar) = DR_newsize;                                             \
 286   }                                                                     \
 287   if (DR_newsize)                                                       \
 288     basevar = xrealloc (basevar, DR_newsize * sizeof (type));           \
 289 } while (0)
 290
 291 /* Used to print pointers (usually for debugging).  Print pointers
 292    using printf ("0x%0*lx", PTR_FORMAT (p)).  (%p is too unpredictable;
 293    some implementations prepend 0x, while some don't, and most don't
 294    0-pad the address.)  */
 295 #define PTR_FORMAT(p) (int) (2 * sizeof (void *)), (unsigned long) (p)
 296
 297 extern const char *exec_name;
 298 \f
 299 /* Document type ("dt") flags */
 300 enum
 301 {
 302   TEXTHTML             = 0x0001,        /* document is of type text/html
 303                                            or application/xhtml+xml */
 304   RETROKF              = 0x0002,        /* retrieval was OK */
 305   HEAD_ONLY            = 0x0004,        /* only send the HEAD request */
 306   SEND_NOCACHE         = 0x0008,        /* send Pragma: no-cache directive */
 307   ACCEPTRANGES         = 0x0010,        /* Accept-ranges header was found */
 308   ADDED_HTML_EXTENSION = 0x0020         /* added ".html" extension due to -E */
 309 };
 310
 311 /* Universal error type -- used almost everywhere.  Error reporting of
 312    this detail is not generally used or needed and should be
 313    simplified.  */
 314 typedef enum
 315 {
 316   /*  0  */
 317   NOCONERROR, HOSTERR, CONSOCKERR, CONERROR, CONSSLERR,
 318   CONIMPOSSIBLE, NEWLOCATION, NOTENOUGHMEM, CONPORTERR, CONCLOSED,
 319   /* 10  */
 320   FTPOK, FTPLOGINC, FTPLOGREFUSED, FTPPORTERR, FTPSYSERR,
 321   FTPNSFOD, FTPRETROK, FTPUNKNOWNTYPE, FTPRERR, FTPREXC,
 322   /* 20  */
 323   FTPSRVERR, FTPRETRINT, FTPRESTFAIL, URLERROR, FOPENERR,
 324   FOPEN_EXCL_ERR, FWRITEERR, HOK, HLEXC, HEOF,
 325   /* 30  */
 326   HERR, RETROK, RECLEVELEXC, FTPACCDENIED, WRONGCODE,
 327   FTPINVPASV, FTPNOPASV, CONTNOTSUPPORTED, RETRUNNEEDED, RETRFINISHED,
 328   /* 40  */
 329   READERR, TRYLIMEXC, URLBADPATTERN, FILEBADFILE, RANGEERR,
 330   RETRBADPATTERN, RETNOTSUP, ROBOTSOK, NOROBOTS, PROXERR,
 331   /* 50  */
 332   AUTHFAILED, QUOTEXC, WRITEFAILED, SSLINITFAILED
 333 } uerr_t;
 334
 335 #endif /* WGET_H */