src/gpg-error.h

   1 /* gpg-error.h - Public interface to libgpg-error.               -*- c -*-
   2    Copyright (C) 2003, 2004, 2010, 2013, 2014 g10 Code GmbH
   3
   4    This file is part of libgpg-error.
   5
   6    libgpg-error is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public License
   8    as published by the Free Software Foundation; either version 2.1 of
   9    the License, or (at your option) any later version.
  10
  11    libgpg-error is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this program; if not, see <http://www.gnu.org/licenses/>.
  18
  19    Do not edit.  Generated from gpg-error.h.in for x86_64-unknown-linux-gnu.
  20  */
  21
  22
  23 #ifndef GPG_ERROR_H
  24 #define GPG_ERROR_H     1
  25
  26 #include <stddef.h>
  27
  28 #ifdef __GNUC__
  29 #define GPG_ERR_INLINE __inline__
  30 #elif _MSC_VER >= 1300
  31 #define GPG_ERR_INLINE __inline
  32 #elif __STDC_VERSION__ >= 199901L
  33 #define GPG_ERR_INLINE inline
  34 #else
  35 #ifndef GPG_ERR_INLINE
  36 #define GPG_ERR_INLINE
  37 #endif
  38 #endif
  39
  40
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #if 0 /* just to make Emacs auto-indent happy */
  44 }
  45 #endif
  46 #endif /* __cplusplus */
  47
  48 /* The GnuPG project consists of many components.  Error codes are
  49    exchanged between all components.  The common error codes and their
  50    user-presentable descriptions are kept into a shared library to
  51    allow adding new error codes and components without recompiling any
  52    of the other components.  The interface will not change in a
  53    backward incompatible way.
  54
  55    An error code together with an error source build up an error
  56    value.  As the error value is been passed from one component to
  57    another, it preserver the information about the source and nature
  58    of the error.
  59
  60    A component of the GnuPG project can define the following macros to
  61    tune the behaviour of the library:
  62
  63    GPG_ERR_SOURCE_DEFAULT: Define to an error source of type
  64    gpg_err_source_t to make that source the default for gpg_error().
  65    Otherwise GPG_ERR_SOURCE_UNKNOWN is used as default.
  66
  67    GPG_ERR_ENABLE_GETTEXT_MACROS: Define to provide macros to map the
  68    internal gettext API to standard names.  This has only an effect on
  69    Windows platforms.
  70
  71    In addition to the error codes, Libgpg-error also provides a set of
  72    functions used by most GnuPG components.  */
  73
  74 \f
  75 /* The error source type gpg_err_source_t.
  76
  77    Where as the Poo out of a welle small
  78    Taketh his firste springing and his sours.
  79                                         --Chaucer.  */
  80
  81 /* Only use free slots, never change or reorder the existing
  82    entries.  */
  83 typedef enum
  84   {
  85     GPG_ERR_SOURCE_UNKNOWN = 0,
  86     GPG_ERR_SOURCE_GCRYPT = 1,
  87     GPG_ERR_SOURCE_GPG = 2,
  88     GPG_ERR_SOURCE_GPGSM = 3,
  89     GPG_ERR_SOURCE_GPGAGENT = 4,
  90     GPG_ERR_SOURCE_PINENTRY = 5,
  91     GPG_ERR_SOURCE_SCD = 6,
  92     GPG_ERR_SOURCE_GPGME = 7,
  93     GPG_ERR_SOURCE_KEYBOX = 8,
  94     GPG_ERR_SOURCE_KSBA = 9,
  95     GPG_ERR_SOURCE_DIRMNGR = 10,
  96     GPG_ERR_SOURCE_GSTI = 11,
  97     GPG_ERR_SOURCE_GPA = 12,
  98     GPG_ERR_SOURCE_KLEO = 13,
  99     GPG_ERR_SOURCE_G13 = 14,
 100     GPG_ERR_SOURCE_ASSUAN = 15,
 101     GPG_ERR_SOURCE_ANY = 31,
 102     GPG_ERR_SOURCE_USER_1 = 32,
 103     GPG_ERR_SOURCE_USER_2 = 33,
 104     GPG_ERR_SOURCE_USER_3 = 34,
 105     GPG_ERR_SOURCE_USER_4 = 35,
 106
 107     /* This is one more than the largest allowed entry.  */
 108     GPG_ERR_SOURCE_DIM = 128
 109   } gpg_err_source_t;
 110
 111 \f
 112 /* The error code type gpg_err_code_t.  */
 113
 114 /* Only use free slots, never change or reorder the existing
 115    entries.  */
 116 typedef enum
 117   {
 118     GPG_ERR_NO_ERROR = 0,
 119     GPG_ERR_GENERAL = 1,
 120     GPG_ERR_UNKNOWN_PACKET = 2,
 121     GPG_ERR_UNKNOWN_VERSION = 3,
 122     GPG_ERR_PUBKEY_ALGO = 4,
 123     GPG_ERR_DIGEST_ALGO = 5,
 124     GPG_ERR_BAD_PUBKEY = 6,
 125     GPG_ERR_BAD_SECKEY = 7,
 126     GPG_ERR_BAD_SIGNATURE = 8,
 127     GPG_ERR_NO_PUBKEY = 9,
 128     GPG_ERR_CHECKSUM = 10,
 129     GPG_ERR_BAD_PASSPHRASE = 11,
 130     GPG_ERR_CIPHER_ALGO = 12,
 131     GPG_ERR_KEYRING_OPEN = 13,
 132     GPG_ERR_INV_PACKET = 14,
 133     GPG_ERR_INV_ARMOR = 15,
 134     GPG_ERR_NO_USER_ID = 16,
 135     GPG_ERR_NO_SECKEY = 17,
 136     GPG_ERR_WRONG_SECKEY = 18,
 137     GPG_ERR_BAD_KEY = 19,
 138     GPG_ERR_COMPR_ALGO = 20,
 139     GPG_ERR_NO_PRIME = 21,
 140     GPG_ERR_NO_ENCODING_METHOD = 22,
 141     GPG_ERR_NO_ENCRYPTION_SCHEME = 23,
 142     GPG_ERR_NO_SIGNATURE_SCHEME = 24,
 143     GPG_ERR_INV_ATTR = 25,
 144     GPG_ERR_NO_VALUE = 26,
 145     GPG_ERR_NOT_FOUND = 27,
 146     GPG_ERR_VALUE_NOT_FOUND = 28,
 147     GPG_ERR_SYNTAX = 29,
 148     GPG_ERR_BAD_MPI = 30,
 149     GPG_ERR_INV_PASSPHRASE = 31,
 150     GPG_ERR_SIG_CLASS = 32,
 151     GPG_ERR_RESOURCE_LIMIT = 33,
 152     GPG_ERR_INV_KEYRING = 34,
 153     GPG_ERR_TRUSTDB = 35,
 154     GPG_ERR_BAD_CERT = 36,
 155     GPG_ERR_INV_USER_ID = 37,
 156     GPG_ERR_UNEXPECTED = 38,
 157     GPG_ERR_TIME_CONFLICT = 39,
 158     GPG_ERR_KEYSERVER = 40,
 159     GPG_ERR_WRONG_PUBKEY_ALGO = 41,
 160     GPG_ERR_TRIBUTE_TO_D_A = 42,
 161     GPG_ERR_WEAK_KEY = 43,
 162     GPG_ERR_INV_KEYLEN = 44,
 163     GPG_ERR_INV_ARG = 45,
 164     GPG_ERR_BAD_URI = 46,
 165     GPG_ERR_INV_URI = 47,
 166     GPG_ERR_NETWORK = 48,
 167     GPG_ERR_UNKNOWN_HOST = 49,
 168     GPG_ERR_SELFTEST_FAILED = 50,
 169     GPG_ERR_NOT_ENCRYPTED = 51,
 170     GPG_ERR_NOT_PROCESSED = 52,
 171     GPG_ERR_UNUSABLE_PUBKEY = 53,
 172     GPG_ERR_UNUSABLE_SECKEY = 54,
 173     GPG_ERR_INV_VALUE = 55,
 174     GPG_ERR_BAD_CERT_CHAIN = 56,
 175     GPG_ERR_MISSING_CERT = 57,
 176     GPG_ERR_NO_DATA = 58,
 177     GPG_ERR_BUG = 59,
 178     GPG_ERR_NOT_SUPPORTED = 60,
 179     GPG_ERR_INV_OP = 61,
 180     GPG_ERR_TIMEOUT = 62,
 181     GPG_ERR_INTERNAL = 63,
 182     GPG_ERR_EOF_GCRYPT = 64,
 183     GPG_ERR_INV_OBJ = 65,
 184     GPG_ERR_TOO_SHORT = 66,
 185     GPG_ERR_TOO_LARGE = 67,
 186     GPG_ERR_NO_OBJ = 68,
 187     GPG_ERR_NOT_IMPLEMENTED = 69,
 188     GPG_ERR_CONFLICT = 70,
 189     GPG_ERR_INV_CIPHER_MODE = 71,
 190     GPG_ERR_INV_FLAG = 72,
 191     GPG_ERR_INV_HANDLE = 73,
 192     GPG_ERR_TRUNCATED = 74,
 193     GPG_ERR_INCOMPLETE_LINE = 75,
 194     GPG_ERR_INV_RESPONSE = 76,
 195     GPG_ERR_NO_AGENT = 77,
 196     GPG_ERR_AGENT = 78,
 197     GPG_ERR_INV_DATA = 79,
 198     GPG_ERR_ASSUAN_SERVER_FAULT = 80,
 199     GPG_ERR_ASSUAN = 81,
 200     GPG_ERR_INV_SESSION_KEY = 82,
 201     GPG_ERR_INV_SEXP = 83,
 202     GPG_ERR_UNSUPPORTED_ALGORITHM = 84,
 203     GPG_ERR_NO_PIN_ENTRY = 85,
 204     GPG_ERR_PIN_ENTRY = 86,
 205     GPG_ERR_BAD_PIN = 87,
 206     GPG_ERR_INV_NAME = 88,
 207     GPG_ERR_BAD_DATA = 89,
 208     GPG_ERR_INV_PARAMETER = 90,
 209     GPG_ERR_WRONG_CARD = 91,
 210     GPG_ERR_NO_DIRMNGR = 92,
 211     GPG_ERR_DIRMNGR = 93,
 212     GPG_ERR_CERT_REVOKED = 94,
 213     GPG_ERR_NO_CRL_KNOWN = 95,
 214     GPG_ERR_CRL_TOO_OLD = 96,
 215     GPG_ERR_LINE_TOO_LONG = 97,
 216     GPG_ERR_NOT_TRUSTED = 98,
 217     GPG_ERR_CANCELED = 99,
 218     GPG_ERR_BAD_CA_CERT = 100,
 219     GPG_ERR_CERT_EXPIRED = 101,
 220     GPG_ERR_CERT_TOO_YOUNG = 102,
 221     GPG_ERR_UNSUPPORTED_CERT = 103,
 222     GPG_ERR_UNKNOWN_SEXP = 104,
 223     GPG_ERR_UNSUPPORTED_PROTECTION = 105,
 224     GPG_ERR_CORRUPTED_PROTECTION = 106,
 225     GPG_ERR_AMBIGUOUS_NAME = 107,
 226     GPG_ERR_CARD = 108,
 227     GPG_ERR_CARD_RESET = 109,
 228     GPG_ERR_CARD_REMOVED = 110,
 229     GPG_ERR_INV_CARD = 111,
 230     GPG_ERR_CARD_NOT_PRESENT = 112,
 231     GPG_ERR_NO_PKCS15_APP = 113,
 232     GPG_ERR_NOT_CONFIRMED = 114,
 233     GPG_ERR_CONFIGURATION = 115,
 234     GPG_ERR_NO_POLICY_MATCH = 116,
 235     GPG_ERR_INV_INDEX = 117,
 236     GPG_ERR_INV_ID = 118,
 237     GPG_ERR_NO_SCDAEMON = 119,
 238     GPG_ERR_SCDAEMON = 120,
 239     GPG_ERR_UNSUPPORTED_PROTOCOL = 121,
 240     GPG_ERR_BAD_PIN_METHOD = 122,
 241     GPG_ERR_CARD_NOT_INITIALIZED = 123,
 242     GPG_ERR_UNSUPPORTED_OPERATION = 124,
 243     GPG_ERR_WRONG_KEY_USAGE = 125,
 244     GPG_ERR_NOTHING_FOUND = 126,
 245     GPG_ERR_WRONG_BLOB_TYPE = 127,
 246     GPG_ERR_MISSING_VALUE = 128,
 247     GPG_ERR_HARDWARE = 129,
 248     GPG_ERR_PIN_BLOCKED = 130,
 249     GPG_ERR_USE_CONDITIONS = 131,
 250     GPG_ERR_PIN_NOT_SYNCED = 132,
 251     GPG_ERR_INV_CRL = 133,
 252     GPG_ERR_BAD_BER = 134,
 253     GPG_ERR_INV_BER = 135,
 254     GPG_ERR_ELEMENT_NOT_FOUND = 136,
 255     GPG_ERR_IDENTIFIER_NOT_FOUND = 137,
 256     GPG_ERR_INV_TAG = 138,
 257     GPG_ERR_INV_LENGTH = 139,
 258     GPG_ERR_INV_KEYINFO = 140,
 259     GPG_ERR_UNEXPECTED_TAG = 141,
 260     GPG_ERR_NOT_DER_ENCODED = 142,
 261     GPG_ERR_NO_CMS_OBJ = 143,
 262     GPG_ERR_INV_CMS_OBJ = 144,
 263     GPG_ERR_UNKNOWN_CMS_OBJ = 145,
 264     GPG_ERR_UNSUPPORTED_CMS_OBJ = 146,
 265     GPG_ERR_UNSUPPORTED_ENCODING = 147,
 266     GPG_ERR_UNSUPPORTED_CMS_VERSION = 148,
 267     GPG_ERR_UNKNOWN_ALGORITHM = 149,
 268     GPG_ERR_INV_ENGINE = 150,
 269     GPG_ERR_PUBKEY_NOT_TRUSTED = 151,
 270     GPG_ERR_DECRYPT_FAILED = 152,
 271     GPG_ERR_KEY_EXPIRED = 153,
 272     GPG_ERR_SIG_EXPIRED = 154,
 273     GPG_ERR_ENCODING_PROBLEM = 155,
 274     GPG_ERR_INV_STATE = 156,
 275     GPG_ERR_DUP_VALUE = 157,
 276     GPG_ERR_MISSING_ACTION = 158,
 277     GPG_ERR_MODULE_NOT_FOUND = 159,
 278     GPG_ERR_INV_OID_STRING = 160,
 279     GPG_ERR_INV_TIME = 161,
 280     GPG_ERR_INV_CRL_OBJ = 162,
 281     GPG_ERR_UNSUPPORTED_CRL_VERSION = 163,
 282     GPG_ERR_INV_CERT_OBJ = 164,
 283     GPG_ERR_UNKNOWN_NAME = 165,
 284     GPG_ERR_LOCALE_PROBLEM = 166,
 285     GPG_ERR_NOT_LOCKED = 167,
 286     GPG_ERR_PROTOCOL_VIOLATION = 168,
 287     GPG_ERR_INV_MAC = 169,
 288     GPG_ERR_INV_REQUEST = 170,
 289     GPG_ERR_UNKNOWN_EXTN = 171,
 290     GPG_ERR_UNKNOWN_CRIT_EXTN = 172,
 291     GPG_ERR_LOCKED = 173,
 292     GPG_ERR_UNKNOWN_OPTION = 174,
 293     GPG_ERR_UNKNOWN_COMMAND = 175,
 294     GPG_ERR_NOT_OPERATIONAL = 176,
 295     GPG_ERR_NO_PASSPHRASE = 177,
 296     GPG_ERR_NO_PIN = 178,
 297     GPG_ERR_NOT_ENABLED = 179,
 298     GPG_ERR_NO_ENGINE = 180,
 299     GPG_ERR_MISSING_KEY = 181,
 300     GPG_ERR_TOO_MANY = 182,
 301     GPG_ERR_LIMIT_REACHED = 183,
 302     GPG_ERR_NOT_INITIALIZED = 184,
 303     GPG_ERR_MISSING_ISSUER_CERT = 185,
 304     GPG_ERR_NO_KEYSERVER = 186,
 305     GPG_ERR_INV_CURVE = 187,
 306     GPG_ERR_UNKNOWN_CURVE = 188,
 307     GPG_ERR_DUP_KEY = 189,
 308     GPG_ERR_AMBIGUOUS = 190,
 309     GPG_ERR_NO_CRYPT_CTX = 191,
 310     GPG_ERR_WRONG_CRYPT_CTX = 192,
 311     GPG_ERR_BAD_CRYPT_CTX = 193,
 312     GPG_ERR_CRYPT_CTX_CONFLICT = 194,
 313     GPG_ERR_BROKEN_PUBKEY = 195,
 314     GPG_ERR_BROKEN_SECKEY = 196,
 315     GPG_ERR_MAC_ALGO = 197,
 316     GPG_ERR_FULLY_CANCELED = 198,
 317     GPG_ERR_UNFINISHED = 199,
 318     GPG_ERR_BUFFER_TOO_SHORT = 200,
 319     GPG_ERR_SEXP_INV_LEN_SPEC = 201,
 320     GPG_ERR_SEXP_STRING_TOO_LONG = 202,
 321     GPG_ERR_SEXP_UNMATCHED_PAREN = 203,
 322     GPG_ERR_SEXP_NOT_CANONICAL = 204,
 323     GPG_ERR_SEXP_BAD_CHARACTER = 205,
 324     GPG_ERR_SEXP_BAD_QUOTATION = 206,
 325     GPG_ERR_SEXP_ZERO_PREFIX = 207,
 326     GPG_ERR_SEXP_NESTED_DH = 208,
 327     GPG_ERR_SEXP_UNMATCHED_DH = 209,
 328     GPG_ERR_SEXP_UNEXPECTED_PUNC = 210,
 329     GPG_ERR_SEXP_BAD_HEX_CHAR = 211,
 330     GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212,
 331     GPG_ERR_SEXP_BAD_OCT_CHAR = 213,
 332     GPG_ERR_KEY_ON_CARD = 253,
 333     GPG_ERR_INV_LOCK_OBJ = 254,
 334     GPG_ERR_ASS_GENERAL = 257,
 335     GPG_ERR_ASS_ACCEPT_FAILED = 258,
 336     GPG_ERR_ASS_CONNECT_FAILED = 259,
 337     GPG_ERR_ASS_INV_RESPONSE = 260,
 338     GPG_ERR_ASS_INV_VALUE = 261,
 339     GPG_ERR_ASS_INCOMPLETE_LINE = 262,
 340     GPG_ERR_ASS_LINE_TOO_LONG = 263,
 341     GPG_ERR_ASS_NESTED_COMMANDS = 264,
 342     GPG_ERR_ASS_NO_DATA_CB = 265,
 343     GPG_ERR_ASS_NO_INQUIRE_CB = 266,
 344     GPG_ERR_ASS_NOT_A_SERVER = 267,
 345     GPG_ERR_ASS_NOT_A_CLIENT = 268,
 346     GPG_ERR_ASS_SERVER_START = 269,
 347     GPG_ERR_ASS_READ_ERROR = 270,
 348     GPG_ERR_ASS_WRITE_ERROR = 271,
 349     GPG_ERR_ASS_TOO_MUCH_DATA = 273,
 350     GPG_ERR_ASS_UNEXPECTED_CMD = 274,
 351     GPG_ERR_ASS_UNKNOWN_CMD = 275,
 352     GPG_ERR_ASS_SYNTAX = 276,
 353     GPG_ERR_ASS_CANCELED = 277,
 354     GPG_ERR_ASS_NO_INPUT = 278,
 355     GPG_ERR_ASS_NO_OUTPUT = 279,
 356     GPG_ERR_ASS_PARAMETER = 280,
 357     GPG_ERR_ASS_UNKNOWN_INQUIRE = 281,
 358     GPG_ERR_USER_1 = 1024,
 359     GPG_ERR_USER_2 = 1025,
 360     GPG_ERR_USER_3 = 1026,
 361     GPG_ERR_USER_4 = 1027,
 362     GPG_ERR_USER_5 = 1028,
 363     GPG_ERR_USER_6 = 1029,
 364     GPG_ERR_USER_7 = 1030,
 365     GPG_ERR_USER_8 = 1031,
 366     GPG_ERR_USER_9 = 1032,
 367     GPG_ERR_USER_10 = 1033,
 368     GPG_ERR_USER_11 = 1034,
 369     GPG_ERR_USER_12 = 1035,
 370     GPG_ERR_USER_13 = 1036,
 371     GPG_ERR_USER_14 = 1037,
 372     GPG_ERR_USER_15 = 1038,
 373     GPG_ERR_USER_16 = 1039,
 374     GPG_ERR_MISSING_ERRNO = 16381,
 375     GPG_ERR_UNKNOWN_ERRNO = 16382,
 376     GPG_ERR_EOF = 16383,
 377
 378     /* The following error codes are used to map system errors.  */
 379 #define GPG_ERR_SYSTEM_ERROR    (1 << 15)
 380     GPG_ERR_E2BIG = GPG_ERR_SYSTEM_ERROR | 0,
 381     GPG_ERR_EACCES = GPG_ERR_SYSTEM_ERROR | 1,
 382     GPG_ERR_EADDRINUSE = GPG_ERR_SYSTEM_ERROR | 2,
 383     GPG_ERR_EADDRNOTAVAIL = GPG_ERR_SYSTEM_ERROR | 3,
 384     GPG_ERR_EADV = GPG_ERR_SYSTEM_ERROR | 4,
 385     GPG_ERR_EAFNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 5,
 386     GPG_ERR_EAGAIN = GPG_ERR_SYSTEM_ERROR | 6,
 387     GPG_ERR_EALREADY = GPG_ERR_SYSTEM_ERROR | 7,
 388     GPG_ERR_EAUTH = GPG_ERR_SYSTEM_ERROR | 8,
 389     GPG_ERR_EBACKGROUND = GPG_ERR_SYSTEM_ERROR | 9,
 390     GPG_ERR_EBADE = GPG_ERR_SYSTEM_ERROR | 10,
 391     GPG_ERR_EBADF = GPG_ERR_SYSTEM_ERROR | 11,
 392     GPG_ERR_EBADFD = GPG_ERR_SYSTEM_ERROR | 12,
 393     GPG_ERR_EBADMSG = GPG_ERR_SYSTEM_ERROR | 13,
 394     GPG_ERR_EBADR = GPG_ERR_SYSTEM_ERROR | 14,
 395     GPG_ERR_EBADRPC = GPG_ERR_SYSTEM_ERROR | 15,
 396     GPG_ERR_EBADRQC = GPG_ERR_SYSTEM_ERROR | 16,
 397     GPG_ERR_EBADSLT = GPG_ERR_SYSTEM_ERROR | 17,
 398     GPG_ERR_EBFONT = GPG_ERR_SYSTEM_ERROR | 18,
 399     GPG_ERR_EBUSY = GPG_ERR_SYSTEM_ERROR | 19,
 400     GPG_ERR_ECANCELED = GPG_ERR_SYSTEM_ERROR | 20,
 401     GPG_ERR_ECHILD = GPG_ERR_SYSTEM_ERROR | 21,
 402     GPG_ERR_ECHRNG = GPG_ERR_SYSTEM_ERROR | 22,
 403     GPG_ERR_ECOMM = GPG_ERR_SYSTEM_ERROR | 23,
 404     GPG_ERR_ECONNABORTED = GPG_ERR_SYSTEM_ERROR | 24,
 405     GPG_ERR_ECONNREFUSED = GPG_ERR_SYSTEM_ERROR | 25,
 406     GPG_ERR_ECONNRESET = GPG_ERR_SYSTEM_ERROR | 26,
 407     GPG_ERR_ED = GPG_ERR_SYSTEM_ERROR | 27,
 408     GPG_ERR_EDEADLK = GPG_ERR_SYSTEM_ERROR | 28,
 409     GPG_ERR_EDEADLOCK = GPG_ERR_SYSTEM_ERROR | 29,
 410     GPG_ERR_EDESTADDRREQ = GPG_ERR_SYSTEM_ERROR | 30,
 411     GPG_ERR_EDIED = GPG_ERR_SYSTEM_ERROR | 31,
 412     GPG_ERR_EDOM = GPG_ERR_SYSTEM_ERROR | 32,
 413     GPG_ERR_EDOTDOT = GPG_ERR_SYSTEM_ERROR | 33,
 414     GPG_ERR_EDQUOT = GPG_ERR_SYSTEM_ERROR | 34,
 415     GPG_ERR_EEXIST = GPG_ERR_SYSTEM_ERROR | 35,
 416     GPG_ERR_EFAULT = GPG_ERR_SYSTEM_ERROR | 36,
 417     GPG_ERR_EFBIG = GPG_ERR_SYSTEM_ERROR | 37,
 418     GPG_ERR_EFTYPE = GPG_ERR_SYSTEM_ERROR | 38,
 419     GPG_ERR_EGRATUITOUS = GPG_ERR_SYSTEM_ERROR | 39,
 420     GPG_ERR_EGREGIOUS = GPG_ERR_SYSTEM_ERROR | 40,
 421     GPG_ERR_EHOSTDOWN = GPG_ERR_SYSTEM_ERROR | 41,
 422     GPG_ERR_EHOSTUNREACH = GPG_ERR_SYSTEM_ERROR | 42,
 423     GPG_ERR_EIDRM = GPG_ERR_SYSTEM_ERROR | 43,
 424     GPG_ERR_EIEIO = GPG_ERR_SYSTEM_ERROR | 44,
 425     GPG_ERR_EILSEQ = GPG_ERR_SYSTEM_ERROR | 45,
 426     GPG_ERR_EINPROGRESS = GPG_ERR_SYSTEM_ERROR | 46,
 427     GPG_ERR_EINTR = GPG_ERR_SYSTEM_ERROR | 47,
 428     GPG_ERR_EINVAL = GPG_ERR_SYSTEM_ERROR | 48,
 429     GPG_ERR_EIO = GPG_ERR_SYSTEM_ERROR | 49,
 430     GPG_ERR_EISCONN = GPG_ERR_SYSTEM_ERROR | 50,
 431     GPG_ERR_EISDIR = GPG_ERR_SYSTEM_ERROR | 51,
 432     GPG_ERR_EISNAM = GPG_ERR_SYSTEM_ERROR | 52,
 433     GPG_ERR_EL2HLT = GPG_ERR_SYSTEM_ERROR | 53,
 434     GPG_ERR_EL2NSYNC = GPG_ERR_SYSTEM_ERROR | 54,
 435     GPG_ERR_EL3HLT = GPG_ERR_SYSTEM_ERROR | 55,
 436     GPG_ERR_EL3RST = GPG_ERR_SYSTEM_ERROR | 56,
 437     GPG_ERR_ELIBACC = GPG_ERR_SYSTEM_ERROR | 57,
 438     GPG_ERR_ELIBBAD = GPG_ERR_SYSTEM_ERROR | 58,
 439     GPG_ERR_ELIBEXEC = GPG_ERR_SYSTEM_ERROR | 59,
 440     GPG_ERR_ELIBMAX = GPG_ERR_SYSTEM_ERROR | 60,
 441     GPG_ERR_ELIBSCN = GPG_ERR_SYSTEM_ERROR | 61,
 442     GPG_ERR_ELNRNG = GPG_ERR_SYSTEM_ERROR | 62,
 443     GPG_ERR_ELOOP = GPG_ERR_SYSTEM_ERROR | 63,
 444     GPG_ERR_EMEDIUMTYPE = GPG_ERR_SYSTEM_ERROR | 64,
 445     GPG_ERR_EMFILE = GPG_ERR_SYSTEM_ERROR | 65,
 446     GPG_ERR_EMLINK = GPG_ERR_SYSTEM_ERROR | 66,
 447     GPG_ERR_EMSGSIZE = GPG_ERR_SYSTEM_ERROR | 67,
 448     GPG_ERR_EMULTIHOP = GPG_ERR_SYSTEM_ERROR | 68,
 449     GPG_ERR_ENAMETOOLONG = GPG_ERR_SYSTEM_ERROR | 69,
 450     GPG_ERR_ENAVAIL = GPG_ERR_SYSTEM_ERROR | 70,
 451     GPG_ERR_ENEEDAUTH = GPG_ERR_SYSTEM_ERROR | 71,
 452     GPG_ERR_ENETDOWN = GPG_ERR_SYSTEM_ERROR | 72,
 453     GPG_ERR_ENETRESET = GPG_ERR_SYSTEM_ERROR | 73,
 454     GPG_ERR_ENETUNREACH = GPG_ERR_SYSTEM_ERROR | 74,
 455     GPG_ERR_ENFILE = GPG_ERR_SYSTEM_ERROR | 75,
 456     GPG_ERR_ENOANO = GPG_ERR_SYSTEM_ERROR | 76,
 457     GPG_ERR_ENOBUFS = GPG_ERR_SYSTEM_ERROR | 77,
 458     GPG_ERR_ENOCSI = GPG_ERR_SYSTEM_ERROR | 78,
 459     GPG_ERR_ENODATA = GPG_ERR_SYSTEM_ERROR | 79,
 460     GPG_ERR_ENODEV = GPG_ERR_SYSTEM_ERROR | 80,
 461     GPG_ERR_ENOENT = GPG_ERR_SYSTEM_ERROR | 81,
 462     GPG_ERR_ENOEXEC = GPG_ERR_SYSTEM_ERROR | 82,
 463     GPG_ERR_ENOLCK = GPG_ERR_SYSTEM_ERROR | 83,
 464     GPG_ERR_ENOLINK = GPG_ERR_SYSTEM_ERROR | 84,
 465     GPG_ERR_ENOMEDIUM = GPG_ERR_SYSTEM_ERROR | 85,
 466     GPG_ERR_ENOMEM = GPG_ERR_SYSTEM_ERROR | 86,
 467     GPG_ERR_ENOMSG = GPG_ERR_SYSTEM_ERROR | 87,
 468     GPG_ERR_ENONET = GPG_ERR_SYSTEM_ERROR | 88,
 469     GPG_ERR_ENOPKG = GPG_ERR_SYSTEM_ERROR | 89,
 470     GPG_ERR_ENOPROTOOPT = GPG_ERR_SYSTEM_ERROR | 90,
 471     GPG_ERR_ENOSPC = GPG_ERR_SYSTEM_ERROR | 91,
 472     GPG_ERR_ENOSR = GPG_ERR_SYSTEM_ERROR | 92,
 473     GPG_ERR_ENOSTR = GPG_ERR_SYSTEM_ERROR | 93,
 474     GPG_ERR_ENOSYS = GPG_ERR_SYSTEM_ERROR | 94,
 475     GPG_ERR_ENOTBLK = GPG_ERR_SYSTEM_ERROR | 95,
 476     GPG_ERR_ENOTCONN = GPG_ERR_SYSTEM_ERROR | 96,
 477     GPG_ERR_ENOTDIR = GPG_ERR_SYSTEM_ERROR | 97,
 478     GPG_ERR_ENOTEMPTY = GPG_ERR_SYSTEM_ERROR | 98,
 479     GPG_ERR_ENOTNAM = GPG_ERR_SYSTEM_ERROR | 99,
 480     GPG_ERR_ENOTSOCK = GPG_ERR_SYSTEM_ERROR | 100,
 481     GPG_ERR_ENOTSUP = GPG_ERR_SYSTEM_ERROR | 101,
 482     GPG_ERR_ENOTTY = GPG_ERR_SYSTEM_ERROR | 102,
 483     GPG_ERR_ENOTUNIQ = GPG_ERR_SYSTEM_ERROR | 103,
 484     GPG_ERR_ENXIO = GPG_ERR_SYSTEM_ERROR | 104,
 485     GPG_ERR_EOPNOTSUPP = GPG_ERR_SYSTEM_ERROR | 105,
 486     GPG_ERR_EOVERFLOW = GPG_ERR_SYSTEM_ERROR | 106,
 487     GPG_ERR_EPERM = GPG_ERR_SYSTEM_ERROR | 107,
 488     GPG_ERR_EPFNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 108,
 489     GPG_ERR_EPIPE = GPG_ERR_SYSTEM_ERROR | 109,
 490     GPG_ERR_EPROCLIM = GPG_ERR_SYSTEM_ERROR | 110,
 491     GPG_ERR_EPROCUNAVAIL = GPG_ERR_SYSTEM_ERROR | 111,
 492     GPG_ERR_EPROGMISMATCH = GPG_ERR_SYSTEM_ERROR | 112,
 493     GPG_ERR_EPROGUNAVAIL = GPG_ERR_SYSTEM_ERROR | 113,
 494     GPG_ERR_EPROTO = GPG_ERR_SYSTEM_ERROR | 114,
 495     GPG_ERR_EPROTONOSUPPORT = GPG_ERR_SYSTEM_ERROR | 115,
 496     GPG_ERR_EPROTOTYPE = GPG_ERR_SYSTEM_ERROR | 116,
 497     GPG_ERR_ERANGE = GPG_ERR_SYSTEM_ERROR | 117,
 498     GPG_ERR_EREMCHG = GPG_ERR_SYSTEM_ERROR | 118,
 499     GPG_ERR_EREMOTE = GPG_ERR_SYSTEM_ERROR | 119,
 500     GPG_ERR_EREMOTEIO = GPG_ERR_SYSTEM_ERROR | 120,
 501     GPG_ERR_ERESTART = GPG_ERR_SYSTEM_ERROR | 121,
 502     GPG_ERR_EROFS = GPG_ERR_SYSTEM_ERROR | 122,
 503     GPG_ERR_ERPCMISMATCH = GPG_ERR_SYSTEM_ERROR | 123,
 504     GPG_ERR_ESHUTDOWN = GPG_ERR_SYSTEM_ERROR | 124,
 505     GPG_ERR_ESOCKTNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 125,
 506     GPG_ERR_ESPIPE = GPG_ERR_SYSTEM_ERROR | 126,
 507     GPG_ERR_ESRCH = GPG_ERR_SYSTEM_ERROR | 127,
 508     GPG_ERR_ESRMNT = GPG_ERR_SYSTEM_ERROR | 128,
 509     GPG_ERR_ESTALE = GPG_ERR_SYSTEM_ERROR | 129,
 510     GPG_ERR_ESTRPIPE = GPG_ERR_SYSTEM_ERROR | 130,
 511     GPG_ERR_ETIME = GPG_ERR_SYSTEM_ERROR | 131,
 512     GPG_ERR_ETIMEDOUT = GPG_ERR_SYSTEM_ERROR | 132,
 513     GPG_ERR_ETOOMANYREFS = GPG_ERR_SYSTEM_ERROR | 133,
 514     GPG_ERR_ETXTBSY = GPG_ERR_SYSTEM_ERROR | 134,
 515     GPG_ERR_EUCLEAN = GPG_ERR_SYSTEM_ERROR | 135,
 516     GPG_ERR_EUNATCH = GPG_ERR_SYSTEM_ERROR | 136,
 517     GPG_ERR_EUSERS = GPG_ERR_SYSTEM_ERROR | 137,
 518     GPG_ERR_EWOULDBLOCK = GPG_ERR_SYSTEM_ERROR | 138,
 519     GPG_ERR_EXDEV = GPG_ERR_SYSTEM_ERROR | 139,
 520     GPG_ERR_EXFULL = GPG_ERR_SYSTEM_ERROR | 140,
 521
 522     /* This is one more than the largest allowed entry.  */
 523     GPG_ERR_CODE_DIM = 65536
 524   } gpg_err_code_t;
 525
 526 \f
 527 /* The error value type gpg_error_t.  */
 528
 529 /* We would really like to use bit-fields in a struct, but using
 530    structs as return values can cause binary compatibility issues, in
 531    particular if you want to do it effeciently (also see
 532    -freg-struct-return option to GCC).  */
 533 typedef unsigned int gpg_error_t;
 534
 535 /* We use the lowest 16 bits of gpg_error_t for error codes.  The 16th
 536    bit indicates system errors.  */
 537 #define GPG_ERR_CODE_MASK       (GPG_ERR_CODE_DIM - 1)
 538
 539 /* Bits 17 to 24 are reserved.  */
 540
 541 /* We use the upper 7 bits of gpg_error_t for error sources.  */
 542 #define GPG_ERR_SOURCE_MASK     (GPG_ERR_SOURCE_DIM - 1)
 543 #define GPG_ERR_SOURCE_SHIFT    24
 544
 545 /* The highest bit is reserved.  It shouldn't be used to prevent
 546    potential negative numbers when transmitting error values as
 547    text.  */
 548
 549 \f
 550 /* GCC feature test.  */
 551 #undef _GPG_ERR_HAVE_CONSTRUCTOR
 552 #if __GNUC__
 553 #define _GPG_ERR_GCC_VERSION (__GNUC__ * 10000 \
 554                             + __GNUC_MINOR__ * 100 \
 555                             + __GNUC_PATCHLEVEL__)
 556
 557 #if _GPG_ERR_GCC_VERSION > 30100
 558 #define _GPG_ERR_CONSTRUCTOR    __attribute__ ((__constructor__))
 559 #define _GPG_ERR_HAVE_CONSTRUCTOR
 560 #endif
 561 #endif
 562
 563 #ifndef _GPG_ERR_CONSTRUCTOR
 564 #define _GPG_ERR_CONSTRUCTOR
 565 #endif
 566
 567 \f
 568 /* Initialization function.  */
 569
 570 /* Initialize the library.  This function should be run early.  */
 571 gpg_error_t gpg_err_init (void) _GPG_ERR_CONSTRUCTOR;
 572
 573 /* If this is defined, the library is already initialized by the
 574    constructor and does not need to be initialized explicitely.  */
 575 #undef GPG_ERR_INITIALIZED
 576 #ifdef _GPG_ERR_HAVE_CONSTRUCTOR
 577 #define GPG_ERR_INITIALIZED     1
 578 #endif
 579
 580 /* See the source on how to use the deinit function; it is usually not
 581    required.  */
 582 void gpg_err_deinit (int mode);
 583
 584 \f
 585 /* Constructor and accessor functions.  */
 586
 587 /* Construct an error value from an error code and source.  Within a
 588    subsystem, use gpg_error.  */
 589 static GPG_ERR_INLINE gpg_error_t
 590 gpg_err_make (gpg_err_source_t source, gpg_err_code_t code)
 591 {
 592   return code == GPG_ERR_NO_ERROR ? GPG_ERR_NO_ERROR
 593     : (((source & GPG_ERR_SOURCE_MASK) << GPG_ERR_SOURCE_SHIFT)
 594        | (code & GPG_ERR_CODE_MASK));
 595 }
 596
 597
 598 /* The user should define GPG_ERR_SOURCE_DEFAULT before including this
 599    file to specify a default source for gpg_error.  */
 600 #ifndef GPG_ERR_SOURCE_DEFAULT
 601 #define GPG_ERR_SOURCE_DEFAULT  GPG_ERR_SOURCE_UNKNOWN
 602 #endif
 603
 604 static GPG_ERR_INLINE gpg_error_t
 605 gpg_error (gpg_err_code_t code)
 606 {
 607   return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, code);
 608 }
 609
 610
 611 /* Retrieve the error code from an error value.  */
 612 static GPG_ERR_INLINE gpg_err_code_t
 613 gpg_err_code (gpg_error_t err)
 614 {
 615   return (gpg_err_code_t) (err & GPG_ERR_CODE_MASK);
 616 }
 617
 618
 619 /* Retrieve the error source from an error value.  */
 620 static GPG_ERR_INLINE gpg_err_source_t
 621 gpg_err_source (gpg_error_t err)
 622 {
 623   return (gpg_err_source_t) ((err >> GPG_ERR_SOURCE_SHIFT)
 624                              & GPG_ERR_SOURCE_MASK);
 625 }
 626
 627 \f
 628 /* String functions.  */
 629
 630 /* Return a pointer to a string containing a description of the error
 631    code in the error value ERR.  This function is not thread-safe.  */
 632 const char *gpg_strerror (gpg_error_t err);
 633
 634 /* Return the error string for ERR in the user-supplied buffer BUF of
 635    size BUFLEN.  This function is, in contrast to gpg_strerror,
 636    thread-safe if a thread-safe strerror_r() function is provided by
 637    the system.  If the function succeeds, 0 is returned and BUF
 638    contains the string describing the error.  If the buffer was not
 639    large enough, ERANGE is returned and BUF contains as much of the
 640    beginning of the error string as fits into the buffer.  */
 641 int gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen);
 642
 643 /* Return a pointer to a string containing a description of the error
 644    source in the error value ERR.  */
 645 const char *gpg_strsource (gpg_error_t err);
 646
 647 \f
 648 /* Mapping of system errors (errno).  */
 649
 650 /* Retrieve the error code for the system error ERR.  This returns
 651    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
 652    this). */
 653 gpg_err_code_t gpg_err_code_from_errno (int err);
 654
 655
 656 /* Retrieve the system error for the error code CODE.  This returns 0
 657    if CODE is not a system error code.  */
 658 int gpg_err_code_to_errno (gpg_err_code_t code);
 659
 660
 661 /* Retrieve the error code directly from the ERRNO variable.  This
 662    returns GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped
 663    (report this) and GPG_ERR_MISSING_ERRNO if ERRNO has the value 0. */
 664 gpg_err_code_t gpg_err_code_from_syserror (void);
 665
 666
 667 /* Set the ERRNO variable.  This function is the preferred way to set
 668    ERRNO due to peculiarities on WindowsCE.  */
 669 void gpg_err_set_errno (int err);
 670
 671 /* Return or check the version.  */
 672 const char *gpg_error_check_version (const char *req_version);
 673
 674 /* The version string of this header. */
 675 #define GPG_ERROR_VERSION "1.13"
 676
 677 /* The version number of this header. */
 678 #define GPG_ERROR_VERSION_NUMBER 0x010d00
 679
 680 \f
 681 /* Self-documenting convenience functions.  */
 682
 683 static GPG_ERR_INLINE gpg_error_t
 684 gpg_err_make_from_errno (gpg_err_source_t source, int err)
 685 {
 686   return gpg_err_make (source, gpg_err_code_from_errno (err));
 687 }
 688
 689
 690 static GPG_ERR_INLINE gpg_error_t
 691 gpg_error_from_errno (int err)
 692 {
 693   return gpg_error (gpg_err_code_from_errno (err));
 694 }
 695
 696 static GPG_ERR_INLINE gpg_error_t
 697 gpg_error_from_syserror (void)
 698 {
 699   return gpg_error (gpg_err_code_from_syserror ());
 700 }
 701
 702
 703 \f
 704 /* Lock functions.  */
 705
 706
 707 typedef struct
 708 {
 709   long _vers;
 710   union {
 711     volatile char _priv[40];
 712     long _x_align;
 713     long *_xp_align;
 714   } u;
 715 } gpgrt_lock_t;
 716
 717 #define GPGRT_LOCK_INITIALIZER {1,{{0,0,0,0,0,0,0,0, \
 718                                     0,0,0,0,0,0,0,0, \
 719                                     0,0,0,0,0,0,0,0, \
 720                                     0,0,0,0,0,0,0,0, \
 721                                     0,0,0,0,0,0,0,0}}}
 722
 723 #define GPGRT_LOCK_DEFINE(name) \
 724   static gpgrt_lock_t name  = GPGRT_LOCK_INITIALIZER
 725
 726 /* NB: If GPGRT_LOCK_DEFINE is not used, zero out the lock variable
 727    before passing it to gpgrt_lock_init.  */
 728 gpg_err_code_t gpgrt_lock_init (gpgrt_lock_t *lockhd);
 729 gpg_err_code_t gpgrt_lock_lock (gpgrt_lock_t *lockhd);
 730 gpg_err_code_t gpgrt_lock_unlock (gpgrt_lock_t *lockhd);
 731 gpg_err_code_t gpgrt_lock_destroy (gpgrt_lock_t *lockhd);
 732
 733
 734 \f
 735 /* Thread functions.  */
 736
 737 gpg_err_code_t gpgrt_yield (void);
 738
 739
 740
 741 \f
 742 /* Estream */
 743
 744
 745
 746 #ifdef __cplusplus
 747 }
 748 #endif
 749 #endif  /* GPG_ERROR_H */
 750 /*
 751 Local Variables:
 752 buffer-read-only: t
 753 End:
 754 */