LCOV - code coverage report
Current view: top level - usr/include - gpg-error.h (source / functions) Hit Total Coverage
Test: GNU Shishi Lines: 0 2 0.0 %
Date: 2010-05-20 Functions: 0 1 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

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

Generated by: LCOV version 1.8