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	x86_64-unknown-linux-gnu (x86_64-pc-linux-gnu)
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.47"
70	#define GPGRT_VERSION "1.47"
71
72	/* The version number of this header. */
73	#define GPG_ERROR_VERSION_NUMBER 0x012f00
74	#define GPGRT_VERSION_NUMBER 0x012f00
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, code: 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 (code: 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 (code: 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
1087
1088	/*
1089	* System specific function wrappers.
1090	*/
1091
1092	/* A getenv replacement which mallocs the returned string. */
1093	char *gpgrt_getenv (const char *name);
1094
1095	/* A setenv and a unsetenv replacement.*/
1096	gpg_err_code_t gpgrt_setenv (const char *name,
1097	const char *value, int overwrite);
1098	#define gpgrt_unsetenv(n) gpgrt_setenv ((n), NULL, 1)
1099
1100	/* A wrapper around mkdir using a string for the mode. */
1101	gpg_err_code_t gpgrt_mkdir (const char *name, const char *modestr);
1102
1103	/* A simple wrapper around chdir. */
1104	gpg_err_code_t gpgrt_chdir (const char *name);
1105
1106	/* Return the current WD as a malloced string. */
1107	char *gpgrt_getcwd (void);
1108
1109	/* A wrapper around access to handle UTF-8 on Windows. */
1110	gpg_err_code_t gpgrt_access (const char *fname, int mode);
1111
1112
1113
1114
1115	/*
1116	* Lock functions.
1117	*/
1118
1119
1120	typedef struct
1121	{
1122	long _vers;
1123	union {
1124	volatile char _priv[40];
1125	long _x_align;
1126	long *_xp_align;
1127	} u;
1128	} gpgrt_lock_t;
1129
1130	#define GPGRT_LOCK_INITIALIZER {1,{{0,0,0,0,0,0,0,0, \
1131	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
1136
1137	#define GPGRT_LOCK_DEFINE(name) \
1138	static gpgrt_lock_t name = GPGRT_LOCK_INITIALIZER
1139
1140	/* NB: If GPGRT_LOCK_DEFINE is not used, zero out the lock variable
1141	before passing it to gpgrt_lock_init. */
1142	gpg_err_code_t gpgrt_lock_init (gpgrt_lock_t *lockhd);
1143	gpg_err_code_t gpgrt_lock_lock (gpgrt_lock_t *lockhd);
1144	gpg_err_code_t gpgrt_lock_trylock (gpgrt_lock_t *lockhd);
1145	gpg_err_code_t gpgrt_lock_unlock (gpgrt_lock_t *lockhd);
1146	gpg_err_code_t gpgrt_lock_destroy (gpgrt_lock_t *lockhd);
1147
1148
1149
1150	/*
1151	* Thread functions.
1152	*/
1153
1154	gpg_err_code_t gpgrt_yield (void);
1155
1156
1157
1158
1159	/*
1160	* Estream
1161	*/
1162
1163	/* The definition of this struct is entirely private. You must not
1164	use it for anything. It is only here so some functions can be
1165	implemented as macros. */
1166	struct _gpgrt_stream_internal;
1167	struct _gpgrt__stream
1168	{
1169	/* The layout of this struct must never change. It may be grown,
1170	but only if all functions which access the new members are
1171	versioned. */
1172
1173	/* Various flags. */
1174	struct {
1175	unsigned int magic: 16;
1176	unsigned int writing: 1;
1177	unsigned int reserved: 15;
1178	} flags;
1179
1180	/* A pointer to the stream buffer. */
1181	unsigned char *buffer;
1182
1183	/* The size of the buffer in bytes. */
1184	size_t buffer_size;
1185
1186	/* The length of the usable data in the buffer, only valid when in
1187	read mode (see flags). */
1188	size_t data_len;
1189
1190	/* The current position of the offset pointer, valid in read and
1191	write mode. */
1192	size_t data_offset;
1193
1194	size_t data_flushed;
1195	unsigned char *unread_buffer;
1196	size_t unread_buffer_size;
1197
1198	/* The number of unread bytes. */
1199	size_t unread_data_len;
1200
1201	/* A pointer to our internal data for this stream. */
1202	struct _gpgrt_stream_internal *intern;
1203	};
1204
1205	/* The opaque type for an estream. */
1206	typedef struct _gpgrt__stream *gpgrt_stream_t;
1207	#ifdef GPGRT_ENABLE_ES_MACROS
1208	typedef struct _gpgrt__stream *estream_t;
1209	#endif
1210
1211	typedef ssize_t (*gpgrt_cookie_read_function_t) (void *cookie,
1212	void *buffer, size_t size);
1213	typedef ssize_t (*gpgrt_cookie_write_function_t) (void *cookie,
1214	const void *buffer,
1215	size_t size);
1216	typedef int (*gpgrt_cookie_seek_function_t) (void *cookie,
1217	gpgrt_off_t *pos, int whence);
1218	typedef int (*gpgrt_cookie_close_function_t) (void *cookie);
1219
1220	struct _gpgrt_cookie_io_functions
1221	{
1222	gpgrt_cookie_read_function_t func_read;
1223	gpgrt_cookie_write_function_t func_write;
1224	gpgrt_cookie_seek_function_t func_seek;
1225	gpgrt_cookie_close_function_t func_close;
1226	};
1227	typedef struct _gpgrt_cookie_io_functions gpgrt_cookie_io_functions_t;
1228	#ifdef GPGRT_ENABLE_ES_MACROS
1229	typedef struct _gpgrt_cookie_io_functions es_cookie_io_functions_t;
1230	#define es_cookie_read_function_t gpgrt_cookie_read_function_t
1231	#define es_cookie_write_function_t gpgrt_cookie_read_function_t
1232	#define es_cookie_seek_function_t gpgrt_cookie_read_function_t
1233	#define es_cookie_close_function_t gpgrt_cookie_read_function_t
1234	#endif
1235
1236	enum gpgrt_syshd_types
1237	{
1238	GPGRT_SYSHD_NONE = 0, /* No system handle available. */
1239	GPGRT_SYSHD_FD = 1, /* A file descriptor as returned by open(). */
1240	GPGRT_SYSHD_SOCK = 2, /* A socket as returned by socket(). */
1241	GPGRT_SYSHD_RVID = 3, /* A rendezvous id (see libassuan's gpgcedev.c). */
1242	GPGRT_SYSHD_HANDLE = 4 /* A HANDLE object (Windows). */
1243	};
1244
1245	struct _gpgrt_syshd
1246	{
1247	enum gpgrt_syshd_types type;
1248	union {
1249	int fd;
1250	int sock;
1251	int rvid;
1252	void *handle;
1253	} u;
1254	};
1255	typedef struct _gpgrt_syshd gpgrt_syshd_t;
1256	#ifdef GPGRT_ENABLE_ES_MACROS
1257	typedef struct _gpgrt_syshd es_syshd_t;
1258	#define ES_SYSHD_NONE GPGRT_SYSHD_NONE
1259	#define ES_SYSHD_FD GPGRT_SYSHD_FD
1260	#define ES_SYSHD_SOCK GPGRT_SYSHD_SOCK
1261	#define ES_SYSHD_RVID GPGRT_SYSHD_RVID
1262	#define ES_SYSHD_HANDLE GPGRT_SYSHD_HANDLE
1263	#endif
1264
1265	/* The object used with gpgrt_poll. */
1266	struct _gpgrt_poll_s
1267	{
1268	gpgrt_stream_t stream;
1269	unsigned int want_read:1;
1270	unsigned int want_write:1;
1271	unsigned int want_oob:1;
1272	unsigned int want_rdhup:1;
1273	unsigned int _reserv1:4;
1274	unsigned int got_read:1;
1275	unsigned int got_write:1;
1276	unsigned int got_oob:1;
1277	unsigned int got_rdhup:1;
1278	unsigned int _reserv2:4;
1279	unsigned int got_err:1;
1280	unsigned int got_hup:1;
1281	unsigned int got_nval:1;
1282	unsigned int _reserv3:4;
1283	unsigned int ignore:1;
1284	unsigned int user:8; /* For application use. */
1285	};
1286	typedef struct _gpgrt_poll_s gpgrt_poll_t;
1287	#ifdef GPGRT_ENABLE_ES_MACROS
1288	typedef struct _gpgrt_poll_s es_poll_t;
1289	#endif
1290
1291	/* The type of the string filter function as used by fprintf_sf et al. */
1292	typedef char *(*gpgrt_string_filter_t) (const char *s, int n, void *opaque);
1293
1294
1295
1296	gpgrt_stream_t gpgrt_fopen (const char *_GPGRT__RESTRICT path,
1297	const char *_GPGRT__RESTRICT mode);
1298	gpgrt_stream_t gpgrt_mopen (void *_GPGRT__RESTRICT data,
1299	size_t data_n, size_t data_len,
1300	unsigned int grow,
1301	void *(*func_realloc) (void *mem, size_t size),
1302	void (*func_free) (void *mem),
1303	const char *_GPGRT__RESTRICT mode);
1304	gpgrt_stream_t gpgrt_fopenmem (size_t memlimit,
1305	const char *_GPGRT__RESTRICT mode);
1306	gpgrt_stream_t gpgrt_fopenmem_init (size_t memlimit,
1307	const char *_GPGRT__RESTRICT mode,
1308	const void *data, size_t datalen);
1309	gpgrt_stream_t gpgrt_fdopen (int filedes, const char *mode);
1310	gpgrt_stream_t gpgrt_fdopen_nc (int filedes, const char *mode);
1311	gpgrt_stream_t gpgrt_sysopen (gpgrt_syshd_t *syshd, const char *mode);
1312	gpgrt_stream_t gpgrt_sysopen_nc (gpgrt_syshd_t *syshd, const char *mode);
1313	gpgrt_stream_t gpgrt_fpopen (FILE *fp, const char *mode);
1314	gpgrt_stream_t gpgrt_fpopen_nc (FILE *fp, const char *mode);
1315	gpgrt_stream_t gpgrt_freopen (const char *_GPGRT__RESTRICT path,
1316	const char *_GPGRT__RESTRICT mode,
1317	gpgrt_stream_t _GPGRT__RESTRICT stream);
1318	gpgrt_stream_t gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie,
1319	const char *_GPGRT__RESTRICT mode,
1320	gpgrt_cookie_io_functions_t functions);
1321	int gpgrt_fclose (gpgrt_stream_t stream);
1322	int gpgrt_fcancel (gpgrt_stream_t stream);
1323	int gpgrt_fclose_snatch (gpgrt_stream_t stream,
1324	void **r_buffer, size_t *r_buflen);
1325	int gpgrt_onclose (gpgrt_stream_t stream, int mode,
1326	void (*fnc) (gpgrt_stream_t, void*), void *fnc_value);
1327	int gpgrt_fileno (gpgrt_stream_t stream);
1328	int gpgrt_fileno_unlocked (gpgrt_stream_t stream);
1329	int gpgrt_syshd (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
1330	int gpgrt_syshd_unlocked (gpgrt_stream_t stream, gpgrt_syshd_t *syshd);
1331
1332	void _gpgrt_set_std_fd (int no, int fd);
1333	gpgrt_stream_t _gpgrt_get_std_stream (int fd);
1334
1335	#define gpgrt_stdin _gpgrt_get_std_stream (0)
1336	#define gpgrt_stdout _gpgrt_get_std_stream (1)
1337	#define gpgrt_stderr _gpgrt_get_std_stream (2)
1338
1339
1340	void gpgrt_flockfile (gpgrt_stream_t stream);
1341	int gpgrt_ftrylockfile (gpgrt_stream_t stream);
1342	void gpgrt_funlockfile (gpgrt_stream_t stream);
1343
1344	int gpgrt_feof (gpgrt_stream_t stream);
1345	int gpgrt_feof_unlocked (gpgrt_stream_t stream);
1346	int gpgrt_ferror (gpgrt_stream_t stream);
1347	int gpgrt_ferror_unlocked (gpgrt_stream_t stream);
1348	void gpgrt_clearerr (gpgrt_stream_t stream);
1349	void gpgrt_clearerr_unlocked (gpgrt_stream_t stream);
1350
1351	int _gpgrt_pending (gpgrt_stream_t stream); /* (private) */
1352	int _gpgrt_pending_unlocked (gpgrt_stream_t stream); /* (private) */
1353
1354	#define gpgrt_pending(stream) _gpgrt_pending (stream)
1355
1356	#define gpgrt_pending_unlocked(stream) \
1357	(((!(stream)->flags.writing) \
1358	&& (((stream)->data_offset < (stream)->data_len) \
1359	|| ((stream)->unread_data_len))) \
1360	? 1 : _gpgrt_pending_unlocked ((stream)))
1361
1362	int gpgrt_fflush (gpgrt_stream_t stream);
1363	int gpgrt_fseek (gpgrt_stream_t stream, long int offset, int whence);
1364	int gpgrt_fseeko (gpgrt_stream_t stream, gpgrt_off_t offset, int whence);
1365	int gpgrt_ftruncate (gpgrt_stream_t stream, gpgrt_off_t length);
1366	long int gpgrt_ftell (gpgrt_stream_t stream);
1367	gpgrt_off_t gpgrt_ftello (gpgrt_stream_t stream);
1368	void gpgrt_rewind (gpgrt_stream_t stream);
1369
1370	int gpgrt_fgetc (gpgrt_stream_t stream);
1371	int gpgrt_fputc (int c, gpgrt_stream_t stream);
1372
1373	int _gpgrt_getc_underflow (gpgrt_stream_t stream); /* (private) */
1374	int _gpgrt_putc_overflow (int c, gpgrt_stream_t stream); /* (private) */
1375
1376	#define gpgrt_getc_unlocked(stream) \
1377	(((!(stream)->flags.writing) \
1378	&& ((stream)->data_offset < (stream)->data_len) \
1379	&& (! (stream)->unread_data_len)) \
1380	? ((int) (stream)->buffer[((stream)->data_offset)++]) \
1381	: _gpgrt_getc_underflow ((stream)))
1382
1383	#define gpgrt_putc_unlocked(c, stream) \
1384	(((stream)->flags.writing \
1385	&& ((stream)->data_offset < (stream)->buffer_size) \
1386	&& (c != '\n')) \
1387	? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \
1388	: _gpgrt_putc_overflow ((c), (stream)))
1389
1390	#define gpgrt_getc(stream) gpgrt_fgetc (stream)
1391	#define gpgrt_putc(c, stream) gpgrt_fputc (c, stream)
1392
1393	int gpgrt_ungetc (int c, gpgrt_stream_t stream);
1394
1395	int gpgrt_read (gpgrt_stream_t _GPGRT__RESTRICT stream,
1396	void *_GPGRT__RESTRICT buffer, size_t bytes_to_read,
1397	size_t *_GPGRT__RESTRICT bytes_read);
1398	int gpgrt_write (gpgrt_stream_t _GPGRT__RESTRICT stream,
1399	const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write,
1400	size_t *_GPGRT__RESTRICT bytes_written);
1401	int gpgrt_write_sanitized (gpgrt_stream_t _GPGRT__RESTRICT stream,
1402	const void *_GPGRT__RESTRICT buffer, size_t length,
1403	const char *delimiters,
1404	size_t *_GPGRT__RESTRICT bytes_written);
1405	int gpgrt_write_hexstring (gpgrt_stream_t _GPGRT__RESTRICT stream,
1406	const void *_GPGRT__RESTRICT buffer, size_t length,
1407	int reserved,
1408	size_t *_GPGRT__RESTRICT bytes_written);
1409
1410	size_t gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
1411	gpgrt_stream_t _GPGRT__RESTRICT stream);
1412	size_t gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size,
1413	size_t nitems, gpgrt_stream_t _GPGRT__RESTRICT stream);
1414
1415	char *gpgrt_fgets (char *_GPGRT__RESTRICT s, int n,
1416	gpgrt_stream_t _GPGRT__RESTRICT stream);
1417	int gpgrt_fputs (const char *_GPGRT__RESTRICT s,
1418	gpgrt_stream_t _GPGRT__RESTRICT stream);
1419	int gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s,
1420	gpgrt_stream_t _GPGRT__RESTRICT stream);
1421
1422	ssize_t gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr,
1423	size_t *_GPGRT__RESTRICT n,
1424	gpgrt_stream_t stream);
1425	ssize_t gpgrt_read_line (gpgrt_stream_t stream,
1426	char **addr_of_buffer, size_t *length_of_buffer,
1427	size_t *max_length);
1428
1429	int gpgrt_fprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
1430	const char *_GPGRT__RESTRICT format, ...)
1431	GPGRT_ATTR_PRINTF(2,3);
1432	int gpgrt_fprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
1433	const char *_GPGRT__RESTRICT format, ...)
1434	GPGRT_ATTR_PRINTF(2,3);
1435
1436	int gpgrt_fprintf_sf (gpgrt_stream_t _GPGRT__RESTRICT stream,
1437	gpgrt_string_filter_t sf, void *sfvalue,
1438	const char *_GPGRT__RESTRICT format,
1439	...) GPGRT_ATTR_PRINTF(4,5);
1440	int gpgrt_fprintf_sf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
1441	gpgrt_string_filter_t sf, void *sfvalue,
1442	const char *_GPGRT__RESTRICT format,
1443	...) GPGRT_ATTR_PRINTF(4,5);
1444
1445	int gpgrt_printf (const char *_GPGRT__RESTRICT format, ...)
1446	GPGRT_ATTR_PRINTF(1,2);
1447	int gpgrt_printf_unlocked (const char *_GPGRT__RESTRICT format, ...)
1448	GPGRT_ATTR_PRINTF(1,2);
1449
1450	int gpgrt_vfprintf (gpgrt_stream_t _GPGRT__RESTRICT stream,
1451	const char *_GPGRT__RESTRICT format, va_list ap)
1452	GPGRT_ATTR_PRINTF(2,0);
1453	int gpgrt_vfprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream,
1454	const char *_GPGRT__RESTRICT format, va_list ap)
1455	GPGRT_ATTR_PRINTF(2,0);
1456
1457	int gpgrt_setvbuf (gpgrt_stream_t _GPGRT__RESTRICT stream,
1458	char *_GPGRT__RESTRICT buf, int mode, size_t size);
1459	void gpgrt_setbuf (gpgrt_stream_t _GPGRT__RESTRICT stream,
1460	char *_GPGRT__RESTRICT buf);
1461
1462	void gpgrt_set_binary (gpgrt_stream_t stream);
1463	int gpgrt_set_nonblock (gpgrt_stream_t stream, int onoff);
1464	int gpgrt_get_nonblock (gpgrt_stream_t stream);
1465
1466	int gpgrt_poll (gpgrt_poll_t *fdlist, unsigned int nfds, int timeout);
1467
1468	gpgrt_stream_t gpgrt_tmpfile (void);
1469
1470	void gpgrt_opaque_set (gpgrt_stream_t _GPGRT__RESTRICT stream,
1471	void *_GPGRT__RESTRICT opaque);
1472	void *gpgrt_opaque_get (gpgrt_stream_t stream);
1473
1474	void gpgrt_fname_set (gpgrt_stream_t stream, const char *fname);
1475	const char *gpgrt_fname_get (gpgrt_stream_t stream);
1476
1477	int gpgrt_asprintf (char **r_buf, const char * _GPGRT__RESTRICT format, ...)
1478	GPGRT_ATTR_PRINTF(2,3);
1479	int gpgrt_vasprintf (char **r_buf, const char * _GPGRT__RESTRICT format,
1480	va_list ap)
1481	GPGRT_ATTR_PRINTF(2,0);
1482	char *gpgrt_bsprintf (const char * _GPGRT__RESTRICT format, ...)
1483	GPGRT_ATTR_PRINTF(1,2);
1484	char *gpgrt_vbsprintf (const char * _GPGRT__RESTRICT format, va_list ap)
1485	GPGRT_ATTR_PRINTF(1,0);
1486	int gpgrt_snprintf (char *buf, size_t bufsize,
1487	const char * _GPGRT__RESTRICT format, ...)
1488	GPGRT_ATTR_PRINTF(3,4);
1489	int gpgrt_vsnprintf (char *buf,size_t bufsize,
1490	const char * _GPGRT__RESTRICT format, va_list arg_ptr)
1491	GPGRT_ATTR_PRINTF(3,0);
1492
1493
1494	#ifdef GPGRT_ENABLE_ES_MACROS
1495	# define es_fopen gpgrt_fopen
1496	# define es_mopen gpgrt_mopen
1497	# define es_fopenmem gpgrt_fopenmem
1498	# define es_fopenmem_init gpgrt_fopenmem_init
1499	# define es_fdopen gpgrt_fdopen
1500	# define es_fdopen_nc gpgrt_fdopen_nc
1501	# define es_sysopen gpgrt_sysopen
1502	# define es_sysopen_nc gpgrt_sysopen_nc
1503	# define es_fpopen gpgrt_fpopen
1504	# define es_fpopen_nc gpgrt_fpopen_nc
1505	# define es_freopen gpgrt_freopen
1506	# define es_fopencookie gpgrt_fopencookie
1507	# define es_fclose gpgrt_fclose
1508	# define es_fclose_snatch gpgrt_fclose_snatch
1509	# define es_onclose gpgrt_onclose
1510	# define es_fileno gpgrt_fileno
1511	# define es_fileno_unlocked gpgrt_fileno_unlocked
1512	# define es_syshd gpgrt_syshd
1513	# define es_syshd_unlocked gpgrt_syshd_unlocked
1514	# define es_stdin _gpgrt_get_std_stream (0)
1515	# define es_stdout _gpgrt_get_std_stream (1)
1516	# define es_stderr _gpgrt_get_std_stream (2)
1517	# define es_flockfile gpgrt_flockfile
1518	# define es_ftrylockfile gpgrt_ftrylockfile
1519	# define es_funlockfile gpgrt_funlockfile
1520	# define es_feof gpgrt_feof
1521	# define es_feof_unlocked gpgrt_feof_unlocked
1522	# define es_ferror gpgrt_ferror
1523	# define es_ferror_unlocked gpgrt_ferror_unlocked
1524	# define es_clearerr gpgrt_clearerr
1525	# define es_clearerr_unlocked gpgrt_clearerr_unlocked
1526	# define es_pending gpgrt_pending
1527	# define es_pending_unlocked gpgrt_pending_unlocked
1528	# define es_fflush gpgrt_fflush
1529	# define es_fseek gpgrt_fseek
1530	# define es_fseeko gpgrt_fseeko
1531	# define es_ftruncate gpgrt_ftruncate
1532	# define es_ftell gpgrt_ftell
1533	# define es_ftello gpgrt_ftello
1534	# define es_rewind gpgrt_rewind
1535	# define es_fgetc gpgrt_fgetc
1536	# define es_fputc gpgrt_fputc
1537	# define es_getc_unlocked gpgrt_getc_unlocked
1538	# define es_putc_unlocked gpgrt_putc_unlocked
1539	# define es_getc gpgrt_getc
1540	# define es_putc gpgrt_putc
1541	# define es_ungetc gpgrt_ungetc
1542	# define es_read gpgrt_read
1543	# define es_write gpgrt_write
1544	# define es_write_sanitized gpgrt_write_sanitized
1545	# define es_write_hexstring gpgrt_write_hexstring
1546	# define es_fread gpgrt_fread
1547	# define es_fwrite gpgrt_fwrite
1548	# define es_fgets gpgrt_fgets
1549	# define es_fputs gpgrt_fputs
1550	# define es_fputs_unlocked gpgrt_fputs_unlocked
1551	# define es_getline gpgrt_getline
1552	# define es_read_line gpgrt_read_line
1553	# define es_free gpgrt_free
1554	# define es_fprintf gpgrt_fprintf
1555	# define es_fprintf_unlocked gpgrt_fprintf_unlocked
1556	# define es_printf gpgrt_printf
1557	# define es_printf_unlocked gpgrt_printf_unlocked
1558	# define es_vfprintf gpgrt_vfprintf
1559	# define es_vfprintf_unlocked gpgrt_vfprintf_unlocked
1560	# define es_setvbuf gpgrt_setvbuf
1561	# define es_setbuf gpgrt_setbuf
1562	# define es_set_binary gpgrt_set_binary
1563	# define es_set_nonblock gpgrt_set_nonblock
1564	# define es_get_nonblock gpgrt_get_nonblock
1565	# define es_poll gpgrt_poll
1566	# define es_tmpfile gpgrt_tmpfile
1567	# define es_opaque_set gpgrt_opaque_set
1568	# define es_opaque_get gpgrt_opaque_get
1569	# define es_fname_set gpgrt_fname_set
1570	# define es_fname_get gpgrt_fname_get
1571	# define es_asprintf gpgrt_asprintf
1572	# define es_vasprintf gpgrt_vasprintf
1573	# define es_bsprintf gpgrt_bsprintf
1574	# define es_vbsprintf gpgrt_vbsprintf
1575	#endif /*GPGRT_ENABLE_ES_MACROS*/
1576
1577
1578
1579	/*
1580	* Base64 encode and decode functions.
1581	*/
1582
1583	struct _gpgrt_b64state;
1584	typedef struct _gpgrt_b64state *gpgrt_b64state_t;
1585
1586	gpgrt_b64state_t gpgrt_b64enc_start (gpgrt_stream_t stream, const char *title);
1587	gpg_err_code_t gpgrt_b64enc_write (gpgrt_b64state_t state,
1588	const void *buffer, size_t nbytes);
1589	gpg_err_code_t gpgrt_b64enc_finish (gpgrt_b64state_t state);
1590
1591	gpgrt_b64state_t gpgrt_b64dec_start (const char *title);
1592	gpg_error_t gpgrt_b64dec_proc (gpgrt_b64state_t state,
1593	void *buffer, size_t length,
1594	size_t *r_nbytes);
1595	gpg_error_t gpgrt_b64dec_finish (gpgrt_b64state_t state);
1596
1597
1598
1599	/*
1600	* Logging functions
1601	*/
1602
1603	/* Flag values for gpgrt_log_set_prefix. */
1604	#define GPGRT_LOG_WITH_PREFIX 1
1605	#define GPGRT_LOG_WITH_TIME 2
1606	#define GPGRT_LOG_WITH_PID 4
1607	#define GPGRT_LOG_RUN_DETACHED 256
1608	#define GPGRT_LOG_NO_REGISTRY 512
1609
1610	/* Log levels as used by gpgrt_log. */
1611	enum gpgrt_log_levels
1612	{
1613	GPGRT_LOGLVL_BEGIN,
1614	GPGRT_LOGLVL_CONT,
1615	GPGRT_LOGLVL_INFO,
1616	GPGRT_LOGLVL_WARN,
1617	GPGRT_LOGLVL_ERROR,
1618	GPGRT_LOGLVL_FATAL,
1619	GPGRT_LOGLVL_BUG,
1620	GPGRT_LOGLVL_DEBUG
1621	};
1622
1623
1624	/* The next 4 functions are not thread-safe - call them early. */
1625	void gpgrt_log_set_sink (const char *name, gpgrt_stream_t stream, int fd);
1626	void gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void));
1627	void gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value));
1628	void gpgrt_log_set_prefix (const char *text, unsigned int flags);
1629
1630	int gpgrt_get_errorcount (int clear);
1631	void gpgrt_inc_errorcount (void);
1632	const char *gpgrt_log_get_prefix (unsigned int *flags);
1633	int gpgrt_log_test_fd (int fd);
1634	int gpgrt_log_get_fd (void);
1635	gpgrt_stream_t gpgrt_log_get_stream (void);
1636
1637	void gpgrt_log (int level, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3);
1638	void gpgrt_logv (int level, const char *fmt, va_list arg_ptr);
1639	void gpgrt_logv_prefix (int level, const char *prefix,
1640	const char *fmt, va_list arg_ptr);
1641	void gpgrt_log_string (int level, const char *string);
1642	void gpgrt_log_bug (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
1643	void gpgrt_log_fatal (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2);
1644	void gpgrt_log_error (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
1645	void gpgrt_log_info (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
1646	void gpgrt_log_debug (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
1647	void gpgrt_log_debug_string (const char *string,
1648	const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3);
1649	void gpgrt_log_printf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
1650	void gpgrt_log_printhex (const void *buffer, size_t length,
1651	const char *fmt, ...) GPGRT_ATTR_PRINTF(3,4);
1652	void gpgrt_log_clock (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
1653	void gpgrt_log_flush (void);
1654	void _gpgrt_log_assert (const char *expr, const char *file, int line,
1655	const char *func) GPGRT_ATTR_NORETURN;
1656
1657	#ifdef GPGRT_HAVE_MACRO_FUNCTION
1658	# define gpgrt_assert(expr) \
1659	((expr) \
1660	? (void) 0 \
1661	: _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__))
1662	#else /*!GPGRT_HAVE_MACRO_FUNCTION*/
1663	# define gpgrt_assert(expr) \
1664	((expr) \
1665	? (void) 0 \
1666	: _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL))
1667	#endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
1668
1669	#ifdef GPGRT_ENABLE_LOG_MACROS
1670	# define log_get_errorcount gpgrt_get_errorcount
1671	# define log_inc_errorcount gpgrt_inc_errorcount
1672	# define log_set_file(a) gpgrt_log_set_sink ((a), NULL, -1)
1673	# define log_set_fd(a) gpgrt_log_set_sink (NULL, NULL, (a))
1674	# define log_set_stream(a) gpgrt_log_set_sink (NULL, (a), -1)
1675	# define log_set_socket_dir_cb gpgrt_log_set_socket_dir_cb
1676	# define log_set_pid_suffix_cb gpgrt_log_set_pid_suffix_cb
1677	# define log_set_prefix gpgrt_log_set_prefix
1678	# define log_get_prefix gpgrt_log_get_prefix
1679	# define log_test_fd gpgrt_log_test_fd
1680	# define log_get_fd gpgrt_log_get_fd
1681	# define log_get_stream gpgrt_log_get_stream
1682	# define log_log gpgrt_log
1683	# define log_logv gpgrt_logv
1684	# define log_logv_prefix gpgrt_logv_prefix
1685	# define log_string gpgrt_log_string
1686	# define log_bug gpgrt_log_bug
1687	# define log_fatal gpgrt_log_fatal
1688	# define log_error gpgrt_log_error
1689	# define log_info gpgrt_log_info
1690	# define log_debug gpgrt_log_debug
1691	# define log_debug_string gpgrt_log_debug_string
1692	# define log_printf gpgrt_log_printf
1693	# define log_printhex gpgrt_log_printhex
1694	# define log_clock gpgrt_log_clock
1695	# define log_flush gpgrt_log_flush
1696	# ifdef GPGRT_HAVE_MACRO_FUNCTION
1697	# define log_assert(expr) \
1698	((expr) \
1699	? (void) 0 \
1700	: _gpgrt_log_assert (#expr, __FILE__, __LINE__, __FUNCTION__))
1701	# else /*!GPGRT_HAVE_MACRO_FUNCTION*/
1702	# define log_assert(expr) \
1703	((expr) \
1704	? (void) 0 \
1705	: _gpgrt_log_assert (#expr, __FILE__, __LINE__, NULL))
1706	# endif /*!GPGRT_HAVE_MACRO_FUNCTION*/
1707
1708	#endif /*GPGRT_ENABLE_LOG_MACROS*/
1709
1710
1711	/*
1712	* Spawn functions (Not yet available)
1713	*/
1714	/* Internal flag to inherit file descriptor/handle */
1715	#define GPGRT_SPAWN_INHERIT_FILE 1
1716
1717	#define GPGRT_SPAWN_NONBLOCK 16 /* Set the streams to non-blocking. */
1718	#define GPGRT_SPAWN_RUN_ASFW 64 /* Use AllowSetForegroundWindow on W32. */
1719	#define GPGRT_SPAWN_DETACHED 128 /* Start the process in the background. */
1720	#define GPGRT_SPAWN_KEEP_STDIN 256
1721	#define GPGRT_SPAWN_KEEP_STDOUT 512
1722	#define GPGRT_SPAWN_KEEP_STDERR 1024
1723
1724	#if 0
1725	/* Function and convenience macros to create pipes. */
1726	gpg_err_code_t gpgrt_make_pipe (int filedes[2], gpgrt_stream_t *r_fp,
1727	int direction, int nonblock);
1728	#define gpgrt_create_pipe(a) gpgrt_make_pipe ((a),NULL, 0, 0);
1729	#define gpgrt_create_inbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), -1,(c));
1730	#define gpgrt_create_outbound_pipe(a,b,c) gpgrt_make_pipe ((a), (b), 1,(c));
1731
1732
1733	/* Fork and exec PGMNAME. */
1734	gpg_err_code_t gpgrt_spawn_process (const char *pgmname, const char *argv[],
1735	int *execpt, unsigned int flags,
1736	gpgrt_stream_t *r_infp,
1737	gpgrt_stream_t *r_outfp,
1738	gpgrt_stream_t *r_errfp,
1739	gpgrt_process_t *r_process_id);
1740
1741	/* Fork and exec PGNNAME and connect the process to the given FDs. */
1742	gpg_err_code_t gpgrt_spawn_process_fd (const char *pgmname, const char *argv[],
1743	int infd, int outfd, int errfd,
1744	int (*spawn_cb) (void *),
1745	void *spawn_cb_arg,
1746	gpgrt_process_t *r_process_id);
1747
1748	/* Fork and exec PGMNAME as a detached process. */
1749	gpg_err_code_t gpgrt_spawn_process_detached (const char *pgmname,
1750	const char *argv[],
1751	const char *envp[]);
1752
1753	/* Wait for a single process. */
1754	gpg_err_code_t gpgrt_wait_process (const char *pgmname,
1755	gpgrt_process_t process_id,
1756	int hang, int *r_exitcode);
1757
1758	/* Wait for a multiple processes. */
1759	gpg_err_code_t gpgrt_wait_processes (const char **pgmnames,
1760	gpgrt_process_t *process_ids,
1761	size_t count, int hang, int *r_exitcodes);
1762
1763	/* Kill the process identified by PROCESS_ID. */
1764	void gpgrt_kill_process (gpgrt_process_t process_id);
1765
1766	/* Release process resources identified by PROCESS_ID. */
1767	void gpgrt_release_process (gpgrt_process_t process_id);
1768
1769	/* Close all file resources (descriptors), except KEEP_FDS. */
1770	void gpgrt_close_all_fds (int from, int *keep_fds);
1771	#endif /*0*/
1772
1773	/*
1774	* Option parsing.
1775	*/
1776
1777	struct _gpgrt_argparse_internal_s;
1778	typedef struct
1779	{
1780	int *argc; /* Pointer to ARGC (value subject to change). */
1781	char ***argv; /* Pointer to ARGV (value subject to change). */
1782	unsigned int flags; /* Global flags. May be set prior to calling the
1783	parser. The parser may change the value. */
1784	int err; /* Print error description for last option.
1785	Either 0, ARGPARSE_PRINT_WARNING or
1786	ARGPARSE_PRINT_ERROR. */
1787	unsigned int lineno;/* The current line number. */
1788	int r_opt; /* Returns option code. */
1789	int r_type; /* Returns type of option value. */
1790	union {
1791	int ret_int;
1792	long ret_long;
1793	unsigned long ret_ulong;
1794	char *ret_str;
1795	} r; /* Return values */
1796
1797	struct _gpgrt_argparse_internal_s *internal;
1798	} gpgrt_argparse_t;
1799
1800
1801	typedef struct
1802	{
1803	int short_opt;
1804	const char *long_opt;
1805	unsigned int flags;
1806	const char *description; /* Optional description. */
1807	} gpgrt_opt_t;
1808
1809
1810	#ifdef GPGRT_ENABLE_ARGPARSE_MACROS
1811
1812	/* Global flags for (gpgrt_argparse_t).flags. */
1813	#define ARGPARSE_FLAG_KEEP 1 /* Do not remove options form argv. */
1814	#define ARGPARSE_FLAG_ALL 2 /* Do not stop at last option but return
1815	remaining args with R_OPT set to -1. */
1816	#define ARGPARSE_FLAG_MIXED 4 /* Assume options and args are mixed. */
1817	#define ARGPARSE_FLAG_NOSTOP 8 /* Do not stop processing at "--". */
1818	#define ARGPARSE_FLAG_ARG0 16 /* Do not skip the first arg. */
1819	#define ARGPARSE_FLAG_ONEDASH 32 /* Allow long options with one dash. */
1820	#define ARGPARSE_FLAG_NOVERSION 64 /* No output for "--version". */
1821	#define ARGPARSE_FLAG_RESET 128 /* Request to reset the internal state. */
1822	#define ARGPARSE_FLAG_STOP_SEEN 256 /* Set to true if a "--" has been seen. */
1823	#define ARGPARSE_FLAG_NOLINENO 512 /* Do not zero the lineno field. */
1824	#define ARGPARSE_FLAG_SYS 1024 /* Use system config file. */
1825	#define ARGPARSE_FLAG_USER 2048 /* Use user config file. */
1826	#define ARGPARSE_FLAG_VERBOSE 4096 /* Print additional argparser info. */
1827	#define ARGPARSE_FLAG_USERVERS 8192 /* Try version-ed user config files. */
1828	#define ARGPARSE_FLAG_WITHATTR 16384 /* Return attribute bits. (Make sure */
1829	/* to act upon ARGPARSE_OPT_IGNORE.) */
1830
1831	/* Constants for (gpgrt_argparse_t).err. */
1832	#define ARGPARSE_PRINT_WARNING 1 /* Print a diagnostic. */
1833	#define ARGPARSE_PRINT_ERROR 2 /* Print a diagnostic and call exit. */
1834
1835	/* Special return values of gpgrt_argparse. */
1836	#define ARGPARSE_IS_ARG (-1)
1837	#define ARGPARSE_INVALID_OPTION (-2)
1838	#define ARGPARSE_MISSING_ARG (-3)
1839	#define ARGPARSE_KEYWORD_TOO_LONG (-4)
1840	#define ARGPARSE_READ_ERROR (-5)
1841	#define ARGPARSE_UNEXPECTED_ARG (-6)
1842	#define ARGPARSE_INVALID_COMMAND (-7)
1843	#define ARGPARSE_AMBIGUOUS_OPTION (-8)
1844	#define ARGPARSE_AMBIGUOUS_COMMAND (-9)
1845	#define ARGPARSE_INVALID_ALIAS (-10)
1846	#define ARGPARSE_OUT_OF_CORE (-11)
1847	#define ARGPARSE_INVALID_ARG (-12)
1848	#define ARGPARSE_PERMISSION_ERROR (-13)
1849	#define ARGPARSE_NO_CONFFILE (-14)
1850	#define ARGPARSE_CONFFILE (-15)
1851	#define ARGPARSE_INVALID_META (-16)
1852	#define ARGPARSE_UNKNOWN_META (-17)
1853	#define ARGPARSE_UNEXPECTED_META (-18)
1854
1855	/* Flags for the option descriptor (gpgrt_opt_t)->flags. Note that a
1856	* TYPE constant may be or-ed with the OPT constants but when used as
1857	* return value in r_type these OPT constants are normally not
1858	* included. However with ARGPARSE_FLAG_WITHATTR used and an option
1859	* would normally not be returned, it is returned but
1860	* ARGPARSE_OPT_IGNORE is then set; further ARPARSE_ATTR_* are set.
1861	*/
1862	#define ARGPARSE_TYPE_MASK 0x0007 /* Mask for the type bits. */
1863	#define ARGPARSE_TYPE_NONE 0 /* Does not take an argument. */
1864	#define ARGPARSE_TYPE_INT 1 /* Takes an int argument. */
1865	#define ARGPARSE_TYPE_STRING 2 /* Takes a string argument. */
1866	#define ARGPARSE_TYPE_LONG 3 /* Takes a long argument. */
1867	#define ARGPARSE_TYPE_ULONG 4 /* Takes an unsigned long argument. */
1868	#define ARGPARSE_OPT_OPTIONAL (1<<3) /* Argument is optional. */
1869	#define ARGPARSE_OPT_PREFIX (1<<4) /* Allow 0x etc. prefixed values. */
1870	#define ARGPARSE_OPT_IGNORE (1<<6) /* Ignore command or option. */
1871	#define ARGPARSE_OPT_COMMAND (1<<7) /* The argument is a command. */
1872	#define ARGPARSE_OPT_CONFFILE (1<<8) /* The value is a conffile. */
1873	#define ARGPARSE_OPT_HEADER (1<<9) /* The value is printed as a header. */
1874	#define ARGPARSE_OPT_VERBATIM (1<<10)/* The value is printed verbatim. */
1875	#define ARGPARSE_ATTR_FORCE (1<<14)/* Attribute force is set. */
1876	#define ARGPARSE_ATTR_IGNORE (1<<15)/* Attribute ignore is set. */
1877
1878	/* A set of macros to make option definitions easier to read. */
1879	#define ARGPARSE_x(s,l,t,f,d) \
1880	{ (s), (l), ARGPARSE_TYPE_ ## t | (f), (d) }
1881
1882	#define ARGPARSE_s(s,l,t,d) \
1883	{ (s), (l), ARGPARSE_TYPE_ ## t, (d) }
1884	#define ARGPARSE_s_n(s,l,d) \
1885	{ (s), (l), ARGPARSE_TYPE_NONE, (d) }
1886	#define ARGPARSE_s_i(s,l,d) \
1887	{ (s), (l), ARGPARSE_TYPE_INT, (d) }
1888	#define ARGPARSE_s_s(s,l,d) \
1889	{ (s), (l), ARGPARSE_TYPE_STRING, (d) }
1890	#define ARGPARSE_s_l(s,l,d) \
1891	{ (s), (l), ARGPARSE_TYPE_LONG, (d) }
1892	#define ARGPARSE_s_u(s,l,d) \
1893	{ (s), (l), ARGPARSE_TYPE_ULONG, (d) }
1894
1895	#define ARGPARSE_o(s,l,t,d) \
1896	{ (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_OPTIONAL), (d) }
1897	#define ARGPARSE_o_n(s,l,d) \
1898	{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_OPTIONAL), (d) }
1899	#define ARGPARSE_o_i(s,l,d) \
1900	{ (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_OPTIONAL), (d) }
1901	#define ARGPARSE_o_s(s,l,d) \
1902	{ (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_OPTIONAL), (d) }
1903	#define ARGPARSE_o_l(s,l,d) \
1904	{ (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_OPTIONAL), (d) }
1905	#define ARGPARSE_o_u(s,l,d) \
1906	{ (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_OPTIONAL), (d) }
1907
1908	#define ARGPARSE_p(s,l,t,d) \
1909	{ (s), (l), (ARGPARSE_TYPE_ ## t | ARGPARSE_OPT_PREFIX), (d) }
1910	#define ARGPARSE_p_n(s,l,d) \
1911	{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_PREFIX), (d) }
1912	#define ARGPARSE_p_i(s,l,d) \
1913	{ (s), (l), (ARGPARSE_TYPE_INT | ARGPARSE_OPT_PREFIX), (d) }
1914	#define ARGPARSE_p_s(s,l,d) \
1915	{ (s), (l), (ARGPARSE_TYPE_STRING | ARGPARSE_OPT_PREFIX), (d) }
1916	#define ARGPARSE_p_l(s,l,d) \
1917	{ (s), (l), (ARGPARSE_TYPE_LONG | ARGPARSE_OPT_PREFIX), (d) }
1918	#define ARGPARSE_p_u(s,l,d) \
1919	{ (s), (l), (ARGPARSE_TYPE_ULONG | ARGPARSE_OPT_PREFIX), (d) }
1920
1921	#define ARGPARSE_op(s,l,t,d) \
1922	{ (s), (l), (ARGPARSE_TYPE_ ## t \
1923	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1924	#define ARGPARSE_op_n(s,l,d) \
1925	{ (s), (l), (ARGPARSE_TYPE_NONE \
1926	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1927	#define ARGPARSE_op_i(s,l,d) \
1928	{ (s), (l), (ARGPARSE_TYPE_INT \
1929	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1930	#define ARGPARSE_op_s(s,l,d) \
1931	{ (s), (l), (ARGPARSE_TYPE_STRING \
1932	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1933	#define ARGPARSE_op_l(s,l,d) \
1934	{ (s), (l), (ARGPARSE_TYPE_LONG \
1935	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1936	#define ARGPARSE_op_u(s,l,d) \
1937	{ (s), (l), (ARGPARSE_TYPE_ULONG \
1938	| ARGPARSE_OPT_OPTIONAL | ARGPARSE_OPT_PREFIX), (d) }
1939
1940	#define ARGPARSE_c(s,l,d) \
1941	{ (s), (l), (ARGPARSE_TYPE_NONE | ARGPARSE_OPT_COMMAND), (d) }
1942
1943	#define ARGPARSE_conffile(s,l,d) \
1944	{ (s), (l), (ARGPARSE_TYPE_STRING|ARGPARSE_OPT_CONFFILE), (d) }
1945
1946	#define ARGPARSE_noconffile(s,l,d) \
1947	{ (s), (l), (ARGPARSE_TYPE_NONE|ARGPARSE_OPT_CONFFILE), (d) }
1948
1949	/* This macro is for stub or obsolete options. */
1950	#define ARGPARSE_ignore(s,l) \
1951	{ (s), (l), (ARGPARSE_OPT_IGNORE), "@" }
1952
1953	/* This is a legacy version of ARGPARSE_verbatim which really does
1954	* verbatim printing. */
1955	#define ARGPARSE_group(s,d) \
1956	{ (s), NULL, 0, (d) }
1957
1958	/* Verbatim print the string D in the help output. It does not make
1959	* use of the "@" hack as ARGPARSE_group does. */
1960	#define ARGPARSE_verbatim(d) \
1961	{ 1, NULL, (ARGPARSE_OPT_VERBATIM), (d) }
1962
1963	/* Same as ARGPARSE_verbatim but also print a colon and a LF. N can
1964	* be used give a symbolic name to the header. Nothing is printed if
1965	* D is the empty string. */
1966	#define ARGPARSE_header(n,d) \
1967	{ 1, (n), (ARGPARSE_OPT_HEADER), (d) }
1968
1969	/* Mark the end of the list (mandatory). */
1970	#define ARGPARSE_end() \
1971	{ 0, NULL, 0, NULL }
1972
1973	#endif /* GPGRT_ENABLE_ARGPARSE_MACROS */
1974
1975	/* Values used for gpgrt_set_confdir. */
1976	#define GPGRT_CONFDIR_USER 1 /* The user's configuration dir. */
1977	#define GPGRT_CONFDIR_SYS 2 /* The systems's configuration dir. */
1978
1979	/* Take care: gpgrt_argparse keeps state in ARG and requires that
1980	* either ARGPARSE_FLAG_RESET is used after OPTS has been changed or
1981	* gpgrt_argparse (NULL, ARG, NULL) is called first. */
1982	int gpgrt_argparse (gpgrt_stream_t fp,
1983	gpgrt_argparse_t *arg, gpgrt_opt_t *opts);
1984	int gpgrt_argparser (gpgrt_argparse_t *arg, gpgrt_opt_t *opts,
1985	const char *confname);
1986	void gpgrt_usage (int level);
1987	const char *gpgrt_strusage (int level);
1988	void gpgrt_set_strusage (const char *(*f)(int));
1989	void gpgrt_set_usage_outfnc (int (*f)(int, const char *));
1990	void gpgrt_set_fixed_string_mapper (const char *(*f)(const char*));
1991	void gpgrt_set_confdir (int what, const char *name);
1992
1993
1994	/*
1995	* Various helper functions
1996	*/
1997
1998	/* Compare arbitrary version strings. For the standard m.n.o version
1999	* numbering scheme a LEVEL of 3 is suitable; see the manual. */
2000	int gpgrt_cmp_version (const char *a, const char *b, int level);
2001
2002	/* Construct a filename from the NULL terminated list of parts. Tilde
2003	* expansion is done for the first argument. The caller must release
2004	* the result using gpgrt_free; on error ERRNO is set and NULL
2005	* returned. The second function returns an absolute filename. */
2006	char *gpgrt_fnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0);
2007	char *gpgrt_absfnameconcat (const char *first, ...) GPGRT_ATTR_SENTINEL(0);
2008
2009
2010	#ifdef __cplusplus
2011	}
2012	#endif
2013	#endif /* GPGRT_H */
2014	#endif /* GPG_ERROR_H */
2015	/*
2016	Local Variables:
2017	buffer-read-only: t
2018	End:
2019	*/
2020