doc/
[gpgme.git] / gpgme / gpgme.h
1 /* gpgme.h -  GnuPG Made Easy
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *      Copyright (C) 2001, 2002 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GPGME is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #ifndef GPGME_H
23 #define GPGME_H
24
25 #include <stdio.h> /* For FILE *.  */
26 #ifdef _MSC_VER
27   typedef long off_t;
28 #else
29 # include <sys/types.h>
30 #endif
31
32 #ifdef __cplusplus
33 extern "C" {
34 #if 0 /* just to make Emacs auto-indent happy */
35 }
36 #endif
37 #endif
38
39
40 /* The version of this header should match the one of the library.  Do
41    not use this symbol in your application, use gpgme_check_version
42    instead.  The purpose of this macro is to let autoconf (using the
43    AM_PATH_GPGME macro) check that this header matches the installed
44    library.  Warning: Do not edit the next line.  configure will do
45    that for you!  */
46 #define GPGME_VERSION "0.3.6-cvs"
47
48
49 /* The opaque data types used by GPGME.  */
50
51 /* The context holds some global state and configration options as
52    well as the results of a crypto operation.  */
53 struct gpgme_context_s;
54 typedef struct gpgme_context_s *GpgmeCtx;
55
56 /* The data object used by GPGME to exchange arbitrary data.  */
57 struct gpgme_data_s;
58 typedef struct gpgme_data_s *GpgmeData;
59
60 /* A list of recipients to be used in an encryption operation.  */
61 struct gpgme_recipients_s;
62 typedef struct gpgme_recipients_s *GpgmeRecipients;
63
64 /* A key from the keyring.  */
65 struct gpgme_key_s;
66 typedef struct gpgme_key_s *GpgmeKey;
67
68 /* A trust item.  */
69 struct gpgme_trust_item_s;
70 typedef struct gpgme_trust_item_s *GpgmeTrustItem;
71
72
73 /* The error numbers used by GPGME.  */
74 typedef enum
75   {
76     GPGME_EOF                = -1,
77     GPGME_No_Error           = 0,
78     GPGME_General_Error      = 1,
79     GPGME_Out_Of_Core        = 2,
80     GPGME_Invalid_Value      = 3,
81     GPGME_Busy               = 4,
82     GPGME_No_Request         = 5,
83     GPGME_Exec_Error         = 6,
84     GPGME_Too_Many_Procs     = 7,
85     GPGME_Pipe_Error         = 8,
86     GPGME_No_Recipients      = 9,
87     GPGME_No_Data            = 10,
88     GPGME_Conflict           = 11,
89     GPGME_Not_Implemented    = 12,
90     GPGME_Read_Error         = 13,
91     GPGME_Write_Error        = 14,
92     GPGME_Invalid_Type       = 15,
93     GPGME_Invalid_Mode       = 16,
94     GPGME_File_Error         = 17,  /* errno is set in this case.  */
95     GPGME_Decryption_Failed  = 18,
96     GPGME_No_Passphrase      = 19,
97     GPGME_Canceled           = 20,
98     GPGME_Invalid_Key        = 21,
99     GPGME_Invalid_Engine     = 22,
100     GPGME_Invalid_Recipients = 23
101   }
102 GpgmeError;
103
104 /* The possible types of GpgmeData objects.  */
105 typedef enum
106   {
107     GPGME_DATA_TYPE_NONE = 0,
108     GPGME_DATA_TYPE_MEM  = 1,
109     GPGME_DATA_TYPE_FD   = 2,
110     GPGME_DATA_TYPE_FILE = 3,
111     GPGME_DATA_TYPE_CB   = 4
112   }
113 GpgmeDataType;
114
115 /* The possible signature stati.  */
116 typedef enum
117   {
118     GPGME_SIG_STAT_NONE  = 0,
119     GPGME_SIG_STAT_GOOD  = 1,
120     GPGME_SIG_STAT_BAD   = 2,
121     GPGME_SIG_STAT_NOKEY = 3,
122     GPGME_SIG_STAT_NOSIG = 4,
123     GPGME_SIG_STAT_ERROR = 5,
124     GPGME_SIG_STAT_DIFF  = 6
125   }
126 GpgmeSigStat;
127
128 /* The available signature modes.  */
129 typedef enum
130   {
131     GPGME_SIG_MODE_NORMAL = 0,
132     GPGME_SIG_MODE_DETACH = 1,
133     GPGME_SIG_MODE_CLEAR  = 2
134   }
135 GpgmeSigMode;
136
137 /* The available key attributes.  */
138 typedef enum
139   {
140     GPGME_ATTR_KEYID        = 1,
141     GPGME_ATTR_FPR          = 2,
142     GPGME_ATTR_ALGO         = 3,
143     GPGME_ATTR_LEN          = 4,
144     GPGME_ATTR_CREATED      = 5,
145     GPGME_ATTR_EXPIRE       = 6,
146     GPGME_ATTR_OTRUST       = 7,
147     GPGME_ATTR_USERID       = 8,
148     GPGME_ATTR_NAME         = 9,
149     GPGME_ATTR_EMAIL        = 10,
150     GPGME_ATTR_COMMENT      = 11,
151     GPGME_ATTR_VALIDITY     = 12,
152     GPGME_ATTR_LEVEL        = 13,
153     GPGME_ATTR_TYPE         = 14,
154     GPGME_ATTR_IS_SECRET    = 15,
155     GPGME_ATTR_KEY_REVOKED  = 16,
156     GPGME_ATTR_KEY_INVALID  = 17,
157     GPGME_ATTR_UID_REVOKED  = 18,
158     GPGME_ATTR_UID_INVALID  = 19,
159     GPGME_ATTR_KEY_CAPS     = 20,
160     GPGME_ATTR_CAN_ENCRYPT  = 21,
161     GPGME_ATTR_CAN_SIGN     = 22,
162     GPGME_ATTR_CAN_CERTIFY  = 23,
163     GPGME_ATTR_KEY_EXPIRED  = 24,
164     GPGME_ATTR_KEY_DISABLED = 25,
165     GPGME_ATTR_SERIAL       = 26,
166     GPGME_ATTR_ISSUER       = 27,
167     GPGME_ATTR_CHAINID      = 28
168   }
169 GpgmeAttr;
170
171 /* The available validities for a trust item or key.  */
172 typedef enum
173   {
174     GPGME_VALIDITY_UNKNOWN   = 0,
175     GPGME_VALIDITY_UNDEFINED = 1,
176     GPGME_VALIDITY_NEVER     = 2,
177     GPGME_VALIDITY_MARGINAL  = 3,
178     GPGME_VALIDITY_FULL      = 4,
179     GPGME_VALIDITY_ULTIMATE  = 5
180   }
181 GpgmeValidity;
182
183 /* The available protocols.  */
184 typedef enum
185   {
186     GPGME_PROTOCOL_OpenPGP = 0,  /* The default mode.  */
187     GPGME_PROTOCOL_CMS     = 1,
188     GPGME_PROTOCOL_AUTO    = 2
189   }
190 GpgmeProtocol;
191
192
193 /* The available keylist mode flags.  */
194 #define GPGME_KEYLIST_MODE_LOCAL 1
195 #define GPGME_KEYLIST_MODE_EXTERN 2
196
197
198 /* Types for callback functions.  */
199
200 /* Request a passphrase from the user.  */
201 typedef const char *(*GpgmePassphraseCb) (void *hook, const char *desc,
202                                           void **r_hd);
203
204 /* Inform the user about progress made.  */
205 typedef void (*GpgmeProgressCb) (void *opaque, const char *what,
206                                  int type, int current, int total);
207
208
209 /* Context management functions.  */
210
211 /* Create a new context and return it in CTX.  */
212 GpgmeError gpgme_new (GpgmeCtx *ctx);
213
214 /* Release the context CTX.  */
215 void gpgme_release (GpgmeCtx ctx);
216
217 /* Retrieve more info about performed signature check.  */
218 char *gpgme_get_notation (GpgmeCtx ctx);
219
220 /* Set the protocol to be used by CTX to PROTO.  */
221 GpgmeError gpgme_set_protocol (GpgmeCtx ctx, GpgmeProtocol proto);
222
223 /* If YES is non-zero, enable armor mode in CTX, disable it otherwise.  */
224 void gpgme_set_armor (GpgmeCtx ctx, int yes);
225
226 /* Return non-zero if armor mode is set in CTX.  */
227 int gpgme_get_armor (GpgmeCtx ctx);
228
229 /* If YES is non-zero, enable text mode in CTX, disable it otherwise.  */
230 void gpgme_set_textmode (GpgmeCtx ctx, int yes);
231
232 /* Return non-zero if text mode is set in CTX.  */
233 int gpgme_get_textmode (GpgmeCtx ctx);
234
235 /* Include up to NR_OF_CERTS certificates in an S/MIME message.  */
236 void gpgme_set_include_certs (GpgmeCtx ctx, int nr_of_certs);
237
238 /* Return the number of certs to include in an S/MIME message.  */
239 int gpgme_get_include_certs (GpgmeCtx ctx);
240
241 /* Set keylist mode in CTX to MODE.  */
242 GpgmeError gpgme_set_keylist_mode (GpgmeCtx ctx, int mode);
243
244 /* Get keylist mode in CTX.  */
245 int gpgme_get_keylist_mode (GpgmeCtx ctx);
246
247 /* Set the passphrase callback function in CTX to CB.  HOOK_VALUE is
248    passed as first argument to the passphrase callback function.  */
249 void gpgme_set_passphrase_cb (GpgmeCtx ctx,
250                               GpgmePassphraseCb cb, void *hook_value);
251
252 /* Get the current passphrase callback function in *CB and the current
253    hook value in *HOOK_VALUE.  */
254 void gpgme_get_passphrase_cb (GpgmeCtx ctx, GpgmePassphraseCb *cb,
255                               void **hook_value);
256
257 /* Set the progress callback function in CTX to CB.  HOOK_VALUE is
258    passed as first argument to the progress callback function.  */
259 void gpgme_set_progress_cb (GpgmeCtx c, GpgmeProgressCb cb, void *hook_value);
260
261 /* Get the current progress callback function in *CB and the current
262    hook value in *HOOK_VALUE.  */
263 void gpgme_get_progress_cb (GpgmeCtx ctx, GpgmeProgressCb *cb,
264                             void **hook_value);
265
266 /* Delete all signers from CTX.  */
267 void gpgme_signers_clear (GpgmeCtx ctx);
268
269 /* Add KEY to list of signers in CTX.  */
270 GpgmeError gpgme_signers_add (GpgmeCtx ctx, const GpgmeKey key);
271
272 /* Return the SEQth signer's key in CTX.  */
273 GpgmeKey gpgme_signers_enum (const GpgmeCtx ctx, int seq);
274
275 /* Retrieve the signature status of signature IDX in CTX after a
276    successful verify operation in R_STAT (if non-null).  The creation
277    time stamp of the signature is returned in R_CREATED (if non-null).
278    The function returns a string containing the fingerprint.  */
279 const char *gpgme_get_sig_status (GpgmeCtx ctx, int idx,
280                                   GpgmeSigStat *r_stat, time_t *r_created);
281
282 /* Get the key used to create signature IDX in CTX and return it in
283    R_KEY.  */
284 GpgmeError gpgme_get_sig_key (GpgmeCtx ctx, int idx, GpgmeKey *r_key);
285
286 /* Return a string with more info about the last crypto operating in CTX.
287    RESERVED should be zero.  The user has to free the string.  */
288 char *gpgme_get_op_info (GpgmeCtx ctx, int reserved);
289
290
291 /* Run control.  */
292
293 /* Cancel a pending operation in CTX.  */
294 void       gpgme_cancel (GpgmeCtx ctx);
295
296 /* Process the pending operation and, if HANG is non-zero, wait for
297    the pending operation to finish.  */
298 GpgmeCtx gpgme_wait (GpgmeCtx ctx, GpgmeError *status, int hang);
299
300
301 /* Functions to handle recipients.  */
302
303 /* Create a new recipients set and return it in R_RSET.  */
304 GpgmeError gpgme_recipients_new (GpgmeRecipients *r_rset);
305
306 /* Release the recipients set RSET.  */
307 void gpgme_recipients_release (GpgmeRecipients rset);
308
309 /* Add NAME to the recipients set RSET.  */
310 GpgmeError gpgme_recipients_add_name (GpgmeRecipients rset, const char *name);
311
312 /* Add NAME with validity AL to the recipients set RSET.  */
313 GpgmeError gpgme_recipients_add_name_with_validity (GpgmeRecipients rset,
314                                                     const char *name,
315                                                     GpgmeValidity val);
316
317 /* Return the number of recipients in RSET.  */
318 unsigned int gpgme_recipients_count (const GpgmeRecipients rset);
319
320 /* Create a new enumeration handle for the recipients set RSET and
321    return it in ITER.  */
322 GpgmeError gpgme_recipients_enum_open (const GpgmeRecipients rset,
323                                        void **iter);
324
325 /* Return the next recipient from the recipient set RSET in the
326    enumerator ITER.  */
327 const char *gpgme_recipients_enum_read (const GpgmeRecipients rset,
328                                         void **iter);
329
330 /* Destroy the enumerator ITER for the recipient set RSET.  */
331 GpgmeError gpgme_recipients_enum_close (const GpgmeRecipients rset,
332                                         void **iter);
333
334
335 /* Functions to handle data objects.  */
336
337 /* Create a new data buffer and return it in R_DH.  */
338 GpgmeError gpgme_data_new (GpgmeData *r_dh);
339
340 /* Create a new data buffer filled with SIZE bytes starting from
341    BUFFER.  If COPY is zero, copying is delayed until necessary, and
342    the data is taken from the original location when needed.  */
343 GpgmeError gpgme_data_new_from_mem (GpgmeData *r_dh,
344                                     const char *buffer, size_t size,
345                                     int copy);
346
347 /* Create a new data buffer which retrieves the data from the callback
348    function READ_CB.  */
349 GpgmeError gpgme_data_new_with_read_cb (GpgmeData *r_dh,
350                                         int (*read_cb) (void*,char *,size_t,size_t*),
351                                         void *read_cb_value);
352
353 /* Create a new data buffer filled with the content of file FNAME.
354    COPY must be non-zero (delayed reads are not supported yet).  */
355 GpgmeError gpgme_data_new_from_file (GpgmeData *r_dh,
356                                      const char *fname,
357                                      int copy);
358
359 /* Create a new data buffer filled with LENGTH bytes starting from
360    OFFSET within the file FNAME or stream FP (exactly one must be
361    non-zero).  */
362 GpgmeError gpgme_data_new_from_filepart (GpgmeData *r_dh,
363                                          const char *fname, FILE *fp,
364                                          off_t offset, size_t length);
365
366 /* Destroy the data buffer DH.  */
367 void gpgme_data_release (GpgmeData dh);
368
369 /* Destroy the data buffer DH and return a pointer to its content.
370    The memory has be to released with free by the user.  It's size is
371    returned in R_LEN.  */
372 char *gpgme_data_release_and_get_mem (GpgmeData dh, size_t *r_len);
373
374 /* Return the type of the data buffer DH.  */
375 GpgmeDataType gpgme_data_get_type (GpgmeData dh);
376
377 /* Reset the read pointer in DH.  */
378 GpgmeError gpgme_data_rewind (GpgmeData dh);
379
380 /* Read LENGTH bytes from the data object DH and store them in the
381    memory starting at BUFFER.  The number of bytes actually read is
382    returned in NREAD.  */
383 GpgmeError gpgme_data_read (GpgmeData dh, char *buffer,
384                             size_t length, size_t *nread);
385
386 /* Write LENGTH bytes starting from BUFFER into the data object DH.  */
387 GpgmeError gpgme_data_write (GpgmeData dh, const char *buffer, size_t length);
388
389
390 /* Key and trust functions.  */
391
392 /* Acquire a reference to KEY.  */
393 void gpgme_key_ref (GpgmeKey key);
394
395 /* Release a reference to KEY.  If this was the last one the key is
396    destroyed.  */
397 void gpgme_key_unref (GpgmeKey key);
398 void gpgme_key_release (GpgmeKey key);
399
400 /* Get the data from key KEY in a XML string, which has to be released
401    with free by the user.  */
402 char *gpgme_key_get_as_xml (GpgmeKey key);
403
404 /* Return the value of the attribute WHAT of KEY, which has to be
405    representable by a string.  IDX specifies a running index if the
406    attribute appears more than once in the key.  */
407 const char *gpgme_key_get_string_attr (GpgmeKey key, GpgmeAttr what,
408                                        const void *reserved, int idx);
409
410 /* Return the value of the attribute WHAT of KEY, which has to be
411    representable by an unsigned integer.  IDX specifies a running
412    index if the attribute appears more than once in the key.  */
413 unsigned long gpgme_key_get_ulong_attr (GpgmeKey key, GpgmeAttr what,
414                                         const void *reserved, int idx);
415
416 /* Release the trust item ITEM.  */
417 void gpgme_trust_item_release (GpgmeTrustItem item);
418
419 /* Return the value of the attribute WHAT of ITEM, which has to be
420    representable by a string.  IDX specifies a running index if the
421    attribute appears more than once in the key.  */
422 const char *gpgme_trust_item_get_string_attr (GpgmeTrustItem item,
423                                               GpgmeAttr what,
424                                               const void *reserved, int idx);
425
426 /* Return the value of the attribute WHAT of KEY, which has to be
427    representable by an integer.  IDX specifies a running index if the
428    attribute appears more than once in the key.  */
429 int gpgme_trust_item_get_int_attr (GpgmeTrustItem item, GpgmeAttr what,
430                                    const void *reserved, int idx);
431
432
433 /* Crypto operation function.  */
434
435 /* Encrypt plaintext PLAIN within CTX for the recipients RECP and
436    store the resulting ciphertext in CIPHER.  */
437 GpgmeError gpgme_op_encrypt_start (GpgmeCtx ctx,
438                                    GpgmeRecipients recp,
439                                    GpgmeData plain, GpgmeData cipher);
440 GpgmeError gpgme_op_encrypt (GpgmeCtx ctx,
441                              GpgmeRecipients recp,
442                              GpgmeData plain, GpgmeData cipher);
443
444 /* Encrypt plaintext PLAIN within CTX for the recipients RECP and
445    store the resulting ciphertext in CIPHER.  Also sign the ciphertext
446    with the signers in CTX.  */
447 GpgmeError gpgme_op_encrypt_sign_start (GpgmeCtx ctx,
448                                         GpgmeRecipients recp,
449                                         GpgmeData plain, GpgmeData cipher);
450 GpgmeError gpgme_op_encrypt_sign (GpgmeCtx ctx,
451                                   GpgmeRecipients recp,
452                                   GpgmeData plain, GpgmeData cipher);
453
454 /* Decrypt ciphertext CIPHER within CTX and store the resulting
455    plaintext in PLAIN.  */
456 GpgmeError gpgme_op_decrypt_start (GpgmeCtx ctx,
457                                    GpgmeData cipher, GpgmeData plain);
458 GpgmeError gpgme_op_decrypt (GpgmeCtx ctx,
459                              GpgmeData cipher, GpgmeData plain);
460
461 /* Decrypt ciphertext CIPHER and make a signature verification within
462    CTX and store the resulting plaintext in PLAIN.  */
463 GpgmeError gpgme_op_decrypt_verify_start (GpgmeCtx ctx,
464                                           GpgmeData cipher, GpgmeData plain);
465 GpgmeError gpgme_op_decrypt_verify (GpgmeCtx ctx,
466                                     GpgmeData cipher, GpgmeData plain,
467                                     GpgmeSigStat *r_status);
468
469 /* Sign the plaintext PLAIN and store the signature in SIG.  Only
470    detached signatures are supported for now.  */
471 GpgmeError gpgme_op_sign_start (GpgmeCtx ctx,
472                                 GpgmeData plain, GpgmeData sig,
473                                 GpgmeSigMode mode);
474 GpgmeError gpgme_op_sign (GpgmeCtx ctx,
475                           GpgmeData plain, GpgmeData sig,
476                           GpgmeSigMode mode);
477
478 /* Verify within CTX that SIG is a valid signature for TEXT.  */
479 GpgmeError gpgme_op_verify_start (GpgmeCtx ctx,
480                                   GpgmeData sig, GpgmeData text);
481 GpgmeError gpgme_op_verify (GpgmeCtx ctx,
482                             GpgmeData sig, GpgmeData text,
483                             GpgmeSigStat *r_status);
484
485 /* Import the key in KEYDATA into the keyring.  */
486 GpgmeError gpgme_op_import_start (GpgmeCtx ctx, GpgmeData keydata);
487 GpgmeError gpgme_op_import (GpgmeCtx ctx, GpgmeData keydata);
488
489 /* Export the keys listed in RECP into KEYDATA.  */
490 GpgmeError gpgme_op_export_start (GpgmeCtx ctx, GpgmeRecipients recp,
491                                   GpgmeData keydata);
492 GpgmeError gpgme_op_export (GpgmeCtx ctx, GpgmeRecipients recp,
493                             GpgmeData keydata);
494
495 /* Generate a new keypair and add it to the keyring.  PUBKEY and
496    SECKEY should be null for now.  PARMS specifies what keys should be
497    generated.  */
498 GpgmeError gpgme_op_genkey_start (GpgmeCtx ctx, const char *parms,
499                                   GpgmeData pubkey, GpgmeData seckey);
500 GpgmeError gpgme_op_genkey (GpgmeCtx ctx, const char *parms,
501                             GpgmeData pubkey, GpgmeData seckey);
502
503 /* Delete KEY from the keyring.  If ALLOW_SECRET is non-zero, secret
504    keys are also deleted.  */
505 GpgmeError gpgme_op_delete_start (GpgmeCtx ctx, const GpgmeKey key,
506                                   int allow_secret);
507 GpgmeError gpgme_op_delete (GpgmeCtx ctx, const GpgmeKey key,
508                             int allow_secret);
509
510
511 /* Key management functions */
512
513 /* Start a keylist operation within CTX, searching for keys which
514    match PATTERN.  If SECRET_ONLY is true, only secret keys are
515    returned.  */
516 GpgmeError gpgme_op_keylist_start (GpgmeCtx ctx,
517                                    const char *pattern, int secret_only);
518 GpgmeError gpgme_op_keylist_ext_start (GpgmeCtx ctx, const char *pattern[],
519                                        int secret_only, int reserved);
520
521 /* Return the next key from the keylist in R_KEY.  */
522 GpgmeError gpgme_op_keylist_next (GpgmeCtx ctx, GpgmeKey *r_key);
523
524 /* Terminate a pending keylist operation within CTX.  */
525 GpgmeError gpgme_op_keylist_end (GpgmeCtx ctx);
526
527
528 /* Start a trustlist operation within CTX, searching for trust items
529    which match PATTERN.  */
530 GpgmeError gpgme_op_trustlist_start (GpgmeCtx ctx,
531                                      const char *pattern, int max_level);
532
533 /* Return the next trust item from the trustlist in R_ITEM.  */
534 GpgmeError gpgme_op_trustlist_next (GpgmeCtx ctx, GpgmeTrustItem *r_item);
535
536 /* Terminate a pending trustlist operation within CTX.  */
537 GpgmeError gpgme_op_trustlist_end (GpgmeCtx ctx);
538
539
540 /* Various functions.  */
541
542 /* Check that the library fulfills the version requirement.  */
543 const char *gpgme_check_version (const char *req_version);
544
545 /* Check that the backend engine is available.  DEPRECATED.  */
546 GpgmeError  gpgme_check_engine (void);
547
548 /* Retrieve information about the backend engines.  */
549 const char *gpgme_get_engine_info (void);
550
551 /* Return a string describing ERR.  */
552 const char *gpgme_strerror (GpgmeError err);
553
554 /* Register an idle function.  */
555 typedef void (*GpgmeIdleFunc)(void);
556 GpgmeIdleFunc gpgme_register_idle (GpgmeIdleFunc idle);
557
558
559 /* Engine support functions.  */
560
561 /* Verify that the engine implementing PROTO is installed and
562    available.  */
563 GpgmeError gpgme_engine_check_version (GpgmeProtocol proto);
564
565
566 #ifdef __cplusplus
567 }
568 #endif
569 #endif /* GPGME_H */