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