gpg-error.h (75117B)
1 /* gpg-error.h or gpgrt.h - Common code for GnuPG and others. -*- c -*- 2 * Copyright (C) 2001-2023 g10 Code GmbH 3 * 4 * This file is part of libgpg-error (aka libgpgrt). 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 <https://www.gnu.org/licenses/>. 18 * SPDX-License-Identifier: LGPL-2.1-or-later 19 * 20 * Do not edit. Generated from gpg-error.h.in for: 21 aarch64-unknown-linux-android 22 */ 23 24 /* The GnuPG project consists of many components. Error codes are 25 * exchanged between all components. The common error codes and their 26 * user-presentable descriptions are kept into a shared library to 27 * allow adding new error codes and components without recompiling any 28 * of the other components. In addition to error codes this library 29 * also features several other groups of functions which are common to 30 * all GnuPG components. They may be used by independet project as 31 * well. The interfaces will not change in a backward incompatible way. 32 * 33 * An error code together with an error source build up an error 34 * value. As the error value is been passed from one component to 35 * another, it preserves the information about the source and nature 36 * of the error. 37 * 38 * A component of the GnuPG project can define the following macros to 39 * tune the behaviour of the library: 40 * 41 * GPG_ERR_SOURCE_DEFAULT: Define to an error source of type 42 * gpg_err_source_t to make that source the default for gpg_error(). 43 * Otherwise GPG_ERR_SOURCE_UNKNOWN is used as default. 44 * 45 * GPG_ERR_ENABLE_GETTEXT_MACROS: Define to provide macros to map the 46 * internal gettext API to standard names. This has only an effect on 47 * Windows platforms. 48 * 49 * GPGRT_ENABLE_ES_MACROS: Define to provide "es_" macros for the 50 * estream functions. 51 * 52 * GPGRT_ENABLE_LOG_MACROS: Define to provide short versions of the 53 * log functions. 54 * 55 * GPGRT_ENABLE_ARGPARSE_MACROS: Needs to be defined to provide the 56 * mandatory macros of the argparse interface. 57 */ 58 59 #ifndef GPG_ERROR_H 60 #define GPG_ERROR_H 1 61 #ifndef GPGRT_H 62 #define GPGRT_H 1 63 64 #include <stddef.h> 65 #include <stdio.h> 66 #include <stdarg.h> 67 68 /* The version string of this header. */ 69 #define GPG_ERROR_VERSION "1.49" 70 #define GPGRT_VERSION "1.49" 71 72 /* The version number of this header. */ 73 #define GPG_ERROR_VERSION_NUMBER 0x013100 74 #define GPGRT_VERSION_NUMBER 0x013100 75 76 77 #ifdef __GNUC__ 78 # define GPG_ERR_INLINE __inline__ 79 #elif defined(_MSC_VER) && _MSC_VER >= 1300 80 # define GPG_ERR_INLINE __inline 81 #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L 82 # define GPG_ERR_INLINE inline 83 #else 84 # ifndef GPG_ERR_INLINE 85 # define GPG_ERR_INLINE 86 # endif 87 #endif 88 89 #ifdef __cplusplus 90 extern "C" { 91 #if 0 /* just to make Emacs auto-indent happy */ 92 } 93 #endif 94 #endif /* __cplusplus */ 95 96 97 98 /* The error source type gpg_err_source_t. 99 * 100 * Where as the Poo out of a welle small 101 * Taketh his firste springing and his sours. 102 * --Chaucer. 103 */ 104 105 /* Only use free slots, never change or reorder the existing 106 * entries. */ 107 typedef enum 108 { 109 GPG_ERR_SOURCE_UNKNOWN = 0, 110 GPG_ERR_SOURCE_GCRYPT = 1, 111 GPG_ERR_SOURCE_GPG = 2, 112 GPG_ERR_SOURCE_GPGSM = 3, 113 GPG_ERR_SOURCE_GPGAGENT = 4, 114 GPG_ERR_SOURCE_PINENTRY = 5, 115 GPG_ERR_SOURCE_SCD = 6, 116 GPG_ERR_SOURCE_GPGME = 7, 117 GPG_ERR_SOURCE_KEYBOX = 8, 118 GPG_ERR_SOURCE_KSBA = 9, 119 GPG_ERR_SOURCE_DIRMNGR = 10, 120 GPG_ERR_SOURCE_GSTI = 11, 121 GPG_ERR_SOURCE_GPA = 12, 122 GPG_ERR_SOURCE_KLEO = 13, 123 GPG_ERR_SOURCE_G13 = 14, 124 GPG_ERR_SOURCE_ASSUAN = 15, 125 GPG_ERR_SOURCE_TPM2D = 16, 126 GPG_ERR_SOURCE_TLS = 17, 127 GPG_ERR_SOURCE_TKD = 18, 128 GPG_ERR_SOURCE_ANY = 31, 129 GPG_ERR_SOURCE_USER_1 = 32, 130 GPG_ERR_SOURCE_USER_2 = 33, 131 GPG_ERR_SOURCE_USER_3 = 34, 132 GPG_ERR_SOURCE_USER_4 = 35, 133 134 /* This is one more than the largest allowed entry. */ 135 GPG_ERR_SOURCE_DIM = 128 136 } gpg_err_source_t; 137 138 139 /* The error code type gpg_err_code_t. */ 140 141 /* Only use free slots, never change or reorder the existing 142 * entries. */ 143 typedef enum 144 { 145 GPG_ERR_NO_ERROR = 0, 146 GPG_ERR_GENERAL = 1, 147 GPG_ERR_UNKNOWN_PACKET = 2, 148 GPG_ERR_UNKNOWN_VERSION = 3, 149 GPG_ERR_PUBKEY_ALGO = 4, 150 GPG_ERR_DIGEST_ALGO = 5, 151 GPG_ERR_BAD_PUBKEY = 6, 152 GPG_ERR_BAD_SECKEY = 7, 153 GPG_ERR_BAD_SIGNATURE = 8, 154 GPG_ERR_NO_PUBKEY = 9, 155 GPG_ERR_CHECKSUM = 10, 156 GPG_ERR_BAD_PASSPHRASE = 11, 157 GPG_ERR_CIPHER_ALGO = 12, 158 GPG_ERR_KEYRING_OPEN = 13, 159 GPG_ERR_INV_PACKET = 14, 160 GPG_ERR_INV_ARMOR = 15, 161 GPG_ERR_NO_USER_ID = 16, 162 GPG_ERR_NO_SECKEY = 17, 163 GPG_ERR_WRONG_SECKEY = 18, 164 GPG_ERR_BAD_KEY = 19, 165 GPG_ERR_COMPR_ALGO = 20, 166 GPG_ERR_NO_PRIME = 21, 167 GPG_ERR_NO_ENCODING_METHOD = 22, 168 GPG_ERR_NO_ENCRYPTION_SCHEME = 23, 169 GPG_ERR_NO_SIGNATURE_SCHEME = 24, 170 GPG_ERR_INV_ATTR = 25, 171 GPG_ERR_NO_VALUE = 26, 172 GPG_ERR_NOT_FOUND = 27, 173 GPG_ERR_VALUE_NOT_FOUND = 28, 174 GPG_ERR_SYNTAX = 29, 175 GPG_ERR_BAD_MPI = 30, 176 GPG_ERR_INV_PASSPHRASE = 31, 177 GPG_ERR_SIG_CLASS = 32, 178 GPG_ERR_RESOURCE_LIMIT = 33, 179 GPG_ERR_INV_KEYRING = 34, 180 GPG_ERR_TRUSTDB = 35, 181 GPG_ERR_BAD_CERT = 36, 182 GPG_ERR_INV_USER_ID = 37, 183 GPG_ERR_UNEXPECTED = 38, 184 GPG_ERR_TIME_CONFLICT = 39, 185 GPG_ERR_KEYSERVER = 40, 186 GPG_ERR_WRONG_PUBKEY_ALGO = 41, 187 GPG_ERR_TRIBUTE_TO_D_A = 42, 188 GPG_ERR_WEAK_KEY = 43, 189 GPG_ERR_INV_KEYLEN = 44, 190 GPG_ERR_INV_ARG = 45, 191 GPG_ERR_BAD_URI = 46, 192 GPG_ERR_INV_URI = 47, 193 GPG_ERR_NETWORK = 48, 194 GPG_ERR_UNKNOWN_HOST = 49, 195 GPG_ERR_SELFTEST_FAILED = 50, 196 GPG_ERR_NOT_ENCRYPTED = 51, 197 GPG_ERR_NOT_PROCESSED = 52, 198 GPG_ERR_UNUSABLE_PUBKEY = 53, 199 GPG_ERR_UNUSABLE_SECKEY = 54, 200 GPG_ERR_INV_VALUE = 55, 201 GPG_ERR_BAD_CERT_CHAIN = 56, 202 GPG_ERR_MISSING_CERT = 57, 203 GPG_ERR_NO_DATA = 58, 204 GPG_ERR_BUG = 59, 205 GPG_ERR_NOT_SUPPORTED = 60, 206 GPG_ERR_INV_OP = 61, 207 GPG_ERR_TIMEOUT = 62, 208 GPG_ERR_INTERNAL = 63, 209 GPG_ERR_EOF_GCRYPT = 64, 210 GPG_ERR_INV_OBJ = 65, 211 GPG_ERR_TOO_SHORT = 66, 212 GPG_ERR_TOO_LARGE = 67, 213 GPG_ERR_NO_OBJ = 68, 214 GPG_ERR_NOT_IMPLEMENTED = 69, 215 GPG_ERR_CONFLICT = 70, 216 GPG_ERR_INV_CIPHER_MODE = 71, 217 GPG_ERR_INV_FLAG = 72, 218 GPG_ERR_INV_HANDLE = 73, 219 GPG_ERR_TRUNCATED = 74, 220 GPG_ERR_INCOMPLETE_LINE = 75, 221 GPG_ERR_INV_RESPONSE = 76, 222 GPG_ERR_NO_AGENT = 77, 223 GPG_ERR_AGENT = 78, 224 GPG_ERR_INV_DATA = 79, 225 GPG_ERR_ASSUAN_SERVER_FAULT = 80, 226 GPG_ERR_ASSUAN = 81, 227 GPG_ERR_INV_SESSION_KEY = 82, 228 GPG_ERR_INV_SEXP = 83, 229 GPG_ERR_UNSUPPORTED_ALGORITHM = 84, 230 GPG_ERR_NO_PIN_ENTRY = 85, 231 GPG_ERR_PIN_ENTRY = 86, 232 GPG_ERR_BAD_PIN = 87, 233 GPG_ERR_INV_NAME = 88, 234 GPG_ERR_BAD_DATA = 89, 235 GPG_ERR_INV_PARAMETER = 90, 236 GPG_ERR_WRONG_CARD = 91, 237 GPG_ERR_NO_DIRMNGR = 92, 238 GPG_ERR_DIRMNGR = 93, 239 GPG_ERR_CERT_REVOKED = 94, 240 GPG_ERR_NO_CRL_KNOWN = 95, 241 GPG_ERR_CRL_TOO_OLD = 96, 242 GPG_ERR_LINE_TOO_LONG = 97, 243 GPG_ERR_NOT_TRUSTED = 98, 244 GPG_ERR_CANCELED = 99, 245 GPG_ERR_BAD_CA_CERT = 100, 246 GPG_ERR_CERT_EXPIRED = 101, 247 GPG_ERR_CERT_TOO_YOUNG = 102, 248 GPG_ERR_UNSUPPORTED_CERT = 103, 249 GPG_ERR_UNKNOWN_SEXP = 104, 250 GPG_ERR_UNSUPPORTED_PROTECTION = 105, 251 GPG_ERR_CORRUPTED_PROTECTION = 106, 252 GPG_ERR_AMBIGUOUS_NAME = 107, 253 GPG_ERR_CARD = 108, 254 GPG_ERR_CARD_RESET = 109, 255 GPG_ERR_CARD_REMOVED = 110, 256 GPG_ERR_INV_CARD = 111, 257 GPG_ERR_CARD_NOT_PRESENT = 112, 258 GPG_ERR_NO_PKCS15_APP = 113, 259 GPG_ERR_NOT_CONFIRMED = 114, 260 GPG_ERR_CONFIGURATION = 115, 261 GPG_ERR_NO_POLICY_MATCH = 116, 262 GPG_ERR_INV_INDEX = 117, 263 GPG_ERR_INV_ID = 118, 264 GPG_ERR_NO_SCDAEMON = 119, 265 GPG_ERR_SCDAEMON = 120, 266 GPG_ERR_UNSUPPORTED_PROTOCOL = 121, 267 GPG_ERR_BAD_PIN_METHOD = 122, 268 GPG_ERR_CARD_NOT_INITIALIZED = 123, 269 GPG_ERR_UNSUPPORTED_OPERATION = 124, 270 GPG_ERR_WRONG_KEY_USAGE = 125, 271 GPG_ERR_NOTHING_FOUND = 126, 272 GPG_ERR_WRONG_BLOB_TYPE = 127, 273 GPG_ERR_MISSING_VALUE = 128, 274 GPG_ERR_HARDWARE = 129, 275 GPG_ERR_PIN_BLOCKED = 130, 276 GPG_ERR_USE_CONDITIONS = 131, 277 GPG_ERR_PIN_NOT_SYNCED = 132, 278 GPG_ERR_INV_CRL = 133, 279 GPG_ERR_BAD_BER = 134, 280 GPG_ERR_INV_BER = 135, 281 GPG_ERR_ELEMENT_NOT_FOUND = 136, 282 GPG_ERR_IDENTIFIER_NOT_FOUND = 137, 283 GPG_ERR_INV_TAG = 138, 284 GPG_ERR_INV_LENGTH = 139, 285 GPG_ERR_INV_KEYINFO = 140, 286 GPG_ERR_UNEXPECTED_TAG = 141, 287 GPG_ERR_NOT_DER_ENCODED = 142, 288 GPG_ERR_NO_CMS_OBJ = 143, 289 GPG_ERR_INV_CMS_OBJ = 144, 290 GPG_ERR_UNKNOWN_CMS_OBJ = 145, 291 GPG_ERR_UNSUPPORTED_CMS_OBJ = 146, 292 GPG_ERR_UNSUPPORTED_ENCODING = 147, 293 GPG_ERR_UNSUPPORTED_CMS_VERSION = 148, 294 GPG_ERR_UNKNOWN_ALGORITHM = 149, 295 GPG_ERR_INV_ENGINE = 150, 296 GPG_ERR_PUBKEY_NOT_TRUSTED = 151, 297 GPG_ERR_DECRYPT_FAILED = 152, 298 GPG_ERR_KEY_EXPIRED = 153, 299 GPG_ERR_SIG_EXPIRED = 154, 300 GPG_ERR_ENCODING_PROBLEM = 155, 301 GPG_ERR_INV_STATE = 156, 302 GPG_ERR_DUP_VALUE = 157, 303 GPG_ERR_MISSING_ACTION = 158, 304 GPG_ERR_MODULE_NOT_FOUND = 159, 305 GPG_ERR_INV_OID_STRING = 160, 306 GPG_ERR_INV_TIME = 161, 307 GPG_ERR_INV_CRL_OBJ = 162, 308 GPG_ERR_UNSUPPORTED_CRL_VERSION = 163, 309 GPG_ERR_INV_CERT_OBJ = 164, 310 GPG_ERR_UNKNOWN_NAME = 165, 311 GPG_ERR_LOCALE_PROBLEM = 166, 312 GPG_ERR_NOT_LOCKED = 167, 313 GPG_ERR_PROTOCOL_VIOLATION = 168, 314 GPG_ERR_INV_MAC = 169, 315 GPG_ERR_INV_REQUEST = 170, 316 GPG_ERR_UNKNOWN_EXTN = 171, 317 GPG_ERR_UNKNOWN_CRIT_EXTN = 172, 318 GPG_ERR_LOCKED = 173, 319 GPG_ERR_UNKNOWN_OPTION = 174, 320 GPG_ERR_UNKNOWN_COMMAND = 175, 321 GPG_ERR_NOT_OPERATIONAL = 176, 322 GPG_ERR_NO_PASSPHRASE = 177, 323 GPG_ERR_NO_PIN = 178, 324 GPG_ERR_NOT_ENABLED = 179, 325 GPG_ERR_NO_ENGINE = 180, 326 GPG_ERR_MISSING_KEY = 181, 327 GPG_ERR_TOO_MANY = 182, 328 GPG_ERR_LIMIT_REACHED = 183, 329 GPG_ERR_NOT_INITIALIZED = 184, 330 GPG_ERR_MISSING_ISSUER_CERT = 185, 331 GPG_ERR_NO_KEYSERVER = 186, 332 GPG_ERR_INV_CURVE = 187, 333 GPG_ERR_UNKNOWN_CURVE = 188, 334 GPG_ERR_DUP_KEY = 189, 335 GPG_ERR_AMBIGUOUS = 190, 336 GPG_ERR_NO_CRYPT_CTX = 191, 337 GPG_ERR_WRONG_CRYPT_CTX = 192, 338 GPG_ERR_BAD_CRYPT_CTX = 193, 339 GPG_ERR_CRYPT_CTX_CONFLICT = 194, 340 GPG_ERR_BROKEN_PUBKEY = 195, 341 GPG_ERR_BROKEN_SECKEY = 196, 342 GPG_ERR_MAC_ALGO = 197, 343 GPG_ERR_FULLY_CANCELED = 198, 344 GPG_ERR_UNFINISHED = 199, 345 GPG_ERR_BUFFER_TOO_SHORT = 200, 346 GPG_ERR_SEXP_INV_LEN_SPEC = 201, 347 GPG_ERR_SEXP_STRING_TOO_LONG = 202, 348 GPG_ERR_SEXP_UNMATCHED_PAREN = 203, 349 GPG_ERR_SEXP_NOT_CANONICAL = 204, 350 GPG_ERR_SEXP_BAD_CHARACTER = 205, 351 GPG_ERR_SEXP_BAD_QUOTATION = 206, 352 GPG_ERR_SEXP_ZERO_PREFIX = 207, 353 GPG_ERR_SEXP_NESTED_DH = 208, 354 GPG_ERR_SEXP_UNMATCHED_DH = 209, 355 GPG_ERR_SEXP_UNEXPECTED_PUNC = 210, 356 GPG_ERR_SEXP_BAD_HEX_CHAR = 211, 357 GPG_ERR_SEXP_ODD_HEX_NUMBERS = 212, 358 GPG_ERR_SEXP_BAD_OCT_CHAR = 213, 359 GPG_ERR_SUBKEYS_EXP_OR_REV = 217, 360 GPG_ERR_DB_CORRUPTED = 218, 361 GPG_ERR_SERVER_FAILED = 219, 362 GPG_ERR_NO_NAME = 220, 363 GPG_ERR_NO_KEY = 221, 364 GPG_ERR_LEGACY_KEY = 222, 365 GPG_ERR_REQUEST_TOO_SHORT = 223, 366 GPG_ERR_REQUEST_TOO_LONG = 224, 367 GPG_ERR_OBJ_TERM_STATE = 225, 368 GPG_ERR_NO_CERT_CHAIN = 226, 369 GPG_ERR_CERT_TOO_LARGE = 227, 370 GPG_ERR_INV_RECORD = 228, 371 GPG_ERR_BAD_MAC = 229, 372 GPG_ERR_UNEXPECTED_MSG = 230, 373 GPG_ERR_COMPR_FAILED = 231, 374 GPG_ERR_WOULD_WRAP = 232, 375 GPG_ERR_FATAL_ALERT = 233, 376 GPG_ERR_NO_CIPHER = 234, 377 GPG_ERR_MISSING_CLIENT_CERT = 235, 378 GPG_ERR_CLOSE_NOTIFY = 236, 379 GPG_ERR_TICKET_EXPIRED = 237, 380 GPG_ERR_BAD_TICKET = 238, 381 GPG_ERR_UNKNOWN_IDENTITY = 239, 382 GPG_ERR_BAD_HS_CERT = 240, 383 GPG_ERR_BAD_HS_CERT_REQ = 241, 384 GPG_ERR_BAD_HS_CERT_VER = 242, 385 GPG_ERR_BAD_HS_CHANGE_CIPHER = 243, 386 GPG_ERR_BAD_HS_CLIENT_HELLO = 244, 387 GPG_ERR_BAD_HS_SERVER_HELLO = 245, 388 GPG_ERR_BAD_HS_SERVER_HELLO_DONE = 246, 389 GPG_ERR_BAD_HS_FINISHED = 247, 390 GPG_ERR_BAD_HS_SERVER_KEX = 248, 391 GPG_ERR_BAD_HS_CLIENT_KEX = 249, 392 GPG_ERR_BOGUS_STRING = 250, 393 GPG_ERR_FORBIDDEN = 251, 394 GPG_ERR_KEY_DISABLED = 252, 395 GPG_ERR_KEY_ON_CARD = 253, 396 GPG_ERR_INV_LOCK_OBJ = 254, 397 GPG_ERR_TRUE = 255, 398 GPG_ERR_FALSE = 256, 399 GPG_ERR_ASS_GENERAL = 257, 400 GPG_ERR_ASS_ACCEPT_FAILED = 258, 401 GPG_ERR_ASS_CONNECT_FAILED = 259, 402 GPG_ERR_ASS_INV_RESPONSE = 260, 403 GPG_ERR_ASS_INV_VALUE = 261, 404 GPG_ERR_ASS_INCOMPLETE_LINE = 262, 405 GPG_ERR_ASS_LINE_TOO_LONG = 263, 406 GPG_ERR_ASS_NESTED_COMMANDS = 264, 407 GPG_ERR_ASS_NO_DATA_CB = 265, 408 GPG_ERR_ASS_NO_INQUIRE_CB = 266, 409 GPG_ERR_ASS_NOT_A_SERVER = 267, 410 GPG_ERR_ASS_NOT_A_CLIENT = 268, 411 GPG_ERR_ASS_SERVER_START = 269, 412 GPG_ERR_ASS_READ_ERROR = 270, 413 GPG_ERR_ASS_WRITE_ERROR = 271, 414 GPG_ERR_ASS_TOO_MUCH_DATA = 273, 415 GPG_ERR_ASS_UNEXPECTED_CMD = 274, 416 GPG_ERR_ASS_UNKNOWN_CMD = 275, 417 GPG_ERR_ASS_SYNTAX = 276, 418 GPG_ERR_ASS_CANCELED = 277, 419 GPG_ERR_ASS_NO_INPUT = 278, 420 GPG_ERR_ASS_NO_OUTPUT = 279, 421 GPG_ERR_ASS_PARAMETER = 280, 422 GPG_ERR_ASS_UNKNOWN_INQUIRE = 281, 423 GPG_ERR_ENGINE_TOO_OLD = 300, 424 GPG_ERR_WINDOW_TOO_SMALL = 301, 425 GPG_ERR_WINDOW_TOO_LARGE = 302, 426 GPG_ERR_MISSING_ENVVAR = 303, 427 GPG_ERR_USER_ID_EXISTS = 304, 428 GPG_ERR_NAME_EXISTS = 305, 429 GPG_ERR_DUP_NAME = 306, 430 GPG_ERR_TOO_YOUNG = 307, 431 GPG_ERR_TOO_OLD = 308, 432 GPG_ERR_UNKNOWN_FLAG = 309, 433 GPG_ERR_INV_ORDER = 310, 434 GPG_ERR_ALREADY_FETCHED = 311, 435 GPG_ERR_TRY_LATER = 312, 436 GPG_ERR_WRONG_NAME = 313, 437 GPG_ERR_NO_AUTH = 314, 438 GPG_ERR_BAD_AUTH = 315, 439 GPG_ERR_NO_KEYBOXD = 316, 440 GPG_ERR_KEYBOXD = 317, 441 GPG_ERR_NO_SERVICE = 318, 442 GPG_ERR_SERVICE = 319, 443 GPG_ERR_BAD_PUK = 320, 444 GPG_ERR_NO_RESET_CODE = 321, 445 GPG_ERR_BAD_RESET_CODE = 322, 446 GPG_ERR_SYSTEM_BUG = 666, 447 GPG_ERR_DNS_UNKNOWN = 711, 448 GPG_ERR_DNS_SECTION = 712, 449 GPG_ERR_DNS_ADDRESS = 713, 450 GPG_ERR_DNS_NO_QUERY = 714, 451 GPG_ERR_DNS_NO_ANSWER = 715, 452 GPG_ERR_DNS_CLOSED = 716, 453 GPG_ERR_DNS_VERIFY = 717, 454 GPG_ERR_DNS_TIMEOUT = 718, 455 GPG_ERR_LDAP_GENERAL = 721, 456 GPG_ERR_LDAP_ATTR_GENERAL = 722, 457 GPG_ERR_LDAP_NAME_GENERAL = 723, 458 GPG_ERR_LDAP_SECURITY_GENERAL = 724, 459 GPG_ERR_LDAP_SERVICE_GENERAL = 725, 460 GPG_ERR_LDAP_UPDATE_GENERAL = 726, 461 GPG_ERR_LDAP_E_GENERAL = 727, 462 GPG_ERR_LDAP_X_GENERAL = 728, 463 GPG_ERR_LDAP_OTHER_GENERAL = 729, 464 GPG_ERR_LDAP_X_CONNECTING = 750, 465 GPG_ERR_LDAP_REFERRAL_LIMIT = 751, 466 GPG_ERR_LDAP_CLIENT_LOOP = 752, 467 GPG_ERR_LDAP_NO_RESULTS = 754, 468 GPG_ERR_LDAP_CONTROL_NOT_FOUND = 755, 469 GPG_ERR_LDAP_NOT_SUPPORTED = 756, 470 GPG_ERR_LDAP_CONNECT = 757, 471 GPG_ERR_LDAP_NO_MEMORY = 758, 472 GPG_ERR_LDAP_PARAM = 759, 473 GPG_ERR_LDAP_USER_CANCELLED = 760, 474 GPG_ERR_LDAP_FILTER = 761, 475 GPG_ERR_LDAP_AUTH_UNKNOWN = 762, 476 GPG_ERR_LDAP_TIMEOUT = 763, 477 GPG_ERR_LDAP_DECODING = 764, 478 GPG_ERR_LDAP_ENCODING = 765, 479 GPG_ERR_LDAP_LOCAL = 766, 480 GPG_ERR_LDAP_SERVER_DOWN = 767, 481 GPG_ERR_LDAP_SUCCESS = 768, 482 GPG_ERR_LDAP_OPERATIONS = 769, 483 GPG_ERR_LDAP_PROTOCOL = 770, 484 GPG_ERR_LDAP_TIMELIMIT = 771, 485 GPG_ERR_LDAP_SIZELIMIT = 772, 486 GPG_ERR_LDAP_COMPARE_FALSE = 773, 487 GPG_ERR_LDAP_COMPARE_TRUE = 774, 488 GPG_ERR_LDAP_UNSUPPORTED_AUTH = 775, 489 GPG_ERR_LDAP_STRONG_AUTH_RQRD = 776, 490 GPG_ERR_LDAP_PARTIAL_RESULTS = 777, 491 GPG_ERR_LDAP_REFERRAL = 778, 492 GPG_ERR_LDAP_ADMINLIMIT = 779, 493 GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN = 780, 494 GPG_ERR_LDAP_CONFIDENT_RQRD = 781, 495 GPG_ERR_LDAP_SASL_BIND_INPROG = 782, 496 GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE = 784, 497 GPG_ERR_LDAP_UNDEFINED_TYPE = 785, 498 GPG_ERR_LDAP_BAD_MATCHING = 786, 499 GPG_ERR_LDAP_CONST_VIOLATION = 787, 500 GPG_ERR_LDAP_TYPE_VALUE_EXISTS = 788, 501 GPG_ERR_LDAP_INV_SYNTAX = 789, 502 GPG_ERR_LDAP_NO_SUCH_OBJ = 800, 503 GPG_ERR_LDAP_ALIAS_PROBLEM = 801, 504 GPG_ERR_LDAP_INV_DN_SYNTAX = 802, 505 GPG_ERR_LDAP_IS_LEAF = 803, 506 GPG_ERR_LDAP_ALIAS_DEREF = 804, 507 GPG_ERR_LDAP_X_PROXY_AUTH_FAIL = 815, 508 GPG_ERR_LDAP_BAD_AUTH = 816, 509 GPG_ERR_LDAP_INV_CREDENTIALS = 817, 510 GPG_ERR_LDAP_INSUFFICIENT_ACC = 818, 511 GPG_ERR_LDAP_BUSY = 819, 512 GPG_ERR_LDAP_UNAVAILABLE = 820, 513 GPG_ERR_LDAP_UNWILL_TO_PERFORM = 821, 514 GPG_ERR_LDAP_LOOP_DETECT = 822, 515 GPG_ERR_LDAP_NAMING_VIOLATION = 832, 516 GPG_ERR_LDAP_OBJ_CLS_VIOLATION = 833, 517 GPG_ERR_LDAP_NOT_ALLOW_NONLEAF = 834, 518 GPG_ERR_LDAP_NOT_ALLOW_ON_RDN = 835, 519 GPG_ERR_LDAP_ALREADY_EXISTS = 836, 520 GPG_ERR_LDAP_NO_OBJ_CLASS_MODS = 837, 521 GPG_ERR_LDAP_RESULTS_TOO_LARGE = 838, 522 GPG_ERR_LDAP_AFFECTS_MULT_DSAS = 839, 523 GPG_ERR_LDAP_VLV = 844, 524 GPG_ERR_LDAP_OTHER = 848, 525 GPG_ERR_LDAP_CUP_RESOURCE_LIMIT = 881, 526 GPG_ERR_LDAP_CUP_SEC_VIOLATION = 882, 527 GPG_ERR_LDAP_CUP_INV_DATA = 883, 528 GPG_ERR_LDAP_CUP_UNSUP_SCHEME = 884, 529 GPG_ERR_LDAP_CUP_RELOAD = 885, 530 GPG_ERR_LDAP_CANCELLED = 886, 531 GPG_ERR_LDAP_NO_SUCH_OPERATION = 887, 532 GPG_ERR_LDAP_TOO_LATE = 888, 533 GPG_ERR_LDAP_CANNOT_CANCEL = 889, 534 GPG_ERR_LDAP_ASSERTION_FAILED = 890, 535 GPG_ERR_LDAP_PROX_AUTH_DENIED = 891, 536 GPG_ERR_USER_1 = 1024, 537 GPG_ERR_USER_2 = 1025, 538 GPG_ERR_USER_3 = 1026, 539 GPG_ERR_USER_4 = 1027, 540 GPG_ERR_USER_5 = 1028, 541 GPG_ERR_USER_6 = 1029, 542 GPG_ERR_USER_7 = 1030, 543 GPG_ERR_USER_8 = 1031, 544 GPG_ERR_USER_9 = 1032, 545 GPG_ERR_USER_10 = 1033, 546 GPG_ERR_USER_11 = 1034, 547 GPG_ERR_USER_12 = 1035, 548 GPG_ERR_USER_13 = 1036, 549 GPG_ERR_USER_14 = 1037, 550 GPG_ERR_USER_15 = 1038, 551 GPG_ERR_USER_16 = 1039, 552 GPG_ERR_SQL_OK = 1500, 553 GPG_ERR_SQL_ERROR = 1501, 554 GPG_ERR_SQL_INTERNAL = 1502, 555 GPG_ERR_SQL_PERM = 1503, 556 GPG_ERR_SQL_ABORT = 1504, 557 GPG_ERR_SQL_BUSY = 1505, 558 GPG_ERR_SQL_LOCKED = 1506, 559 GPG_ERR_SQL_NOMEM = 1507, 560 GPG_ERR_SQL_READONLY = 1508, 561 GPG_ERR_SQL_INTERRUPT = 1509, 562 GPG_ERR_SQL_IOERR = 1510, 563 GPG_ERR_SQL_CORRUPT = 1511, 564 GPG_ERR_SQL_NOTFOUND = 1512, 565 GPG_ERR_SQL_FULL = 1513, 566 GPG_ERR_SQL_CANTOPEN = 1514, 567 GPG_ERR_SQL_PROTOCOL = 1515, 568 GPG_ERR_SQL_EMPTY = 1516, 569 GPG_ERR_SQL_SCHEMA = 1517, 570 GPG_ERR_SQL_TOOBIG = 1518, 571 GPG_ERR_SQL_CONSTRAINT = 1519, 572 GPG_ERR_SQL_MISMATCH = 1520, 573 GPG_ERR_SQL_MISUSE = 1521, 574 GPG_ERR_SQL_NOLFS = 1522, 575 GPG_ERR_SQL_AUTH = 1523, 576 GPG_ERR_SQL_FORMAT = 1524, 577 GPG_ERR_SQL_RANGE = 1525, 578 GPG_ERR_SQL_NOTADB = 1526, 579 GPG_ERR_SQL_NOTICE = 1527, 580 GPG_ERR_SQL_WARNING = 1528, 581 GPG_ERR_SQL_ROW = 1600, 582 GPG_ERR_SQL_DONE = 1601, 583 GPG_ERR_MISSING_ERRNO = 16381, 584 GPG_ERR_UNKNOWN_ERRNO = 16382, 585 GPG_ERR_EOF = 16383, 586 587 /* The following error codes are used to map system errors. */ 588 #define GPG_ERR_SYSTEM_ERROR (1 << 15) 589 GPG_ERR_E2BIG = GPG_ERR_SYSTEM_ERROR | 0, 590 GPG_ERR_EACCES = GPG_ERR_SYSTEM_ERROR | 1, 591 GPG_ERR_EADDRINUSE = GPG_ERR_SYSTEM_ERROR | 2, 592 GPG_ERR_EADDRNOTAVAIL = GPG_ERR_SYSTEM_ERROR | 3, 593 GPG_ERR_EADV = GPG_ERR_SYSTEM_ERROR | 4, 594 GPG_ERR_EAFNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 5, 595 GPG_ERR_EAGAIN = GPG_ERR_SYSTEM_ERROR | 6, 596 GPG_ERR_EALREADY = GPG_ERR_SYSTEM_ERROR | 7, 597 GPG_ERR_EAUTH = GPG_ERR_SYSTEM_ERROR | 8, 598 GPG_ERR_EBACKGROUND = GPG_ERR_SYSTEM_ERROR | 9, 599 GPG_ERR_EBADE = GPG_ERR_SYSTEM_ERROR | 10, 600 GPG_ERR_EBADF = GPG_ERR_SYSTEM_ERROR | 11, 601 GPG_ERR_EBADFD = GPG_ERR_SYSTEM_ERROR | 12, 602 GPG_ERR_EBADMSG = GPG_ERR_SYSTEM_ERROR | 13, 603 GPG_ERR_EBADR = GPG_ERR_SYSTEM_ERROR | 14, 604 GPG_ERR_EBADRPC = GPG_ERR_SYSTEM_ERROR | 15, 605 GPG_ERR_EBADRQC = GPG_ERR_SYSTEM_ERROR | 16, 606 GPG_ERR_EBADSLT = GPG_ERR_SYSTEM_ERROR | 17, 607 GPG_ERR_EBFONT = GPG_ERR_SYSTEM_ERROR | 18, 608 GPG_ERR_EBUSY = GPG_ERR_SYSTEM_ERROR | 19, 609 GPG_ERR_ECANCELED = GPG_ERR_SYSTEM_ERROR | 20, 610 GPG_ERR_ECHILD = GPG_ERR_SYSTEM_ERROR | 21, 611 GPG_ERR_ECHRNG = GPG_ERR_SYSTEM_ERROR | 22, 612 GPG_ERR_ECOMM = GPG_ERR_SYSTEM_ERROR | 23, 613 GPG_ERR_ECONNABORTED = GPG_ERR_SYSTEM_ERROR | 24, 614 GPG_ERR_ECONNREFUSED = GPG_ERR_SYSTEM_ERROR | 25, 615 GPG_ERR_ECONNRESET = GPG_ERR_SYSTEM_ERROR | 26, 616 GPG_ERR_ED = GPG_ERR_SYSTEM_ERROR | 27, 617 GPG_ERR_EDEADLK = GPG_ERR_SYSTEM_ERROR | 28, 618 GPG_ERR_EDEADLOCK = GPG_ERR_SYSTEM_ERROR | 29, 619 GPG_ERR_EDESTADDRREQ = GPG_ERR_SYSTEM_ERROR | 30, 620 GPG_ERR_EDIED = GPG_ERR_SYSTEM_ERROR | 31, 621 GPG_ERR_EDOM = GPG_ERR_SYSTEM_ERROR | 32, 622 GPG_ERR_EDOTDOT = GPG_ERR_SYSTEM_ERROR | 33, 623 GPG_ERR_EDQUOT = GPG_ERR_SYSTEM_ERROR | 34, 624 GPG_ERR_EEXIST = GPG_ERR_SYSTEM_ERROR | 35, 625 GPG_ERR_EFAULT = GPG_ERR_SYSTEM_ERROR | 36, 626 GPG_ERR_EFBIG = GPG_ERR_SYSTEM_ERROR | 37, 627 GPG_ERR_EFTYPE = GPG_ERR_SYSTEM_ERROR | 38, 628 GPG_ERR_EGRATUITOUS = GPG_ERR_SYSTEM_ERROR | 39, 629 GPG_ERR_EGREGIOUS = GPG_ERR_SYSTEM_ERROR | 40, 630 GPG_ERR_EHOSTDOWN = GPG_ERR_SYSTEM_ERROR | 41, 631 GPG_ERR_EHOSTUNREACH = GPG_ERR_SYSTEM_ERROR | 42, 632 GPG_ERR_EIDRM = GPG_ERR_SYSTEM_ERROR | 43, 633 GPG_ERR_EIEIO = GPG_ERR_SYSTEM_ERROR | 44, 634 GPG_ERR_EILSEQ = GPG_ERR_SYSTEM_ERROR | 45, 635 GPG_ERR_EINPROGRESS = GPG_ERR_SYSTEM_ERROR | 46, 636 GPG_ERR_EINTR = GPG_ERR_SYSTEM_ERROR | 47, 637 GPG_ERR_EINVAL = GPG_ERR_SYSTEM_ERROR | 48, 638 GPG_ERR_EIO = GPG_ERR_SYSTEM_ERROR | 49, 639 GPG_ERR_EISCONN = GPG_ERR_SYSTEM_ERROR | 50, 640 GPG_ERR_EISDIR = GPG_ERR_SYSTEM_ERROR | 51, 641 GPG_ERR_EISNAM = GPG_ERR_SYSTEM_ERROR | 52, 642 GPG_ERR_EL2HLT = GPG_ERR_SYSTEM_ERROR | 53, 643 GPG_ERR_EL2NSYNC = GPG_ERR_SYSTEM_ERROR | 54, 644 GPG_ERR_EL3HLT = GPG_ERR_SYSTEM_ERROR | 55, 645 GPG_ERR_EL3RST = GPG_ERR_SYSTEM_ERROR | 56, 646 GPG_ERR_ELIBACC = GPG_ERR_SYSTEM_ERROR | 57, 647 GPG_ERR_ELIBBAD = GPG_ERR_SYSTEM_ERROR | 58, 648 GPG_ERR_ELIBEXEC = GPG_ERR_SYSTEM_ERROR | 59, 649 GPG_ERR_ELIBMAX = GPG_ERR_SYSTEM_ERROR | 60, 650 GPG_ERR_ELIBSCN = GPG_ERR_SYSTEM_ERROR | 61, 651 GPG_ERR_ELNRNG = GPG_ERR_SYSTEM_ERROR | 62, 652 GPG_ERR_ELOOP = GPG_ERR_SYSTEM_ERROR | 63, 653 GPG_ERR_EMEDIUMTYPE = GPG_ERR_SYSTEM_ERROR | 64, 654 GPG_ERR_EMFILE = GPG_ERR_SYSTEM_ERROR | 65, 655 GPG_ERR_EMLINK = GPG_ERR_SYSTEM_ERROR | 66, 656 GPG_ERR_EMSGSIZE = GPG_ERR_SYSTEM_ERROR | 67, 657 GPG_ERR_EMULTIHOP = GPG_ERR_SYSTEM_ERROR | 68, 658 GPG_ERR_ENAMETOOLONG = GPG_ERR_SYSTEM_ERROR | 69, 659 GPG_ERR_ENAVAIL = GPG_ERR_SYSTEM_ERROR | 70, 660 GPG_ERR_ENEEDAUTH = GPG_ERR_SYSTEM_ERROR | 71, 661 GPG_ERR_ENETDOWN = GPG_ERR_SYSTEM_ERROR | 72, 662 GPG_ERR_ENETRESET = GPG_ERR_SYSTEM_ERROR | 73, 663 GPG_ERR_ENETUNREACH = GPG_ERR_SYSTEM_ERROR | 74, 664 GPG_ERR_ENFILE = GPG_ERR_SYSTEM_ERROR | 75, 665 GPG_ERR_ENOANO = GPG_ERR_SYSTEM_ERROR | 76, 666 GPG_ERR_ENOBUFS = GPG_ERR_SYSTEM_ERROR | 77, 667 GPG_ERR_ENOCSI = GPG_ERR_SYSTEM_ERROR | 78, 668 GPG_ERR_ENODATA = GPG_ERR_SYSTEM_ERROR | 79, 669 GPG_ERR_ENODEV = GPG_ERR_SYSTEM_ERROR | 80, 670 GPG_ERR_ENOENT = GPG_ERR_SYSTEM_ERROR | 81, 671 GPG_ERR_ENOEXEC = GPG_ERR_SYSTEM_ERROR | 82, 672 GPG_ERR_ENOLCK = GPG_ERR_SYSTEM_ERROR | 83, 673 GPG_ERR_ENOLINK = GPG_ERR_SYSTEM_ERROR | 84, 674 GPG_ERR_ENOMEDIUM = GPG_ERR_SYSTEM_ERROR | 85, 675 GPG_ERR_ENOMEM = GPG_ERR_SYSTEM_ERROR | 86, 676 GPG_ERR_ENOMSG = GPG_ERR_SYSTEM_ERROR | 87, 677 GPG_ERR_ENONET = GPG_ERR_SYSTEM_ERROR | 88, 678 GPG_ERR_ENOPKG = GPG_ERR_SYSTEM_ERROR | 89, 679 GPG_ERR_ENOPROTOOPT = GPG_ERR_SYSTEM_ERROR | 90, 680 GPG_ERR_ENOSPC = GPG_ERR_SYSTEM_ERROR | 91, 681 GPG_ERR_ENOSR = GPG_ERR_SYSTEM_ERROR | 92, 682 GPG_ERR_ENOSTR = GPG_ERR_SYSTEM_ERROR | 93, 683 GPG_ERR_ENOSYS = GPG_ERR_SYSTEM_ERROR | 94, 684 GPG_ERR_ENOTBLK = GPG_ERR_SYSTEM_ERROR | 95, 685 GPG_ERR_ENOTCONN = GPG_ERR_SYSTEM_ERROR | 96, 686 GPG_ERR_ENOTDIR = GPG_ERR_SYSTEM_ERROR | 97, 687 GPG_ERR_ENOTEMPTY = GPG_ERR_SYSTEM_ERROR | 98, 688 GPG_ERR_ENOTNAM = GPG_ERR_SYSTEM_ERROR | 99, 689 GPG_ERR_ENOTSOCK = GPG_ERR_SYSTEM_ERROR | 100, 690 GPG_ERR_ENOTSUP = GPG_ERR_SYSTEM_ERROR | 101, 691 GPG_ERR_ENOTTY = GPG_ERR_SYSTEM_ERROR | 102, 692 GPG_ERR_ENOTUNIQ = GPG_ERR_SYSTEM_ERROR | 103, 693 GPG_ERR_ENXIO = GPG_ERR_SYSTEM_ERROR | 104, 694 GPG_ERR_EOPNOTSUPP = GPG_ERR_SYSTEM_ERROR | 105, 695 GPG_ERR_EOVERFLOW = GPG_ERR_SYSTEM_ERROR | 106, 696 GPG_ERR_EPERM = GPG_ERR_SYSTEM_ERROR | 107, 697 GPG_ERR_EPFNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 108, 698 GPG_ERR_EPIPE = GPG_ERR_SYSTEM_ERROR | 109, 699 GPG_ERR_EPROCLIM = GPG_ERR_SYSTEM_ERROR | 110, 700 GPG_ERR_EPROCUNAVAIL = GPG_ERR_SYSTEM_ERROR | 111, 701 GPG_ERR_EPROGMISMATCH = GPG_ERR_SYSTEM_ERROR | 112, 702 GPG_ERR_EPROGUNAVAIL = GPG_ERR_SYSTEM_ERROR | 113, 703 GPG_ERR_EPROTO = GPG_ERR_SYSTEM_ERROR | 114, 704 GPG_ERR_EPROTONOSUPPORT = GPG_ERR_SYSTEM_ERROR | 115, 705 GPG_ERR_EPROTOTYPE = GPG_ERR_SYSTEM_ERROR | 116, 706 GPG_ERR_ERANGE = GPG_ERR_SYSTEM_ERROR | 117, 707 GPG_ERR_EREMCHG = GPG_ERR_SYSTEM_ERROR | 118, 708 GPG_ERR_EREMOTE = GPG_ERR_SYSTEM_ERROR | 119, 709 GPG_ERR_EREMOTEIO = GPG_ERR_SYSTEM_ERROR | 120, 710 GPG_ERR_ERESTART = GPG_ERR_SYSTEM_ERROR | 121, 711 GPG_ERR_EROFS = GPG_ERR_SYSTEM_ERROR | 122, 712 GPG_ERR_ERPCMISMATCH = GPG_ERR_SYSTEM_ERROR | 123, 713 GPG_ERR_ESHUTDOWN = GPG_ERR_SYSTEM_ERROR | 124, 714 GPG_ERR_ESOCKTNOSUPPORT = GPG_ERR_SYSTEM_ERROR | 125, 715 GPG_ERR_ESPIPE = GPG_ERR_SYSTEM_ERROR | 126, 716 GPG_ERR_ESRCH = GPG_ERR_SYSTEM_ERROR | 127, 717 GPG_ERR_ESRMNT = GPG_ERR_SYSTEM_ERROR | 128, 718 GPG_ERR_ESTALE = GPG_ERR_SYSTEM_ERROR | 129, 719 GPG_ERR_ESTRPIPE = GPG_ERR_SYSTEM_ERROR | 130, 720 GPG_ERR_ETIME = GPG_ERR_SYSTEM_ERROR | 131, 721 GPG_ERR_ETIMEDOUT = GPG_ERR_SYSTEM_ERROR | 132, 722 GPG_ERR_ETOOMANYREFS = GPG_ERR_SYSTEM_ERROR | 133, 723 GPG_ERR_ETXTBSY = GPG_ERR_SYSTEM_ERROR | 134, 724 GPG_ERR_EUCLEAN = GPG_ERR_SYSTEM_ERROR | 135, 725 GPG_ERR_EUNATCH = GPG_ERR_SYSTEM_ERROR | 136, 726 GPG_ERR_EUSERS = GPG_ERR_SYSTEM_ERROR | 137, 727 GPG_ERR_EWOULDBLOCK = GPG_ERR_SYSTEM_ERROR | 138, 728 GPG_ERR_EXDEV = GPG_ERR_SYSTEM_ERROR | 139, 729 GPG_ERR_EXFULL = GPG_ERR_SYSTEM_ERROR | 140, 730 731 /* This is one more than the largest allowed entry. */ 732 GPG_ERR_CODE_DIM = 65536 733 } gpg_err_code_t; 734 735 736 /* The error value type gpg_error_t. */ 737 738 /* We would really like to use bit-fields in a struct, but using 739 * structs as return values can cause binary compatibility issues, in 740 * particular if you want to do it efficiently (also see 741 * -freg-struct-return option to GCC). */ 742 typedef unsigned int gpg_error_t; 743 744 /* We use the lowest 16 bits of gpg_error_t for error codes. The 16th 745 * bit indicates system errors. */ 746 #define GPG_ERR_CODE_MASK (GPG_ERR_CODE_DIM - 1) 747 748 /* Bits 17 to 24 are reserved. */ 749 750 /* We use the upper 7 bits of gpg_error_t for error sources. */ 751 #define GPG_ERR_SOURCE_MASK (GPG_ERR_SOURCE_DIM - 1) 752 #define GPG_ERR_SOURCE_SHIFT 24 753 754 /* The highest bit is reserved. It shouldn't be used to prevent 755 * potential negative numbers when transmitting error values as 756 * text. */ 757 758 759 /* 760 * GCC feature test. 761 */ 762 #if __GNUC__ 763 # define _GPG_ERR_GCC_VERSION (__GNUC__ * 10000 \ 764 + __GNUC_MINOR__ * 100 \ 765 + __GNUC_PATCHLEVEL__) 766 #else 767 # define _GPG_ERR_GCC_VERSION 0 768 #endif 769 770 #undef _GPG_ERR_HAVE_CONSTRUCTOR 771 #if _GPG_ERR_GCC_VERSION > 30100 772 # define _GPG_ERR_CONSTRUCTOR __attribute__ ((__constructor__)) 773 # define _GPG_ERR_HAVE_CONSTRUCTOR 774 #else 775 # define _GPG_ERR_CONSTRUCTOR 776 #endif 777 778 #define GPGRT_GCC_VERSION _GPG_ERR_GCC_VERSION 779 780 #if _GPG_ERR_GCC_VERSION >= 29200 781 # define _GPGRT__RESTRICT __restrict__ 782 #else 783 # define _GPGRT__RESTRICT 784 #endif 785 786 /* The noreturn attribute. */ 787 #if _GPG_ERR_GCC_VERSION >= 20500 788 # define GPGRT_ATTR_NORETURN __attribute__ ((__noreturn__)) 789 #else 790 # define GPGRT_ATTR_NORETURN 791 #endif 792 793 /* The printf attributes. */ 794 #if _GPG_ERR_GCC_VERSION >= 40400 795 # define GPGRT_ATTR_PRINTF(f, a) \ 796 __attribute__ ((format(__gnu_printf__,f,a))) 797 # define GPGRT_ATTR_NR_PRINTF(f, a) \ 798 __attribute__ ((__noreturn__, format(__gnu_printf__,f,a))) 799 #elif _GPG_ERR_GCC_VERSION >= 20500 800 # define GPGRT_ATTR_PRINTF(f, a) \ 801 __attribute__ ((format(printf,f,a))) 802 # define GPGRT_ATTR_NR_PRINTF(f, a) \ 803 __attribute__ ((__noreturn__, format(printf,f,a))) 804 #else 805 # define GPGRT_ATTR_PRINTF(f, a) 806 # define GPGRT_ATTR_NR_PRINTF(f, a) 807 #endif 808 #if _GPG_ERR_GCC_VERSION >= 20800 809 # define GPGRT_ATTR_FORMAT_ARG(a) __attribute__ ((__format_arg__ (a))) 810 #else 811 # define GPGRT_ATTR_FORMAT_ARG(a) 812 #endif 813 814 /* The sentinel attribute. */ 815 #if _GPG_ERR_GCC_VERSION >= 40000 816 # define GPGRT_ATTR_SENTINEL(a) __attribute__ ((sentinel(a))) 817 #else 818 # define GPGRT_ATTR_SENTINEL(a) 819 #endif 820 821 /* The used and unused attributes. 822 * I am not sure since when the unused attribute is really supported. 823 * In any case it it only needed for gcc versions which print a 824 * warning. Thus let us require gcc >= 3.5. */ 825 #if _GPG_ERR_GCC_VERSION >= 40000 826 # define GPGRT_ATTR_USED __attribute__ ((used)) 827 #else 828 # define GPGRT_ATTR_USED 829 #endif 830 #if _GPG_ERR_GCC_VERSION >= 30500 831 # define GPGRT_ATTR_UNUSED __attribute__ ((unused)) 832 #else 833 # define GPGRT_ATTR_UNUSED 834 #endif 835 836 /* The deprecated attribute. */ 837 #if _GPG_ERR_GCC_VERSION >= 30100 838 # define GPGRT_ATTR_DEPRECATED __attribute__ ((__deprecated__)) 839 #else 840 # define GPGRT_ATTR_DEPRECATED 841 #endif 842 843 /* The pure attribute. */ 844 #if _GPG_ERR_GCC_VERSION >= 29600 845 # define GPGRT_ATTR_PURE __attribute__ ((__pure__)) 846 #else 847 # define GPGRT_ATTR_PURE 848 #endif 849 850 /* The malloc attribute. */ 851 #if _GPG_ERR_GCC_VERSION >= 30200 852 # define GPGRT_ATTR_MALLOC __attribute__ ((__malloc__)) 853 #else 854 # define GPGRT_ATTR_MALLOC 855 #endif 856 857 /* A macro defined if a GCC style __FUNCTION__ macro is available. */ 858 #undef GPGRT_HAVE_MACRO_FUNCTION 859 #if _GPG_ERR_GCC_VERSION >= 20500 860 # define GPGRT_HAVE_MACRO_FUNCTION 1 861 #endif 862 863 /* A macro defined if the pragma GCC push_options is available. */ 864 #undef GPGRT_HAVE_PRAGMA_GCC_PUSH 865 #if _GPG_ERR_GCC_VERSION >= 40400 866 # define GPGRT_HAVE_PRAGMA_GCC_PUSH 1 867 #endif 868 869 /* Detect LeakSanitizer (LSan) support for GCC and Clang based on 870 * whether AddressSanitizer (ASAN) is enabled via -fsanitize=address). 871 * Note that -fsanitize=leak just affect the linker options which 872 * cannot be detected here. In that case you have to define the 873 * GPGRT_HAVE_LEAK_SANITIZER macro manually. */ 874 #ifdef __GNUC__ 875 # ifdef __SANITIZE_ADDRESS__ 876 # define GPGRT_HAVE_LEAK_SANITIZER 877 # elif defined(__has_feature) 878 # if __has_feature(address_sanitizer) 879 # define GPGRT_HAVE_LEAK_SANITIZER 880 # endif 881 # endif 882 #endif 883 884 885 /* The new name for the inline macro. */ 886 #define GPGRT_INLINE GPG_ERR_INLINE 887 888 #ifdef GPGRT_HAVE_LEAK_SANITIZER 889 # include <sanitizer/lsan_interface.h> 890 #endif 891 892 /* Mark heap objects as non-leaked memory. */ 893 static GPGRT_INLINE void 894 gpgrt_annotate_leaked_object (const void *p) 895 { 896 #ifdef GPGRT_HAVE_LEAK_SANITIZER 897 __lsan_ignore_object(p); 898 #else 899 (void)p; 900 #endif 901 } 902 903 904 /* 905 * Initialization function. 906 */ 907 908 /* Initialize the library. This function should be run early. */ 909 gpg_error_t gpg_err_init (void) _GPG_ERR_CONSTRUCTOR; 910 911 /* If this is defined, the library is already initialized by the 912 constructor and does not need to be initialized explicitely. */ 913 #undef GPG_ERR_INITIALIZED 914 #ifdef _GPG_ERR_HAVE_CONSTRUCTOR 915 # define GPG_ERR_INITIALIZED 1 916 # define gpgrt_init() do { gpg_err_init (); } while (0) 917 #else 918 # define gpgrt_init() do { ; } while (0) 919 #endif 920 921 /* See the source on how to use the deinit function; it is usually not 922 required. */ 923 void gpg_err_deinit (int mode); 924 925 /* Register blocking system I/O clamping functions. */ 926 void gpgrt_set_syscall_clamp (void (*pre)(void), void (*post)(void)); 927 928 /* Get current I/O clamping functions. */ 929 void gpgrt_get_syscall_clamp (void (**r_pre)(void), void (**r_post)(void)); 930 931 /* Register a custom malloc/realloc/free function. */ 932 void gpgrt_set_alloc_func (void *(*f)(void *a, size_t n)); 933 934 /* Register an emergency cleanup handler. */ 935 void gpgrt_add_emergency_cleanup (void (*f)(void)); 936 937 /* Wrapper around abort to make sure emergency cleanups are run. */ 938 void gpgrt_abort (void) GPGRT_ATTR_NORETURN; 939 940 941 942 /* 943 * Constructor and accessor functions. 944 */ 945 946 /* Construct an error value from an error code and source. Within a 947 * subsystem, use gpg_error. */ 948 static GPG_ERR_INLINE gpg_error_t 949 gpg_err_make (gpg_err_source_t source, gpg_err_code_t code) 950 { 951 return code == GPG_ERR_NO_ERROR ? GPG_ERR_NO_ERROR 952 : (((source & GPG_ERR_SOURCE_MASK) << GPG_ERR_SOURCE_SHIFT) 953 | (code & GPG_ERR_CODE_MASK)); 954 } 955 956 957 /* The user should define GPG_ERR_SOURCE_DEFAULT before including this 958 * file to specify a default source for gpg_error. */ 959 #ifndef GPG_ERR_SOURCE_DEFAULT 960 #define GPG_ERR_SOURCE_DEFAULT GPG_ERR_SOURCE_UNKNOWN 961 #endif 962 963 static GPG_ERR_INLINE gpg_error_t 964 gpg_error (gpg_err_code_t code) 965 { 966 return gpg_err_make (GPG_ERR_SOURCE_DEFAULT, code); 967 } 968 969 970 /* Retrieve the error code from an error value. */ 971 static GPG_ERR_INLINE gpg_err_code_t 972 gpg_err_code (gpg_error_t err) 973 { 974 return (gpg_err_code_t) (err & GPG_ERR_CODE_MASK); 975 } 976 977 978 /* Retrieve the error source from an error value. */ 979 static GPG_ERR_INLINE gpg_err_source_t 980 gpg_err_source (gpg_error_t err) 981 { 982 return (gpg_err_source_t) ((err >> GPG_ERR_SOURCE_SHIFT) 983 & GPG_ERR_SOURCE_MASK); 984 } 985 986 987 /* String functions. */ 988 989 /* Return a pointer to a string containing a description of the error 990 * code in the error value ERR. This function is not thread-safe. */ 991 const char *gpg_strerror (gpg_error_t err); 992 993 /* Return the error string for ERR in the user-supplied buffer BUF of 994 * size BUFLEN. This function is, in contrast to gpg_strerror, 995 * thread-safe if a thread-safe strerror_r() function is provided by 996 * the system. If the function succeeds, 0 is returned and BUF 997 * contains the string describing the error. If the buffer was not 998 * large enough, ERANGE is returned and BUF contains as much of the 999 * beginning of the error string as fits into the buffer. */ 1000 int gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen); 1001 1002 /* Return a pointer to a string containing a description of the error 1003 * source in the error value ERR. */ 1004 const char *gpg_strsource (gpg_error_t err); 1005 1006 1007 /* 1008 * Mapping of system errors (errno). 1009 */ 1010 1011 /* Retrieve the error code for the system error ERR. This returns 1012 * GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report 1013 * this). */ 1014 gpg_err_code_t gpg_err_code_from_errno (int err); 1015 1016 /* Retrieve the system error for the error code CODE. This returns 0 1017 * if CODE is not a system error code. */ 1018 int gpg_err_code_to_errno (gpg_err_code_t code); 1019 1020 /* Retrieve the error code directly from the ERRNO variable. This 1021 * returns GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped 1022 * (report this) and GPG_ERR_MISSING_ERRNO if ERRNO has the value 0. */ 1023 gpg_err_code_t gpg_err_code_from_syserror (void); 1024 1025 /* Mapper for SQLite primary error codes. */ 1026 static GPG_ERR_INLINE gpg_error_t 1027 gpg_err_code_from_sqlite (int sqlres) 1028 { 1029 return sqlres? GPG_ERR_SQL_OK + (sqlres & 0xff) : 0; 1030 } 1031 1032 1033 /* Set the ERRNO variable. This function is the preferred way to set 1034 * ERRNO due to peculiarities on WindowsCE. */ 1035 void gpg_err_set_errno (int err); 1036 1037 /* Return or check the version. Both functions are identical. */ 1038 const char *gpgrt_check_version (const char *req_version); 1039 const char *gpg_error_check_version (const char *req_version); 1040 1041 /* System specific type definitions. */ 1042 #include <sys/types.h> 1043 typedef pid_t gpgrt_process_t; 1044 1045 typedef ssize_t gpgrt_ssize_t; 1046 1047 typedef long gpgrt_off_t; 1048 1049 1050 1051 1052 /* Self-documenting convenience functions. */ 1053 1054 static GPG_ERR_INLINE gpg_error_t 1055 gpg_err_make_from_errno (gpg_err_source_t source, int err) 1056 { 1057 return gpg_err_make (source, gpg_err_code_from_errno (err)); 1058 } 1059 1060 1061 static GPG_ERR_INLINE gpg_error_t 1062 gpg_error_from_errno (int err) 1063 { 1064 return gpg_error (gpg_err_code_from_errno (err)); 1065 } 1066 1067 static GPG_ERR_INLINE gpg_error_t 1068 gpg_error_from_syserror (void) 1069 { 1070 return gpg_error (gpg_err_code_from_syserror ()); 1071 } 1072 1073 1074 1075 /* 1076 * Malloc and friends 1077 */ 1078 1079 void *gpgrt_realloc (void *a, size_t n); 1080 void *gpgrt_reallocarray (void *a, size_t oldnmemb, size_t nmemb, size_t size); 1081 void *gpgrt_malloc (size_t n); 1082 void *gpgrt_calloc (size_t n, size_t m); 1083 char *gpgrt_strdup (const char *string); 1084 char *gpgrt_strconcat (const char *s1, ...) GPGRT_ATTR_SENTINEL(0); 1085 void gpgrt_free (void *a); 1086 void gpgrt_wipememory (void *ptr, size_t len); 1087 1088 1089 /* 1090 * System specific function wrappers. 1091 */ 1092 1093 /* A getenv replacement which mallocs the returned string. */ 1094 char *gpgrt_getenv (const char *name); 1095 1096 /* A setenv and a unsetenv replacement.*/ 1097 gpg_err_code_t gpgrt_setenv (const char *name, 1098 const char *value, int overwrite); 1099 #define gpgrt_unsetenv(n) gpgrt_setenv ((n), NULL, 1) 1100 1101 /* A wrapper around mkdir using a string for the mode. */ 1102 gpg_err_code_t gpgrt_mkdir (const char *name, const char *modestr); 1103 1104 /* A simple wrapper around chdir. */ 1105 gpg_err_code_t gpgrt_chdir (const char *name); 1106 1107 /* Return the current WD as a malloced string. */ 1108 char *gpgrt_getcwd (void); 1109 1110 /* A wrapper around access to handle UTF-8 on Windows. */ 1111 gpg_err_code_t gpgrt_access (const char *fname, int mode); 1112 1113 1114 1115 1116 /* 1117 * Lock functions. 1118 */ 1119 1120 1121 typedef struct 1122 { 1123 long _vers; 1124 union { 1125 volatile char _priv[40]; 1126 long _x_align; 1127 long *_xp_align; 1128 } u; 1129 } gpgrt_lock_t; 1130 1131 #define GPGRT_LOCK_INITIALIZER {1,{{0,0,0,0,0,0,0,0, \ 1132 0,0,0,0,0,0,0,0, \ 1133 0,0,0,0,0,0,0,0, \ 1134 0,0,0,0,0,0,0,0, \ 1135 0,0,0,0,0,0,0,0}}} 1136 1137 1138 #define GPGRT_LOCK_DEFINE(name) \ 1139 static gpgrt_lock_t name = GPGRT_LOCK_INITIALIZER 1140 1141 /* NB: If GPGRT_LOCK_DEFINE is not used, zero out the lock variable 1142 before passing it to gpgrt_lock_init. */ 1143 gpg_err_code_t gpgrt_lock_init (gpgrt_lock_t *lockhd); 1144 gpg_err_code_t gpgrt_lock_lock (gpgrt_lock_t *lockhd); 1145 gpg_err_code_t gpgrt_lock_trylock (gpgrt_lock_t *lockhd); 1146 gpg_err_code_t gpgrt_lock_unlock (gpgrt_lock_t *lockhd); 1147 gpg_err_code_t gpgrt_lock_destroy (gpgrt_lock_t *lockhd); 1148 1149 1150 1151 /* 1152 * Thread functions. 1153 */ 1154 1155 gpg_err_code_t gpgrt_yield (void); 1156 1157 1158 1159 1160 /* 1161 * Estream 1162 */ 1163 1164 /* The definition of this struct is entirely private. You must not 1165 use it for anything. It is only here so some functions can be 1166 implemented as macros. */ 1167 struct _gpgrt_stream_internal; 1168 struct _gpgrt__stream 1169 { 1170 /* The layout of this struct must never change. It may be grown, 1171 but only if all functions which access the new members are 1172 versioned. */ 1173 1174 /* Various flags. */ 1175 struct { 1176 unsigned int magic: 16; 1177 unsigned int writing: 1; 1178 unsigned int reserved: 15; 1179 } flags; 1180 1181 /* A pointer to the stream buffer. */ 1182 unsigned char *buffer; 1183 1184 /* The size of the buffer in bytes. */ 1185 size_t buffer_size; 1186 1187 /* The length of the usable data in the buffer, only valid when in 1188 read mode (see flags). */ 1189 size_t data_len; 1190 1191 /* The current position of the offset pointer, valid in read and 1192 write mode. */ 1193 size_t data_offset; 1194 1195 size_t data_flushed; 1196 unsigned char *unread_buffer; 1197 size_t unread_buffer_size; 1198 1199 /* The number of unread bytes. */ 1200 size_t unread_data_len; 1201 1202 /* A pointer to our internal data for this stream. */ 1203 struct _gpgrt_stream_internal *intern; 1204 }; 1205 1206 /* The opaque type for an estream. */ 1207 typedef struct _gpgrt__stream *gpgrt_stream_t; 1208 #ifdef GPGRT_ENABLE_ES_MACROS 1209 typedef struct _gpgrt__stream *estream_t; 1210 #endif 1211 1212 typedef ssize_t (*gpgrt_cookie_read_function_t) (void *cookie, 1213 void *buffer, size_t size); 1214 typedef ssize_t (*gpgrt_cookie_write_function_t) (void *cookie, 1215 const void *buffer, 1216 size_t size); 1217 typedef int (*gpgrt_cookie_seek_function_t) (void *cookie, 1218 gpgrt_off_t *pos, int whence); 1219 typedef int (*gpgrt_cookie_close_function_t) (void *cookie); 1220 1221 struct _gpgrt_cookie_io_functions 1222 { 1223 gpgrt_cookie_read_function_t func_read; 1224 gpgrt_cookie_write_function_t func_write; 1225 gpgrt_cookie_seek_function_t func_seek; 1226 gpgrt_cookie_close_function_t func_close; 1227 }; 1228 typedef struct _gpgrt_cookie_io_functions gpgrt_cookie_io_functions_t; 1229 #ifdef GPGRT_ENABLE_ES_MACROS 1230 typedef struct _gpgrt_cookie_io_functions es_cookie_io_functions_t; 1231 #define es_cookie_read_function_t gpgrt_cookie_read_function_t 1232 #define es_cookie_write_function_t gpgrt_cookie_read_function_t 1233 #define es_cookie_seek_function_t gpgrt_cookie_read_function_t 1234 #define es_cookie_close_function_t gpgrt_cookie_read_function_t 1235 #endif 1236 1237 enum gpgrt_syshd_types 1238 { 1239 GPGRT_SYSHD_NONE = 0, /* No system handle available. */ 1240 GPGRT_SYSHD_FD = 1, /* A file descriptor as returned by open(). */ 1241 GPGRT_SYSHD_SOCK = 2, /* A socket as returned by socket(). */ 1242 GPGRT_SYSHD_RVID = 3, /* A rendezvous id (see libassuan's gpgcedev.c). */ 1243 GPGRT_SYSHD_HANDLE = 4 /* A HANDLE object (Windows). */ 1244 }; 1245 1246 struct _gpgrt_syshd 1247 { 1248 enum gpgrt_syshd_types type; 1249 union { 1250 int fd; 1251 int sock; 1252 int rvid; 1253 void *handle; 1254 } u; 1255 }; 1256 typedef struct _gpgrt_syshd gpgrt_syshd_t; 1257 #ifdef GPGRT_ENABLE_ES_MACROS 1258 typedef struct _gpgrt_syshd es_syshd_t; 1259 #define ES_SYSHD_NONE GPGRT_SYSHD_NONE 1260 #define ES_SYSHD_FD GPGRT_SYSHD_FD 1261 #define ES_SYSHD_SOCK GPGRT_SYSHD_SOCK 1262 #define ES_SYSHD_RVID GPGRT_SYSHD_RVID 1263 #define ES_SYSHD_HANDLE GPGRT_SYSHD_HANDLE 1264 #endif 1265 1266 /* The object used with gpgrt_poll. */ 1267 struct _gpgrt_poll_s 1268 { 1269 gpgrt_stream_t stream; 1270 unsigned int want_read:1; 1271 unsigned int want_write:1; 1272 unsigned int want_oob:1; 1273 unsigned int want_rdhup:1; 1274 unsigned int _reserv1:4; 1275 unsigned int got_read:1; 1276 unsigned int got_write:1; 1277 unsigned int got_oob:1; 1278 unsigned int got_rdhup:1; 1279 unsigned int _reserv2:4; 1280 unsigned int got_err:1; 1281 unsigned int got_hup:1; 1282 unsigned int got_nval:1; 1283 unsigned int _reserv3:4; 1284 unsigned int ignore:1; 1285 unsigned int user:8; /* For application use. */ 1286 }; 1287 typedef struct _gpgrt_poll_s gpgrt_poll_t; 1288 #ifdef GPGRT_ENABLE_ES_MACROS 1289 typedef struct _gpgrt_poll_s es_poll_t; 1290 #endif 1291 1292 /* The type of the string filter function as used by fprintf_sf et al. */ 1293 typedef char *(*gpgrt_string_filter_t) (const char *s, int n, void *opaque); 1294 1295 1296 1297 gpgrt_stream_t gpgrt_fopen (const char *_GPGRT__RESTRICT path, 1298 const char *_GPGRT__RESTRICT mode); 1299 gpgrt_stream_t gpgrt_mopen (void *_GPGRT__RESTRICT data, 1300 size_t data_n, size_t data_len, 1301 unsigned int grow, 1302 void *(*func_realloc) (void *mem, size_t size), 1303 void (*func_free) (void *mem), 1304 const char *_GPGRT__RESTRICT mode); 1305 gpgrt_stream_t gpgrt_fopenmem (size_t memlimit, 1306 const char *_GPGRT__RESTRICT mode); 1307 gpgrt_stream_t gpgrt_fopenmem_init (size_t memlimit, 1308 const char *_GPGRT__RESTRICT mode, 1309 const void *data, size_t datalen); 1310 gpgrt_stream_t gpgrt_fdopen (int filedes, const char *mode); 1311 gpgrt_stream_t gpgrt_fdopen_nc (int filedes, const char *mode); 1312 gpgrt_stream_t gpgrt_sysopen (gpgrt_syshd_t *syshd, const char *mode); 1313 gpgrt_stream_t gpgrt_sysopen_nc (gpgrt_syshd_t *syshd, const char *mode); 1314 gpgrt_stream_t gpgrt_fpopen (FILE *fp, const char *mode); 1315 gpgrt_stream_t gpgrt_fpopen_nc (FILE *fp, const char *mode); 1316 gpgrt_stream_t gpgrt_freopen (const char *_GPGRT__RESTRICT path, 1317 const char *_GPGRT__RESTRICT mode, 1318 gpgrt_stream_t _GPGRT__RESTRICT stream); 1319 gpgrt_stream_t gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie, 1320 const char *_GPGRT__RESTRICT mode, 1321 gpgrt_cookie_io_functions_t functions); 1322 int gpgrt_fclose (gpgrt_stream_t stream); 1323 int gpgrt_fcancel (gpgrt_stream_t stream); 1324 int gpgrt_fclose_snatch (gpgrt_stream_t stream, 1325 void **r_buffer, size_t *r_buflen); 1326 int gpgrt_onclose (gpgrt_stream_t stream, int mode, 1327 void (*fnc) (gpgrt_stream_t, void*), void *fnc_value); 1328 int gpgrt_fileno (gpgrt_stream_t stream); 1329 int gpgrt_fileno_unlocked (gpgrt_stream_t stream); 1330 int gpgrt_syshd (gpgrt_stream_t stream, gpgrt_syshd_t *syshd); 1331 int gpgrt_syshd_unlocked (gpgrt_stream_t stream, gpgrt_syshd_t *syshd); 1332 1333 void _gpgrt_set_std_fd (int no, int fd); 1334 gpgrt_stream_t _gpgrt_get_std_stream (int fd); 1335 1336 #define gpgrt_stdin _gpgrt_get_std_stream (0) 1337 #define gpgrt_stdout _gpgrt_get_std_stream (1) 1338 #define gpgrt_stderr _gpgrt_get_std_stream (2) 1339 1340 1341 void gpgrt_flockfile (gpgrt_stream_t stream); 1342 int gpgrt_ftrylockfile (gpgrt_stream_t stream); 1343 void gpgrt_funlockfile (gpgrt_stream_t stream); 1344 1345 int gpgrt_feof (gpgrt_stream_t stream); 1346 int gpgrt_feof_unlocked (gpgrt_stream_t stream); 1347 int gpgrt_ferror (gpgrt_stream_t stream); 1348 int gpgrt_ferror_unlocked (gpgrt_stream_t stream); 1349 void gpgrt_clearerr (gpgrt_stream_t stream); 1350 void gpgrt_clearerr_unlocked (gpgrt_stream_t stream); 1351 1352 int _gpgrt_pending (gpgrt_stream_t stream); /* (private) */ 1353 int _gpgrt_pending_unlocked (gpgrt_stream_t stream); /* (private) */ 1354 1355 #define gpgrt_pending(stream) _gpgrt_pending (stream) 1356 1357 #define gpgrt_pending_unlocked(stream) \ 1358 (((!(stream)->flags.writing) \ 1359 && (((stream)->data_offset < (stream)->data_len) \ 1360 || ((stream)->unread_data_len))) \ 1361 ? 1 : _gpgrt_pending_unlocked ((stream))) 1362 1363 int gpgrt_fflush (gpgrt_stream_t stream); 1364 int gpgrt_fseek (gpgrt_stream_t stream, long int offset, int whence); 1365 int gpgrt_fseeko (gpgrt_stream_t stream, gpgrt_off_t offset, int whence); 1366 int gpgrt_ftruncate (gpgrt_stream_t stream, gpgrt_off_t length); 1367 long int gpgrt_ftell (gpgrt_stream_t stream); 1368 gpgrt_off_t gpgrt_ftello (gpgrt_stream_t stream); 1369 void gpgrt_rewind (gpgrt_stream_t stream); 1370 1371 int gpgrt_fgetc (gpgrt_stream_t stream); 1372 int gpgrt_fputc (int c, gpgrt_stream_t stream); 1373 1374 int _gpgrt_getc_underflow (gpgrt_stream_t stream); /* (private) */ 1375 int _gpgrt_putc_overflow (int c, gpgrt_stream_t stream); /* (private) */ 1376 1377 #define gpgrt_getc_unlocked(stream) \ 1378 (((!(stream)->flags.writing) \ 1379 && ((stream)->data_offset < (stream)->data_len) \ 1380 && (! (stream)->unread_data_len)) \ 1381 ? ((int) (stream)->buffer[((stream)->data_offset)++]) \ 1382 : _gpgrt_getc_underflow ((stream))) 1383 1384 #define gpgrt_putc_unlocked(c, stream) \ 1385 (((stream)->flags.writing \ 1386 && ((stream)->data_offset < (stream)->buffer_size) \ 1387 && (c != '\n')) \ 1388 ? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \ 1389 : _gpgrt_putc_overflow ((c), (stream))) 1390 1391 #define gpgrt_getc(stream) gpgrt_fgetc (stream) 1392 #define gpgrt_putc(c, stream) gpgrt_fputc (c, stream) 1393 1394 int gpgrt_ungetc (int c, gpgrt_stream_t stream); 1395 1396 int gpgrt_read (gpgrt_stream_t _GPGRT__RESTRICT stream, 1397 void *_GPGRT__RESTRICT buffer, size_t bytes_to_read, 1398 size_t *_GPGRT__RESTRICT bytes_read); 1399 int gpgrt_write (gpgrt_stream_t _GPGRT__RESTRICT stream, 1400 const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write, 1401 size_t *_GPGRT__RESTRICT bytes_written); 1402 int gpgrt_write_sanitized (gpgrt_stream_t _GPGRT__RESTRICT stream, 1403 const void *_GPGRT__RESTRICT buffer, size_t length, 1404 const char *delimiters, 1405 size_t *_GPGRT__RESTRICT bytes_written); 1406 int gpgrt_write_hexstring (gpgrt_stream_t _GPGRT__RESTRICT stream, 1407 const void *_GPGRT__RESTRICT buffer, size_t length, 1408 int reserved, 1409 size_t *_GPGRT__RESTRICT bytes_written); 1410 1411 size_t gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems, 1412 gpgrt_stream_t _GPGRT__RESTRICT stream); 1413 size_t gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size, 1414 size_t nitems, gpgrt_stream_t _GPGRT__RESTRICT stream); 1415 1416 char *gpgrt_fgets (char *_GPGRT__RESTRICT s, int n, 1417 gpgrt_stream_t _GPGRT__RESTRICT stream); 1418 int gpgrt_fputs (const char *_GPGRT__RESTRICT s, 1419 gpgrt_stream_t _GPGRT__RESTRICT stream); 1420 int gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s, 1421 gpgrt_stream_t _GPGRT__RESTRICT stream); 1422 1423 ssize_t gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr, 1424 size_t *_GPGRT__RESTRICT n, 1425 gpgrt_stream_t stream); 1426 ssize_t gpgrt_read_line (gpgrt_stream_t stream, 1427 char **addr_of_buffer, size_t *length_of_buffer, 1428 size_t *max_length); 1429 1430 int gpgrt_fprintf (gpgrt_stream_t _GPGRT__RESTRICT stream, 1431 const char *_GPGRT__RESTRICT format, ...) 1432 GPGRT_ATTR_PRINTF(2,3); 1433 int gpgrt_fprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream, 1434 const char *_GPGRT__RESTRICT format, ...) 1435 GPGRT_ATTR_PRINTF(2,3); 1436 1437 int gpgrt_fprintf_sf (gpgrt_stream_t _GPGRT__RESTRICT stream, 1438 gpgrt_string_filter_t sf, void *sfvalue, 1439 const char *_GPGRT__RESTRICT format, 1440 ...) GPGRT_ATTR_PRINTF(4,5); 1441 int gpgrt_fprintf_sf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream, 1442 gpgrt_string_filter_t sf, void *sfvalue, 1443 const char *_GPGRT__RESTRICT format, 1444 ...) GPGRT_ATTR_PRINTF(4,5); 1445 1446 int gpgrt_printf (const char *_GPGRT__RESTRICT format, ...) 1447 GPGRT_ATTR_PRINTF(1,2); 1448 int gpgrt_printf_unlocked (const char *_GPGRT__RESTRICT format, ...) 1449 GPGRT_ATTR_PRINTF(1,2); 1450 1451 int gpgrt_vfprintf (gpgrt_stream_t _GPGRT__RESTRICT stream, 1452 const char *_GPGRT__RESTRICT format, va_list ap) 1453 GPGRT_ATTR_PRINTF(2,0); 1454 int gpgrt_vfprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream, 1455 const char *_GPGRT__RESTRICT format, va_list ap) 1456 GPGRT_ATTR_PRINTF(2,0); 1457 1458 int gpgrt_setvbuf (gpgrt_stream_t _GPGRT__RESTRICT stream, 1459 char *_GPGRT__RESTRICT buf, int mode, size_t size); 1460 void gpgrt_setbuf (gpgrt_stream_t _GPGRT__RESTRICT stream, 1461 char *_GPGRT__RESTRICT buf); 1462 1463 void gpgrt_set_binary (gpgrt_stream_t stream); 1464 int gpgrt_set_nonblock (gpgrt_stream_t stream, int onoff); 1465 int gpgrt_get_nonblock (gpgrt_stream_t stream); 1466 1467 int gpgrt_poll (gpgrt_poll_t *fdlist, unsigned int nfds, int timeout); 1468 1469 gpgrt_stream_t gpgrt_tmpfile (void); 1470 1471 void gpgrt_opaque_set (gpgrt_stream_t _GPGRT__RESTRICT stream, 1472 void *_GPGRT__RESTRICT opaque); 1473 void *gpgrt_opaque_get (gpgrt_stream_t stream); 1474 1475 void gpgrt_fname_set (gpgrt_stream_t stream, const char *fname); 1476 const char *gpgrt_fname_get (gpgrt_stream_t stream); 1477 1478 int gpgrt_asprintf (char **r_buf, const char * _GPGRT__RESTRICT format, ...) 1479 GPGRT_ATTR_PRINTF(2,3); 1480 int gpgrt_vasprintf (char **r_buf, const char * _GPGRT__RESTRICT format, 1481 va_list ap) 1482 GPGRT_ATTR_PRINTF(2,0); 1483 char *gpgrt_bsprintf (const char * _GPGRT__RESTRICT format, ...) 1484 GPGRT_ATTR_PRINTF(1,2); 1485 char *gpgrt_vbsprintf (const char * _GPGRT__RESTRICT format, va_list ap) 1486 GPGRT_ATTR_PRINTF(1,0); 1487 int gpgrt_snprintf (char *buf, size_t bufsize, 1488 const char * _GPGRT__RESTRICT format, ...) 1489 GPGRT_ATTR_PRINTF(3,4); 1490 int gpgrt_vsnprintf (char *buf,size_t bufsize, 1491 const char * _GPGRT__RESTRICT format, va_list arg_ptr) 1492 GPGRT_ATTR_PRINTF(3,0); 1493 1494 1495 #ifdef GPGRT_ENABLE_ES_MACROS 1496 # define es_fopen gpgrt_fopen 1497 # define es_mopen gpgrt_mopen 1498 # define es_fopenmem gpgrt_fopenmem 1499 # define es_fopenmem_init gpgrt_fopenmem_init 1500 # define es_fdopen gpgrt_fdopen 1501 # define es_fdopen_nc gpgrt_fdopen_nc 1502 # define es_sysopen gpgrt_sysopen 1503 # define es_sysopen_nc gpgrt_sysopen_nc 1504 # define es_fpopen gpgrt_fpopen 1505 # define es_fpopen_nc gpgrt_fpopen_nc 1506 # define es_freopen gpgrt_freopen 1507 # define es_fopencookie gpgrt_fopencookie 1508 # define es_fclose gpgrt_fclose 1509 # define es_fclose_snatch gpgrt_fclose_snatch 1510 # define es_onclose gpgrt_onclose 1511 # define es_fileno gpgrt_fileno 1512 # define es_fileno_unlocked gpgrt_fileno_unlocked 1513 # define es_syshd gpgrt_syshd 1514 # define es_syshd_unlocked gpgrt_syshd_unlocked 1515 # define es_stdin _gpgrt_get_std_stream (0) 1516 # define es_stdout _gpgrt_get_std_stream (1) 1517 # define es_stderr _gpgrt_get_std_stream (2) 1518 # define es_flockfile gpgrt_flockfile 1519 # define es_ftrylockfile gpgrt_ftrylockfile 1520 # define es_funlockfile gpgrt_funlockfile 1521 # define es_feof gpgrt_feof 1522 # define es_feof_unlocked gpgrt_feof_unlocked 1523 # define es_ferror gpgrt_ferror 1524 # define es_ferror_unlocked gpgrt_ferror_unlocked 1525 # define es_clearerr gpgrt_clearerr 1526 # define es_clearerr_unlocked gpgrt_clearerr_unlocked 1527 # define es_pending gpgrt_pending 1528 # define es_pending_unlocked gpgrt_pending_unlocked 1529 # define es_fflush gpgrt_fflush 1530 # define es_fseek gpgrt_fseek 1531 # define es_fseeko gpgrt_fseeko 1532 # define es_ftruncate gpgrt_ftruncate 1533 # define es_ftell gpgrt_ftell 1534 # define es_ftello gpgrt_ftello 1535 # define es_rewind gpgrt_rewind 1536 # define es_fgetc gpgrt_fgetc 1537 # define es_fputc gpgrt_fputc 1538 # define es_getc_unlocked gpgrt_getc_unlocked 1539 # define es_putc_unlocked gpgrt_putc_unlocked 1540 # define es_getc gpgrt_getc 1541 # define es_putc gpgrt_putc 1542 # define es_ungetc gpgrt_ungetc 1543 # define es_read gpgrt_read 1544 # define es_write gpgrt_write 1545 # define es_write_sanitized gpgrt_write_sanitized 1546 # define es_write_hexstring gpgrt_write_hexstring 1547 # define es_fread gpgrt_fread 1548 # define es_fwrite gpgrt_fwrite 1549 # define es_fgets gpgrt_fgets 1550 # define es_fputs gpgrt_fputs 1551 # define es_fputs_unlocked gpgrt_fputs_unlocked 1552 # define es_getline gpgrt_getline 1553 # define es_read_line gpgrt_read_line 1554 # define es_free gpgrt_free 1555 # define es_fprintf gpgrt_fprintf 1556 # define es_fprintf_unlocked gpgrt_fprintf_unlocked 1557 # define es_printf gpgrt_printf 1558 # define es_printf_unlocked gpgrt_printf_unlocked 1559 # define es_vfprintf gpgrt_vfprintf 1560 # define es_vfprintf_unlocked gpgrt_vfprintf_unlocked 1561 # define es_setvbuf gpgrt_setvbuf 1562 # define es_setbuf gpgrt_setbuf 1563 # define es_set_binary gpgrt_set_binary 1564 # define es_set_nonblock gpgrt_set_nonblock 1565 # define es_get_nonblock gpgrt_get_nonblock 1566 # define es_poll gpgrt_poll 1567 # define es_tmpfile gpgrt_tmpfile 1568 # define es_opaque_set gpgrt_opaque_set 1569 # define es_opaque_get gpgrt_opaque_get 1570 # define es_fname_set gpgrt_fname_set 1571 # define es_fname_get gpgrt_fname_get 1572 # define es_asprintf gpgrt_asprintf 1573 # define es_vasprintf gpgrt_vasprintf 1574 # define es_bsprintf gpgrt_bsprintf 1575 # define es_vbsprintf gpgrt_vbsprintf 1576 #endif /*GPGRT_ENABLE_ES_MACROS*/ 1577 1578 1579 1580 /* 1581 * Base64 encode and decode functions. 1582 */ 1583 1584 struct _gpgrt_b64state; 1585 typedef struct _gpgrt_b64state *gpgrt_b64state_t; 1586 1587 gpgrt_b64state_t gpgrt_b64enc_start (gpgrt_stream_t stream, const char *title); 1588 gpg_err_code_t gpgrt_b64enc_write (gpgrt_b64state_t state, 1589 const void *buffer, size_t nbytes); 1590 gpg_err_code_t gpgrt_b64enc_finish (gpgrt_b64state_t state); 1591 1592 gpgrt_b64state_t gpgrt_b64dec_start (const char *title); 1593 gpg_error_t gpgrt_b64dec_proc (gpgrt_b64state_t state, 1594 void *buffer, size_t length, 1595 size_t *r_nbytes); 1596 gpg_error_t gpgrt_b64dec_finish (gpgrt_b64state_t state); 1597 1598 1599 1600 /* 1601 * Logging functions 1602 */ 1603 1604 /* Flag values for gpgrt_log_set_prefix. */ 1605 #define GPGRT_LOG_WITH_PREFIX 1 1606 #define GPGRT_LOG_WITH_TIME 2 1607 #define GPGRT_LOG_WITH_PID 4 1608 #define GPGRT_LOG_RUN_DETACHED 256 1609 #define GPGRT_LOG_NO_REGISTRY 512 1610 1611 /* Log levels as used by gpgrt_log. */ 1612 enum gpgrt_log_levels 1613 { 1614 GPGRT_LOGLVL_BEGIN, 1615 GPGRT_LOGLVL_CONT, 1616 GPGRT_LOGLVL_INFO, 1617 GPGRT_LOGLVL_WARN, 1618 GPGRT_LOGLVL_ERROR, 1619 GPGRT_LOGLVL_FATAL, 1620 GPGRT_LOGLVL_BUG, 1621 GPGRT_LOGLVL_DEBUG 1622 }; 1623 1624 1625 /* The next 5 functions are not thread-safe - call them early. */ 1626 void gpgrt_log_set_sink (const char *name, gpgrt_stream_t stream, int fd); 1627 void gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void)); 1628 void gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value)); 1629 void gpgrt_log_set_prefix (const char *text, unsigned int flags); 1630 void gpgrt_add_post_log_func (void (*f)(int)); 1631 1632 int gpgrt_get_errorcount (int clear); 1633 void gpgrt_inc_errorcount (void); 1634 const char *gpgrt_log_get_prefix (unsigned int *flags); 1635 int gpgrt_log_test_fd (int fd); 1636 int gpgrt_log_get_fd (void); 1637 gpgrt_stream_t gpgrt_log_get_stream (void); 1638 1639 void gpgrt_log (int level, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3); 1640 void gpgrt_logv (int level, const char *fmt, 1641 va_list arg_ptr) GPGRT_ATTR_PRINTF(2,0); 1642 void gpgrt_logv_prefix (int level, const char *prefix, const char *fmt, 1643 va_list arg_ptr) GPGRT_ATTR_PRINTF(3,0); 1644 void gpgrt_logv_domain (const char *domain, int level, const char *prefix, 1645 const void *buffer, size_t length, const char *fmt, 1646 va_list arg_ptr) GPGRT_ATTR_PRINTF(6,0); 1647 void gpgrt_log_string (int level, const char *string); 1648 void gpgrt_log_bug (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2); 1649 void gpgrt_log_fatal (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2); 1650 void gpgrt_log_error (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); 1651 void gpgrt_log_info (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); 1652 void gpgrt_log_debug (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); 1653 void gpgrt_log_debug_string (const char *string, 1654 const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3); 1655 void gpgrt_log_printf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); 1656 void gpgrt_log_printhex (const void *buffer, size_t length, 1657 const char *fmt, ...) GPGRT_ATTR_PRINTF(3,4); 1658 void gpgrt_log_clock (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); 1659 void gpgrt_log_flush (void); 1660 void _gpgrt_log_assert (const char *expr, const char *file, int line, 1661 const char *func) GPGRT_ATTR_NORETURN; 1662 1663 #ifdef GPGRT_HAVE_MACRO_FUNCTION 1664 # define gpgrt_assert(expr) \ 1665 ((expr) \ 1666 ? (void) 0 \ 1667 : _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__)) 1668 #else /*!GPGRT_HAVE_MACRO_FUNCTION*/ 1669 # define gpgrt_assert(expr) \ 1670 ((expr) \ 1671 ? (void) 0 \ 1672 : _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL)) 1673 #endif /*!GPGRT_HAVE_MACRO_FUNCTION*/ 1674 1675 #ifdef GPGRT_ENABLE_LOG_MACROS 1676 # define log_get_errorcount gpgrt_get_errorcount 1677 # define log_inc_errorcount gpgrt_inc_errorcount 1678 # define log_set_file(a) gpgrt_log_set_sink ((a), NULL, -1) 1679 # define log_set_fd(a) gpgrt_log_set_sink (NULL, NULL, (a)) 1680 # define log_set_stream(a) gpgrt_log_set_sink (NULL, (a), -1) 1681 # define log_set_socket_dir_cb gpgrt_log_set_socket_dir_cb 1682 # define log_set_pid_suffix_cb gpgrt_log_set_pid_suffix_cb 1683 # define log_set_prefix gpgrt_log_set_prefix 1684 # define log_get_prefix gpgrt_log_get_prefix 1685 # define log_test_fd gpgrt_log_test_fd 1686 # define log_get_fd gpgrt_log_get_fd 1687 # define log_get_stream gpgrt_log_get_stream 1688 # define log_log gpgrt_log 1689 # define log_logv gpgrt_logv 1690 # define log_logv_prefix gpgrt_logv_prefix 1691 # define log_string gpgrt_log_string 1692 # define log_bug gpgrt_log_bug 1693 # define log_fatal gpgrt_log_fatal 1694 # define log_error gpgrt_log_error 1695 # define log_info gpgrt_log_info 1696 # define log_debug gpgrt_log_debug 1697 # define log_debug_string gpgrt_log_debug_string 1698 # define log_printf gpgrt_log_printf 1699 # define log_printhex gpgrt_log_printhex 1700 # define log_clock gpgrt_log_clock 1701 # define log_flush gpgrt_log_flush 1702 # ifdef GPGRT_HAVE_MACRO_FUNCTION 1703 # define log_assert(expr) \ 1704 ((expr) \ 1705 ? (void) 0 \ 1706 : _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__)) 1707 # else /*!GPGRT_HAVE_MACRO_FUNCTION*/ 1708 # define log_assert(expr) \ 1709 ((expr) \ 1710 ? (void) 0 \ 1711 : _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL)) 1712 # endif /*!GPGRT_HAVE_MACRO_FUNCTION*/ 1713 1714 #endif /*GPGRT_ENABLE_LOG_MACROS*/ 1715 1716 1717 /* 1718 * Spawn functions (Not yet available) 1719 */ 1720 /* Internal flag to inherit file descriptor/handle */ 1721 #define GPGRT_SPAWN_INHERIT_FILE 1 1722 1723 #define GPGRT_SPAWN_NONBLOCK 16 /* Set the streams to non-blocking. */ 1724 #define GPGRT_SPAWN_RUN_ASFW 64 /* Use AllowSetForegroundWindow on W32. */ 1725 #define GPGRT_SPAWN_DETACHED 128 /* Start the process in the background. */ 1726 #define GPGRT_SPAWN_KEEP_STDIN 256 1727 #define GPGRT_SPAWN_KEEP_STDOUT 512 1728 #define GPGRT_SPAWN_KEEP_STDERR 1024 1729 1730 #if 0 1731 /* Function and convenience macros to create pipes. */ 1732 gpg_err_code_t gpgrt_make_pipe (int filedes[2], gpgrt_stream_t *r_fp, 1733 int direction, int nonblock); 1734 #define gpgrt_create_pipe(a) gpgrt_make_pipe ((a),NULL, 0, 0); 1735 #define gpgrt_create_inbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), -1,(c)); 1736 #define gpgrt_create_outbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), 1,(c)); 1737 1738 1739 /* Fork and exec PGMNAME. */ 1740 gpg_err_code_t gpgrt_spawn_process (const char *pgmname, const char *argv[], 1741 int *execpt, unsigned int flags, 1742 gpgrt_stream_t *r_infp, 1743 gpgrt_stream_t *r_outfp, 1744 gpgrt_stream_t *r_errfp, 1745 gpgrt_process_t *r_process_id); 1746 1747 /* Fork and exec PGNNAME and connect the process to the given FDs. */ 1748 gpg_err_code_t gpgrt_spawn_process_fd (const char *pgmname, const char *argv[], 1749 int infd, int outfd, int errfd, 1750 int (*spawn_cb) (void *), 1751 void *spawn_cb_arg, 1752 gpgrt_process_t *r_process_id); 1753 1754 /* Fork and exec PGMNAME as a detached process. */ 1755 gpg_err_code_t gpgrt_spawn_process_detached (const char *pgmname, 1756 const char *argv[], 1757 const char *envp[]); 1758 1759 /* Wait for a single process. */ 1760 gpg_err_code_t gpgrt_wait_process (const char *pgmname, 1761 gpgrt_process_t process_id, 1762 int hang, int *r_exitcode); 1763 1764 /* Wait for a multiple processes. */ 1765 gpg_err_code_t gpgrt_wait_processes (const char **pgmnames, 1766 gpgrt_process_t *process_ids, 1767 size_t count, int hang, int *r_exitcodes); 1768 1769 /* Kill the process identified by PROCESS_ID. */ 1770 void gpgrt_kill_process (gpgrt_process_t process_id); 1771 1772 /* Release process resources identified by PROCESS_ID. */ 1773 void gpgrt_release_process (gpgrt_process_t process_id); 1774 1775 /* Close all file resources (descriptors), except KEEP_FDS. */ 1776 void gpgrt_close_all_fds (int from, int *keep_fds); 1777 #endif /*0*/ 1778 1779 /* 1780 * Option parsing. 1781 */ 1782 1783 struct _gpgrt_argparse_internal_s; 1784 typedef struct 1785 { 1786 int *argc; /* Pointer to ARGC (value subject to change). */ 1787 char ***argv; /* Pointer to ARGV (value subject to change). */ 1788 unsigned int flags; /* Global flags. May be set prior to calling the 1789 parser. The parser may change the value. */ 1790 int err; /* Print error description for last option. 1791 Either 0, ARGPARSE_PRINT_WARNING or 1792 ARGPARSE_PRINT_ERROR. */ 1793 unsigned int lineno;/* The current line number. */ 1794 int r_opt; /* Returns option code. */ 1795 int r_type; /* Returns type of option value. */ 1796 union { 1797 int ret_int; 1798 long ret_long; 1799 unsigned long ret_ulong; 1800 char *ret_str; 1801 } r; /* Return values */ 1802 1803 struct _gpgrt_argparse_internal_s *internal; 1804 } gpgrt_argparse_t; 1805 1806 1807 typedef struct 1808 { 1809 int short_opt; 1810 const char *long_opt; 1811 unsigned int flags; 1812 const char *description; /* Optional description. */ 1813 } gpgrt_opt_t; 1814 1815 1816 #ifdef GPGRT_ENABLE_ARGPARSE_MACROS 1817 1818 /* Global flags for (gpgrt_argparse_t).flags. */ 1819 #define ARGPARSE_FLAG_KEEP 1 /* Do not remove options form argv. */ 1820 #define ARGPARSE_FLAG_ALL 2 /* Do not stop at last option but return 1821 remaining args with R_OPT set to -1. */ 1822 #define ARGPARSE_FLAG_MIXED 4 /* Assume options and args are mixed. */ 1823 #define ARGPARSE_FLAG_NOSTOP 8 /* Do not stop processing at "--". */ 1824 #define ARGPARSE_FLAG_ARG0 16 /* Do not skip the first arg. */ 1825 #define ARGPARSE_FLAG_ONEDASH 32 /* Allow long options with one dash. */ 1826 #define ARGPARSE_FLAG_NOVERSION 64 /* No output for "--version". */ 1827 #define ARGPARSE_FLAG_RESET 128 /* Request to reset the internal state. */ 1828 #define ARGPARSE_FLAG_STOP_SEEN 256 /* Set to true if a "--" has been seen. */ 1829 #define ARGPARSE_FLAG_NOLINENO 512 /* Do not zero the lineno field. */ 1830 #define ARGPARSE_FLAG_SYS 1024 /* Use system config file. */ 1831 #define ARGPARSE_FLAG_USER 2048 /* Use user config file. */ 1832 #define ARGPARSE_FLAG_VERBOSE 4096 /* Print additional argparser info. */ 1833 #define ARGPARSE_FLAG_USERVERS 8192 /* Try version-ed user config files. */ 1834 #define ARGPARSE_FLAG_WITHATTR 16384 /* Return attribute bits. (Make sure */ 1835 /* to act upon ARGPARSE_OPT_IGNORE.) */ 1836 #define ARGPARSE_FLAG_COMMAND 32768 /* Allow commands w/o leading dashes. */ 1837 1838 1839 /* Constants for (gpgrt_argparse_t).err. */ 1840 #define ARGPARSE_PRINT_WARNING 1 /* Print a diagnostic. */ 1841 #define ARGPARSE_PRINT_ERROR 2 /* Print a diagnostic and call exit. */ 1842 1843 /* Special return values of gpgrt_argparse. */ 1844 #define ARGPARSE_IS_ARG (-1) 1845 #define ARGPARSE_INVALID_OPTION (-2) 1846 #define ARGPARSE_MISSING_ARG (-3) 1847 #define ARGPARSE_KEYWORD_TOO_LONG (-4) 1848 #define ARGPARSE_READ_ERROR (-5) 1849 #define ARGPARSE_UNEXPECTED_ARG (-6) 1850 #define ARGPARSE_INVALID_COMMAND (-7) 1851 #define ARGPARSE_AMBIGUOUS_OPTION (-8) 1852 #define ARGPARSE_AMBIGUOUS_COMMAND (-9) 1853 #define ARGPARSE_INVALID_ALIAS (-10) 1854 #define ARGPARSE_OUT_OF_CORE (-11) 1855 #define ARGPARSE_INVALID_ARG (-12) 1856 #define ARGPARSE_PERMISSION_ERROR (-13) 1857 #define ARGPARSE_NO_CONFFILE (-14) 1858 #define ARGPARSE_CONFFILE (-15) 1859 #define ARGPARSE_INVALID_META (-16) 1860 #define ARGPARSE_UNKNOWN_META (-17) 1861 #define ARGPARSE_UNEXPECTED_META (-18) 1862 1863 /* Flags for the option descriptor (gpgrt_opt_t)->flags. Note that a 1864 * TYPE constant may be or-ed with the OPT constants but when used as 1865 * return value in r_type these OPT constants are normally not 1866 * included. However with ARGPARSE_FLAG_WITHATTR used and an option 1867 * would normally not be returned, it is returned but 1868 * ARGPARSE_OPT_IGNORE is then set; further ARPARSE_ATTR_* are set. 1869 */ 1870 #define ARGPARSE_TYPE_MASK 0x0007 /* Mask for the type bits. */ 1871 #define ARGPARSE_TYPE_NONE 0 /* Does not take an argument. */ 1872 #define ARGPARSE_TYPE_INT 1 /* Takes an int argument. */ 1873 #define ARGPARSE_TYPE_STRING 2 /* Takes a string argument. */ 1874 #define ARGPARSE_TYPE_LONG 3 /* Takes a long argument. */ 1875 #define ARGPARSE_TYPE_ULONG 4 /* Takes an unsigned long argument. */ 1876 #define ARGPARSE_OPT_OPTIONAL (1<<3) /* Argument is optional. */ 1877 #define ARGPARSE_OPT_PREFIX (1<<4) /* Allow 0x etc. prefixed values. */ 1878 #define ARGPARSE_OPT_IGNORE (1<<6) /* Ignore command or option. */ 1879 #define ARGPARSE_OPT_COMMAND (1<<7) /* The argument is a command. */ 1880 #define ARGPARSE_OPT_CONFFILE (1<<8) /* The value is a conffile. */ 1881 #define ARGPARSE_OPT_HEADER (1<<9) /* The value is printed as a header. */ 1882 #define ARGPARSE_OPT_VERBATIM (1<<10)/* The value is printed verbatim. */ 1883 #define ARGPARSE_ATTR_FORCE (1<<14)/* Attribute force is set. */ 1884 #define ARGPARSE_ATTR_IGNORE (1<<15)/* Attribute ignore is set. */ 1885 1886 /* A set of macros to make option definitions easier to read. */ 1887 #define ARGPARSE_x(s,l,t,f,d) \ 1888 { (s), (l), ARGPARSE_TYPE_ ## t | (f), (d) } 1889 1890 #define ARGPARSE_s(s,l,t,d) \ 1891 { (s), (l), ARGPARSE_TYPE_ ## t, (d) } 1892 #define ARGPARSE_s_n(s,l,d) \ 1893 { (s), (l), ARGPARSE_TYPE_NONE, (d) } 1894 #define ARGPARSE_s_i(s,l,d) \ 1895 { (s), (l), ARGPARSE_TYPE_INT, (d) } 1896 #define ARGPARSE_s_s(s,l,d) \ 1897 { (s), (l), ARGPARSE_TYPE_STRING, (d) } 1898 #define ARGPARSE_s_l(s,l,d) \ 1899 { (s), (l), ARGPARSE_TYPE_LONG, (d) } 1900 #define ARGPARSE_s_u(s,l,d) \ 1901 { (s), (l), ARGPARSE_TYPE_ULONG, (d) } 1902 1903 #define ARGPARSE_o(s,l,t,d) \ 1904 { (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_OPTIONAL), (d) } 1905 #define ARGPARSE_o_n(s,l,d) \ 1906 { (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_OPTIONAL), (d) } 1907 #define ARGPARSE_o_i(s,l,d) \ 1908 { (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_OPTIONAL), (d) } 1909 #define ARGPARSE_o_s(s,l,d) \ 1910 { (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_OPTIONAL), (d) } 1911 #define ARGPARSE_o_l(s,l,d) \ 1912 { (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_OPTIONAL), (d) } 1913 #define ARGPARSE_o_u(s,l,d) \ 1914 { (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_OPTIONAL), (d) } 1915 1916 #define ARGPARSE_p(s,l,t,d) \ 1917 { (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_PREFIX), (d) } 1918 #define ARGPARSE_p_n(s,l,d) \ 1919 { (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_PREFIX), (d) } 1920 #define ARGPARSE_p_i(s,l,d) \ 1921 { (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_PREFIX), (d) } 1922 #define ARGPARSE_p_s(s,l,d) \ 1923 { (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_PREFIX), (d) } 1924 #define ARGPARSE_p_l(s,l,d) \ 1925 { (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_PREFIX), (d) } 1926 #define ARGPARSE_p_u(s,l,d) \ 1927 { (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_PREFIX), (d) } 1928 1929 #define ARGPARSE_op(s,l,t,d) \ 1930 { (s), (l), (ARGPARSE_TYPE_ ## t \ 1931 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1932 #define ARGPARSE_op_n(s,l,d) \ 1933 { (s), (l), (ARGPARSE_TYPE_NONE \ 1934 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1935 #define ARGPARSE_op_i(s,l,d) \ 1936 { (s), (l), (ARGPARSE_TYPE_INT \ 1937 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1938 #define ARGPARSE_op_s(s,l,d) \ 1939 { (s), (l), (ARGPARSE_TYPE_STRING \ 1940 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1941 #define ARGPARSE_op_l(s,l,d) \ 1942 { (s), (l), (ARGPARSE_TYPE_LONG \ 1943 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1944 #define ARGPARSE_op_u(s,l,d) \ 1945 { (s), (l), (ARGPARSE_TYPE_ULONG \ 1946 | ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) } 1947 1948 #define ARGPARSE_c(s,l,d) \ 1949 { (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_COMMAND), (d) } 1950 1951 #define ARGPARSE_conffile(s,l,d) \ 1952 { (s), (l), (ARGPARSE_TYPE_STRING|ARGPARSE_OPT_CONFFILE), (d) } 1953 1954 #define ARGPARSE_noconffile(s,l,d) \ 1955 { (s), (l), (ARGPARSE_TYPE_NONE|ARGPARSE_OPT_CONFFILE), (d) } 1956 1957 /* This macro is for stub or obsolete options. */ 1958 #define ARGPARSE_ignore(s,l) \ 1959 { (s), (l), (ARGPARSE_OPT_IGNORE), "@" } 1960 1961 /* This is a legacy version of ARGPARSE_verbatim which really does 1962 * verbatim printing. */ 1963 #define ARGPARSE_group(s,d) \ 1964 { (s), NULL, 0, (d) } 1965 1966 /* Verbatim print the string D in the help output. It does not make 1967 * use of the "@" hack as ARGPARSE_group does. */ 1968 #define ARGPARSE_verbatim(d) \ 1969 { 1, NULL, (ARGPARSE_OPT_VERBATIM), (d) } 1970 1971 /* Same as ARGPARSE_verbatim but also print a colon and a LF. N can 1972 * be used give a symbolic name to the header. Nothing is printed if 1973 * D is the empty string. */ 1974 #define ARGPARSE_header(n,d) \ 1975 { 1, (n), (ARGPARSE_OPT_HEADER), (d) } 1976 1977 /* Mark the end of the list (mandatory). */ 1978 #define ARGPARSE_end() \ 1979 { 0, NULL, 0, NULL } 1980 1981 #endif /* GPGRT_ENABLE_ARGPARSE_MACROS */ 1982 1983 /* Values used for gpgrt_set_confdir. */ 1984 #define GPGRT_CONFDIR_USER 1 /* The user's configuration dir. */ 1985 #define GPGRT_CONFDIR_SYS 2 /* The systems's configuration dir. */ 1986 1987 /* Take care: gpgrt_argparse keeps state in ARG and requires that 1988 * either ARGPARSE_FLAG_RESET is used after OPTS has been changed or 1989 * gpgrt_argparse (NULL, ARG, NULL) is called first. */ 1990 int gpgrt_argparse (gpgrt_stream_t fp, 1991 gpgrt_argparse_t *arg, gpgrt_opt_t *opts); 1992 int gpgrt_argparser (gpgrt_argparse_t *arg, gpgrt_opt_t *opts, 1993 const char *confname); 1994 void gpgrt_usage (int level); 1995 const char *gpgrt_strusage (int level); 1996 void gpgrt_set_strusage (const char *(*f)(int)); 1997 void gpgrt_set_usage_outfnc (int (*f)(int, const char *)); 1998 void gpgrt_set_fixed_string_mapper (const char *(*f)(const char*)); 1999 void gpgrt_set_confdir (int what, const char *name); 2000 2001 2002 /* 2003 * Various helper functions 2004 */ 2005 2006 /* Compare arbitrary version strings. For the standard m.n.o version 2007 * numbering scheme a LEVEL of 3 is suitable; see the manual. */ 2008 int gpgrt_cmp_version (const char *a, const char *b, int level); 2009 2010 /* Construct a filename from the NULL terminated list of parts. Tilde 2011 * expansion is done for the first argument. The caller must release 2012 * the result using gpgrt_free; on error ERRNO is set and NULL 2013 * returned. The second function returns an absolute filename. */ 2014 char *gpgrt_fnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0); 2015 char *gpgrt_absfnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0); 2016 2017 2018 #ifdef __cplusplus 2019 } 2020 #endif 2021 #endif /* GPGRT_H */ 2022 #endif /* GPG_ERROR_H */ 2023 /* 2024 Local Variables: 2025 buffer-read-only: t 2026 End: 2027 */