67e496ec7c3f19133cf1425b0e9e3057c1c36921
[gpgme.git] / doc / gpgme.texi
1 \input texinfo                  @c -*- Texinfo -*-
2 @setfilename gpgme.info
3 @settitle The `GnuPG Made Easy' Reference Manual
4
5 @dircategory GNU Libraries
6 @direntry
7 * @acronym{GPGME}: (gpgme).          Adding support for cryptography to your program.
8 @end direntry
9
10 @include version.texi
11
12 @c Unify some of the indices.
13 @syncodeindex tp fn
14 @syncodeindex pg fn
15
16 @ifinfo
17 This file documents the @acronym{GPGME} library.
18
19 This is Edition @value{EDITION}, last updated @value{UPDATED}, of
20 @cite{The `GnuPG Made Easy' Reference Manual}, for Version
21 @value{VERSION}.
22
23 Copyright @copyright{} 2002 g10 Code GmbH.
24
25 Permission is granted to copy, distribute and/or modify this document
26 under the terms of the GNU Free Documentation License, Version 1.1 or
27 any later version published by the Free Software Foundation; with the
28 Invariant Sections being ``Free Software Needs Free Documentation'' and
29 ``GNU Lesser General Public License'', the Front-Cover texts being (a)
30 (see below), and with the Back-Cover Texts being (b) (see below).  A
31 copy of the license is included in the section entitled ``GNU Free
32 Documentation License''.
33
34 @end ifinfo
35
36 @iftex
37 @shorttitlepage The `GnuPG Made Easy' Reference Manual
38 @end iftex
39 @titlepage
40 @center @titlefont{The `GnuPG Made Easy'}
41 @sp 1
42 @center @titlefont{Reference Manual}
43 @sp 6
44 @center Edition @value{EDITION}
45 @sp 1
46 @center last updated @value{UPDATED}
47 @sp 1
48 @center for version @value{VERSION}
49 @page
50 @vskip 0pt plus 1filll
51 Copyright @copyright{} 2002 g10 Code GmbH.
52
53 Permission is granted to copy, distribute and/or modify this document
54 under the terms of the GNU Free Documentation License, Version 1.1 or
55 any later version published by the Free Software Foundation; with the
56 Invariant Sections being ``Free Software Needs Free Documentation'' and
57 ``GNU Lesser General Public License'', the Front-Cover texts being (a)
58 (see below), and with the Back-Cover Texts being (b) (see below).  A
59 copy of the license is included in the section entitled ``GNU Free
60 Documentation License''.
61 @end titlepage
62 @page
63
64 @ifnottex
65 @node Top
66 @top Main Menu
67 This is Edition @value{EDITION}, last updated @value{UPDATED}, of
68 @cite{The `GnuPG Made Easy' Reference Manual}, for Version
69 @value{VERSION} of the @acronym{GPGME} library.
70 @end ifnottex
71
72 @menu
73 * Introduction::                  How to use this manual.
74 * Preparation::                   What you should do before using the library.
75 * Protocols and Engines::         Supported crypto protocols.
76 * Error Handling::                Error numbers and their meanings.
77 * Exchanging Data::               Passing data to and from @acronym{GPGME}.
78 * Contexts::                      Handling @acronym{GPGME} contexts.
79
80 Appendices
81
82 * Copying::                       The GNU General Public License says how you
83                                   can copy and share `GnuPG Made Easy'.
84 * Free Documentation License::    This manual is under the GNU Free
85                                   Documentation License.
86
87 Indices
88
89 * Concept Index::                 Index of concepts and programs.
90 * Function and Data Index::       Index of functions, variables and data types.
91
92
93 @detailmenu
94  --- The Detailed Node Listing ---
95
96 Introduction
97
98 * Getting Started::               Purpose of the manual, and how to use it.
99 * Features::                      Reasons to install and use @acronym{GPGME}.
100 * Overview::                      Basic architecture of the @acronym{GPGME} library.
101
102 Preparation
103
104 * Header::                        What header file you need to include.
105 * Building the Source::           Compiler options to be used.
106 * Using Automake::                Compiler options to be used the easy way.
107 * Library Version Check::         Getting and verifying the library version.
108 * Multi Threading::               How GPGME can be used in an MT environment.
109
110 Protocols and Engines
111
112 * Engine Version Check::          Verifying the engine version.
113 * Engine Information::            Obtaining more information about the engines.
114 * OpenPGP::                       Support for the OpenPGP protocol.
115 * Cryptographic Message Syntax::  Support for the CMS.
116
117 Error Handling
118
119 * Error Values::                  A list of all error values used.
120 * Error Strings::                 How to get a descriptive string from a value.
121
122 Exchanging Data 
123
124 * Creating Data Buffers::         Creating new data buffers.
125 * Destroying Data Buffers::       Releasing data buffers.
126 * Manipulating Data Buffers::     Operations on data buffers.
127
128 Contexts
129
130 * Creating Contexts::             Creating new @acronym{GPGME} contexts.
131 * Destroying Contexts::           Releasing @acronym{GPGME} contexts.
132 * Context Attributes::            Setting properties of a context.
133 * Key Management::                Managing keys with @acronym{GPGME}.
134 * Trust Item Management::         Managing trust items with @acronym{GPGME}.
135 * Crypto Operations::             Using a context for cryptography.
136 * Run Control::                   Controlling how operations are run.
137
138 Context Attributes
139
140 * Protocol Selection::            Selecting the protocol used by a context.
141 * @acronym{ASCII} Armor::                   Requesting @acronym{ASCII} armored output.
142 * Text Mode::                     Choosing canonical text mode.
143 * Included Certificates::         Including a number of certificates.
144 * Key Listing Mode::              Selecting key listing mode.
145 * Passphrase Callback::           Getting the passphrase from the user.
146 * Progress Meter Callback::       Being informed about the progress.
147
148 Key Management
149
150 * Listing Keys::                  Browsing the list of available keys.
151 * Information About Keys::        Requesting detailed information about keys.
152 * Manipulating Keys::             Operations on keys.
153 * Generating Keys::               Creating new key pairs.
154 * Exporting Keys::                Retrieving key data from the key ring.
155 * Importing Keys::                Adding keys to the key ring.
156 * Deleting Keys::                 Removing keys from the key ring.
157
158 Trust Item Management
159
160 * Listing Trust Items::           Browsing the list of available trust items.
161 * Information About Trust Items:: Requesting detailed information about trust items.
162 * Manipulating Trust Items::      Operations on trust items.
163
164 Crypto Operations
165
166 * Decrypt::                       Decrypting a ciphertext.
167 * Verify::                        Verifying a signature.
168 * Decrypt and Verify::            Decrypting a signed ciphertext.
169 * Sign::                          Creating a signature.
170 * Encrypt::                       Encrypting a plaintext.
171 * Detailed Results::              How to obtain more info about the operation.
172
173 Sign
174
175 * Selecting Signers::             How to choose the keys to sign with.
176 * Creating a Signature::          How to create a signature.
177
178 Encrypt
179
180 * Selecting Recipients::          How to choose the recipients.
181 * Encrypting a Plaintext::        How to encrypt a plaintext.
182
183 Run Control
184
185 * Waiting For Completion::        Waiting until an operation is completed.
186 * Cancelling an Operation::       Interrupting a running operation.
187 * Hooking Up Into Idle Time::     Doing something when nothing has to be done.
188
189 @end detailmenu
190 @end menu
191
192 @node Introduction
193 @chapter Introduction
194
195 `GnuPG Made Easy' (@acronym{GPGME}) is a C language library that
196 allows to add support for cryptography to a program.  It is designed
197 to make access to crypto engines like GnuPG or GpgSM easier for
198 applications.  @acronym{GPGME} provides a high-level crypto API for
199 encryption, decryption, signing, signature verification and key
200 management.
201
202 @acronym{GPGME} uses GnuPG and GpgSM as its backends to support
203 OpenPGP and the Cryptographic Message Syntax (CMS).
204
205 @menu
206 * Getting Started::               Purpose of the manual, and how to use it.
207 * Features::                      Reasons to install and use @acronym{GPGME}.
208 * Overview::                      Basic architecture of the @acronym{GPGME} library.
209 @end menu
210
211
212 @node Getting Started
213 @section Getting Started
214
215 This library documents the @acronym{GPGME} library programming
216 interface.  All functions and data types provided by the library are
217 explained.
218
219 The reader is assumed to possess basic knowledge about cryptography in
220 general, and public key cryptography in particular.  The underlying
221 cryptographic engines that are used by the library are not explained,
222 but where necessary, special features or requirements by an engine are
223 mentioned as far as they are relevant to @acronym{GPGME} or its users.
224
225 This manual can be used in several ways.  If read from the beginning
226 to the end, it gives a good introduction into the library and how it
227 can be used in an application.  Forward references are included where
228 necessary.  Later on, the manual can be used as a reference manual to
229 get just the information needed about any particular interface of the
230 library.  Experienced programmers might want to start looking at the
231 examples at the end of the manual, and then only read up those parts
232 of the interface which are unclear.
233
234
235 @node Features
236 @section Features
237
238 @acronym{GPGME} has a couple of advantages over other libraries doing
239 a similar job, and over implementing support for GnuPG or other crypto
240 engines into your application directly.
241
242 @table @asis
243 @item it's free software
244 Anybody can use, modify, and redistribute it under the terms of the GNU
245 General Public License (@pxref{Copying}).
246
247 @item it's flexible
248 @acronym{GPGME} provides transparent support for several cryptographic
249 protocols by different engines.  Currently, @acronym{GPGME} supports
250 the OpenPGP protocol using GnuPG as the backend, and the Cryptographic
251 Message Syntax using GpgSM as the backend.
252
253 @item it's easy
254 @acronym{GPGME} hides the differences between the protocols and
255 engines from the programmer behind an easy-to-use interface.  This way
256 the programmer can focus on the other parts of the program, and still
257 integrate strong cryptography in his application.  Once support for
258 @acronym{GPGME} has been added to a program, it is easy to add support
259 for other crypto protocols once @acronym{GPGME} backends provide them.
260 @end table
261
262
263 @node Overview
264 @section Overview
265
266 @acronym{GPGME} provides a data abstraction that is used to pass data
267 to the crypto engine, and receive returned data from it.  Data can be
268 read from memory or from files, but it can also be provided by a
269 callback function.
270
271 The actual cryptographic operations are always set within a context.
272 A context provides configuration parameters that define the behaviour
273 of all operations performed within it.  Only one operation per context
274 is allowed at any time, but when one operation is finished, you can
275 run the next operation in the same context.  There can be more than
276 one context, and all can run different operations at the same time.
277
278 Furthermore, @acronym{GPGME} has rich key management facilities
279 including listing keys, querying their attributes, generating,
280 importing, exporting and deleting keys, and acquiring information
281 about the trust path.
282
283 With some precautions, @acronym{GPGME} can be used in a multi-threaded
284 environment, although it is not completely thread safe and thus needs
285 the support of the application.
286
287
288 @node Preparation
289 @chapter Preparation
290
291 To use @acronym{GPGME}, you have to perform some changes to your
292 sources and the build system.  The necessary changes are small and
293 explained in the following sections.  At the end of this chapter, it
294 is described how the library is initialized, and how the requirements
295 of the library are verified.
296
297 @menu
298 * Header::                        What header file you need to include.
299 * Building the Source::           Compiler options to be used.
300 * Using Automake::                Compiler options to be used the easy way.
301 * Library Version Check::         Getting and verifying the library version.
302 * Multi Threading::               How GPGME can be used in an MT environment.
303 @end menu
304
305
306 @node Header
307 @section Header
308 @cindex header file
309 @cindex include file
310
311 All interfaces (data types and functions) of the library are defined
312 in the header file `gpgme.h'.  You must include this in all programs
313 using the library, either directly or through some other header file,
314 like this:
315
316 @example
317 #include <gpgme.h>
318 @end example
319
320 The name space of @acronym{GPGME} is @code{gpgme_*} for function
321 names, @code{Gpgme*} for data types and @code{GPGME_*} for other
322 symbols.
323
324
325 @node Building the Source
326 @section Building the Source
327 @cindex compiler options
328 @cindex compiler flags
329
330 If you want to compile a source file including the `gpgme.h' header
331 file, you must make sure that the compiler can find it in the
332 directory hierarchy.  This is accomplished by adding the path to the
333 directory in which the header file is located to the compilers include
334 file search path (via the @option{-I} option).
335
336 However, the path to the include file is determined at the time the
337 source is configured.  To solve this problem, gpgme ships with a small
338 helper program @command{gpgme-config} that knows about the path to the
339 include file and other configuration options.  The options that need
340 to be added to the compiler invocation at compile time are output by
341 the @option{--cflags} option to @command{gpgme-config}.  The following
342 example shows how it can be used at the command line:
343
344 @example
345 gcc -c foo.c `gpgme-config --cflags`
346 @end example
347
348 Adding the output of @samp{gpgme-config --cflags} to the compilers
349 command line will ensure that the compiler can find the @acronym{GPGME} header
350 file.
351
352 A similar problem occurs when linking the program with the library.
353 Again, the compiler has to find the library files.  For this to work,
354 the path to the library files has to be added to the library search
355 path (via the @option{-L} option).  For this, the option
356 @option{--libs} to @command{gpgme-config} can be used.  For
357 convenience, this option also outputs all other options that are
358 required to link the program with @acronym{GPGME} (in particular, the
359 @samp{-lgpgme} option).  The example shows how to link @file{foo.o}
360 with the @acronym{GPGME} library to a program @command{foo}.
361
362 @example
363 gcc -o foo foo.o `gpgme-config --libs`
364 @end example
365
366 Of course you can also combine both examples to a single command by
367 specifying both options to @command{gpgme-config}:
368
369 @example
370 gcc -o foo foo.c `gpgme-config --cflags --libs`
371 @end example
372
373
374 @node Using Automake
375 @section Using Automake
376 @cindex automake
377 @cindex autoconf
378
379 It is much easier if you use GNU Automake instead writing your own
380 Makefiles.  If you do that you don't have to worry about finding and
381 invoking the @command{gpgme-config} script at all.  @acronym{GPGME}
382 provides an extension to Automake that does all the work for you.
383
384 @c A simple macro for optional variables.
385 @macro ovar{varname}
386 @r{[}@var{\varname\}@r{]}
387 @end macro
388 @defmac AM_PATH_GPGME (@ovar{minimum-version}, @ovar{action-if-found}, @ovar{action-if-not-found})
389 Check whether @acronym{GPGME} (at least version @var{minimum-version},
390 if given) exists on the host system.  If it is found, execute
391 @var{action-if-found}, otherwise do @var{action-if-not-found}, if
392 given.
393
394 Additionally, the function defines @code{GPGME_CFLAGS} to the flags
395 needed for compilation of the program to find the @file{gpgme.h}
396 header file, and @code{GPGME_LIBS} to the linker flags needed to link
397 the program to the @acronym{GPGME} library.
398 @end defmac
399
400 You can use the defined Autoconf variables like this in your
401 @file{Makefile.am}:
402
403 @example
404 AM_CPPFLAGS = $(GPGME_CFLAGS)
405 LDADD = $(GPGME_LIBS)
406 @end example
407
408
409 @node Library Version Check
410 @section Library Version Check
411 @cindex version check, of the library
412
413 @deftypefun {const char *} gpgme_check_version (@w{const char *@var{required_version}})
414 The function @code{gpgme_check_version} has three purposes.  It can be
415 used to retrieve the version number of the library.  In addition it
416 can verify that the version number is higher than a certain required
417 version number.  In either case, the function initializes some
418 sub-systems, and for this reason alone it must be invoked early in
419 your program, before you make use of the other functions in
420 @acronym{GPGME}.
421
422 If @var{required_version} is @code{NULL}, the function returns a
423 pointer to a statically allocated string containing the version number
424 of the library.
425
426 If @var{required_version} is not @code{NULL}, it should point to a
427 string containing a version number, and the function checks that the
428 version of the library is at least as high as the version number
429 provided.  In this case, the function returns a pointer to a
430 statically allocated string containing the version number of the
431 library.  If @var{REQUIRED_VERSION} is not a valid version number, or
432 if the version requirement is not met, the function returns
433 @code{NULL}.
434
435 If you use a version of a library that is backwards compatible with
436 older releases, but contains additional interfaces which your program
437 uses, this function provides a run-time check if the necessary
438 features are provided by the installed version of the library.
439 @end deftypefun
440
441
442 @node Multi Threading
443 @section Multi Threading
444 @cindex thread-safeness
445 @cindex multi-threading
446
447 The @acronym{GPGME} library is not entirely thread-safe, but it can
448 still be used in a multi-threaded environment if some care is taken.
449 If the following requirements are met, there should be no race
450 conditions to worry about:
451
452 @itemize @bullet
453 @item
454 The function @code{gpgme_check_version} must be called before any
455 other function in the library, because it initializes the locking
456 subsystem in @acronym{GPGME}.  To achieve this in all generality, it
457 is necessary to synchronize the call to this function with all other
458 calls to functions in the library, using the synchronization
459 mechanisms available in your thread library.  Otherwise, specific
460 compiler or CPU memory cache optimizations could lead to the situation
461 where a thread is started and uses @acronym{GPGME} before the effects
462 of the initialization are visible for this thread.  It doesn't even
463 suffice to call @code{gpgme_check_version} before creating this other
464 thread@footnote{In SMP systems the new thread could be started on
465 another CPU before the effects of the initialization are seen by that
466 CPU's memory cache.  Not doing proper synchronization here leads to
467 the same problems the double-checked locking idiom has.  You might
468 find that if you don't do proper synchronization, it still works in
469 most configurations.  Don't let this fool you.  Someday it might lead
470 to subtle bugs when someone tries it on a DEC Alpha or an SMP
471 machine.}.
472
473 For example, if you are using POSIX threads, each thread that wants to
474 call functions in @acronym{GPGME} could call the following function
475 before any function in the library:
476
477 @example
478 #include <pthread.h>
479
480 void
481 initialize_gpgme (void)
482 @{
483   static int gpgme_init;
484   static pthread_mutext_t gpgme_init_lock = PTHREAD_MUTEX_INITIALIZER;
485
486   pthread_mutex_lock (&gpgme_init_lock);
487   if (!gpgme_init)
488     @{
489       gpgme_check_version ();
490       gpgme_init = 1;
491     @}
492   pthread_mutex_unlock (&gpgme_init_lock);
493 @}
494 @end example
495
496 @item
497 Any @code{GpgmeData}, @code{GpgmeCtx} and @code{GpgmeRecipients}
498 object must only be accessed by one thread at a time.  If multiple
499 threads want to deal with the same object, the caller has to make sure
500 that operations on this object are fully synchronized.
501
502 @item
503 Only one thread is allowed to call @code{gpgme_wait} at a time.  If
504 multiple threads call this function, the caller must make sure that
505 all invocations are fully synchronized.
506
507 @item
508 Unfortunately, the last rule implies that all calls to one of the
509 following functions have to be fully synchronized together with
510 @code{gpgme_wait}, as they call @code{gpgme_wait} internally: All
511 functions @code{gpgme_op_FOO} that have a corresponding
512 @code{gpgme_op_FOO_start} function, @code{gpgme_op_keylist_next},
513 @code{gpgme_op_trustlist_next}.
514 @end itemize
515
516
517 @node Protocols and Engines
518 @chapter Protocols and Engines
519 @cindex protocol
520 @cindex engine
521 @cindex crypto engine
522 @cindex backend
523 @cindex crypto backend
524
525 @acronym{GPGME} supports several cryptographic protocols, however, it
526 does not implement them.  Rather it uses backends (also called
527 engines) which implement the protocol.  @acronym{GPGME} uses
528 inter-process communication to pass data back and forth between the
529 application and the backend, but the details of the communication
530 protocol and invocation of the backends is completely hidden by the
531 interface.  All complexity is handled by @acronym{GPGME}.  Where an
532 exchange of information between the application and the backend is
533 necessary, @acronym{GPGME} provides the necessary callback function
534 hooks and further interfaces.
535
536 @deftp {Data type} {enum GpgmeProtocol}
537 @tindex GpgmeProtocol
538 The @code{GpgmeProtocol} type specifies the set of possible protocol
539 values that are supported by @acronym{GPGME}.  The following protocols
540 are supported:
541
542 @table @code
543 @item GPGME_PROTOCOL_OpenPGP
544 This specifies the OpenPGP protocol.
545 @item GPGME_PROTOCOL_CMS
546 This specifies the Cryptographic Message Syntax.
547 @end table
548 @end deftp
549
550 @menu
551 * Engine Version Check::          Verifying the engine version.
552 * Engine Information::            Obtaining more information about the engines.
553 * OpenPGP::                       Support for the OpenPGP protocol.
554 * Cryptographic Message Syntax::  Support for the CMS.
555 @end menu
556
557
558 @node Engine Version Check
559 @section Engine Version Check
560 @cindex version check, of the engines
561
562 @deftypefun GpgmeError gpgme_engine_check_version (@w{GpgmeProtocol @var{protocol}})
563 The function @code{gpgme_engine_check_version} verifies that the
564 engine implementing the protocol @var{PROTOCOL} is installed in the
565 expected path and meets the version requirement of @acronym{GPGME}.
566
567 This function returns @code{GPGME_No_Error} if the engine is available
568 and @code{GPGME_Invalid_Engine} if it is not.
569 @end deftypefun
570
571 @deftypefun GpgmeError gpgme_check_engine (void)
572 The function @code{gpgme_check_engine} is equivalent to
573
574 @example
575 gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
576 @end example
577
578 This function is deprecated and provided for backwards compatibility
579 only.  It is obsoleted by @code{gpgme_engine_check_version}.
580 @end deftypefun
581
582
583 @node Engine Information
584 @section Engine Information
585 @cindex engine, information about
586
587 @deftypefun {const char *} gpgme_get_engine_info (void)
588 The function @code{gpgme_get_engine_info} returns an @acronym{XML}
589 string containing information about the available protocols and the
590 engine which implement them.  The following information is returned
591 for each engine:
592
593 @table @samp
594 @item <protocol>
595 The name of the protocol.
596 @item <version>
597 The version of the engine.
598 @item <path>
599 The path to the engine binary.
600 @end table
601
602 A string is always returned.  If an error occurs, the string will
603 contain an @samp{<error>} tag with a description of the failure.
604 @end deftypefun
605
606 Here is the example output of what @code{gpgme_get_engine_info} might
607 return on your system:
608
609 @example
610 <EngineInfo>
611  <engine>
612   <protocol>OpenPGP</protocol>
613   <version>1.0.6</version>
614   <path>/usr/bin/gpg</path>
615  </engine>
616  <engine>
617   <protocol>CMS</protocol>
618   <version>0.0.0</version>
619   <path>/usr/bin/gpgsm</path>
620  </engine>
621 </EngineInfo>
622 @end example
623
624
625 @node OpenPGP
626 @section OpenPGP
627 @cindex OpenPGP
628 @cindex GnuPG
629 @cindex protocol, GnuPG
630 @cindex engine, GnuPG
631
632 OpenPGP is implemented by GnuPG, the @acronym{GNU} Privacy Guard.
633 This is the first protocol that was supported by @acronym{GPGME}.
634
635 The OpenPGP protocol is specified by @code{GPGME_PROTOCOL_OpenPGP}.
636
637
638 @node Cryptographic Message Syntax
639 @section Cryptographic Message Syntax
640 @cindex CMS
641 @cindex cryptographic message syntax
642 @cindex GpgSM
643 @cindex protocol, CMS
644 @cindex engine, GpgSM
645 @cindex S/MIME
646 @cindex protocol, S/MIME
647
648 @acronym{CMS} is implemented by GpgSM, the S/MIME implementation for
649 GnuPG.
650
651 The @acronym{CMS} protocol is specified by @code{GPGME_PROTOCOL_CMS}.
652
653
654 @node Error Handling
655 @chapter Error Handling
656 @cindex error handling
657
658 Many functions in @acronym{GPGME} can return an error if they fail.
659 For this reason, the application should always catch the error
660 condition and take appropriate measures, for example by releasing the
661 resources and passing the error up to the caller, or by displaying a
662 descriptive message to the user and cancelling the operation.
663
664 Some error values do not indicate a system error or an error in the
665 operation, but the result of an operation that failed properly.  For
666 example, if you try to decrypt a tempered message, the decryption will
667 fail.  Another error value actually means that the end of a data
668 buffer or list has been reached.  The following descriptions explain
669 what each error message means in general.  Some error values have
670 specific meanings if returned by a specific function.  Such cases are
671 described in the documentation of those functions.
672
673 @menu
674 * Error Values::                  A list of all error values used.
675 * Error Strings::                 How to get a descriptive string from a value.
676 @end menu
677
678
679 @node Error Values
680 @section Error Values
681 @cindex error values, list of
682
683 @deftp {Data type} {enum GpgmeError}
684 @tindex GpgmeError
685 The @code{GpgmeError} type specifies the set of all error values that
686 are used by @acronym{GPGME}.  Possible values are:
687
688 @table @code
689 @item GPGME_EOF
690 This value indicates the end of a list, buffer or file.
691
692 @item GPGME_No_Error
693 This value indicates success.  The value of this error is @code{0}.
694
695 @item GPGME_General_Error
696 This value means that something went wrong, but either there is not
697 enough information about the problem to return a more useful error
698 value, or there is no separate error value for this type of problem.
699
700 @item GPGME_Out_Of_Core
701 This value means that an out-of-memory condition occurred.
702
703 @item GPGME_Invalid_Value
704 This value means that some user provided data was out of range.  This
705 can also refer to objects.  For example, if an empty @code{GpgmeData}
706 object was expected, but one containing data was provided, this error
707 value is returned.
708
709 @item GPGME_Busy
710 This value is returned if you try to start a new operation in a
711 context that is already busy with some earlier operation which was not
712 cancelled or finished yet.
713
714 @item GPGME_No_Request
715 This value is in some sense the opposite of @code{GPGME_Busy}.  There
716 is no pending operation, but it is required for the function to
717 succeed.
718
719 @item GPGME_Exec_Error
720 This value means that an error occurred when trying to spawn a child
721 process.
722
723 @item GPGME_Too_Many_Procs
724 This value means that there are too many active backend processes.
725
726 @item GPGME_Pipe_Error
727 This value means that the creation of a pipe failed.
728
729 @item GPGME_No_Recipients 
730 This value means that no valid recipients for a message have been set.
731
732 @item GPGME_Invalid_Recipients 
733 This value means that some, but not all, recipients for a message have
734 been invalid.
735
736 @item GPGME_No_Data
737 This value means that a @code{GpgmeData} object which was expected to
738 have content was found empty.
739
740 @item GPGME_Conflict
741 This value means that a conflict of some sort occurred.
742
743 @item GPGME_Not_Implemented
744 This value indicates that the specific function (or operation) is not
745 implemented.  This error should never happen.  It can only occur if
746 you use certain values or configuration options which do not work,
747 but for which we think that they should work at some later time.
748
749 @item GPGME_Read_Error
750 This value means that an I/O read operation failed.
751
752 @item GPGME_Write_Error
753 This value means that an I/O write operation failed.
754
755 @item GPGME_Invalid_Type
756 This value means that a user provided object was of a wrong or
757 incompatible type.  Usually this refers to the type of a
758 @code{GpgmeData} object.
759
760 @item GPGME_Invalid_Mode
761 This value means that a @code{GpgmeData} object has an incorrect mode
762 of operation (for example, doesn't support output although it is
763 attempted to use it as an output buffer).
764
765 @item GPGME_File_Error
766 This value means that a file I/O operation failed.  The value of
767 @code{errno} contains the system error value.
768
769 @item GPGME_Decryption_Failed
770 This value indicates that a decryption operation was unsuccessful.
771
772 @item GPGME_No_Passphrase
773 This value means that the user did not provide a passphrase when
774 requested.
775
776 @item GPGME_Canceled
777 This value means that the operation was canceled.
778
779 @item GPGME_Invalid_Key
780 This value means that a key was invalid.
781
782 @item GPGME_Invalid_Engine
783 This value means that the engine that implements the desired protocol
784 is currently not available.  This can either be because the sources
785 were configured to exclude support for this engine, or because the
786 engine is not installed properly.
787 @end table
788 @end deftp
789
790
791 @node Error Strings
792 @section Error Strings
793 @cindex error values, printing of
794 @cindex error strings
795
796 @deftypefun {const char *} gpgme_strerror (@w{GpgmeError @var{err}})
797 The function @code{gpgme_strerror} returns a pointer to a statically
798 allocated string containing a description of the error with the error
799 value @var{err}.  This string can be used to output a diagnostic
800 message to the user.
801
802 The following example illustrates the use of @code{gpgme_strerror}:
803
804 @example
805 GpgmeCtx ctx;
806 GpgmeError err = gpgme_new (&ctx);
807 if (err)
808   @{
809     fprintf (stderr, "%s: creating GpgME context failed: %s\n",
810              argv[0], gpgme_strerror (err));
811     exit (1);
812   @}
813 @end example
814 @end deftypefun
815
816
817 @node Exchanging Data
818 @chapter Exchanging Data
819 @cindex data, exchanging
820
821 A lot of data has to be exchanged between the user and the crypto
822 engine, like plaintext messages, ciphertext, signatures and
823 information about the keys.  The technical details about exchanging
824 the data information are completely abstracted by @acronym{GPGME}.
825 The user provides and receives the data via @code{GpgmeData} objects,
826 regardless of the communication protocol between @acronym{GPGME} and
827 the crypto engine in use.
828
829 @deftp {Data type} {GpgmeData}
830 The @code{GpgmeData} type is a handle for a container for generic
831 data, which is used by @acronym{GPGME} to exchange data with the user.
832 @end deftp
833
834 @menu
835 * Creating Data Buffers::         Creating new data buffers.
836 * Destroying Data Buffers::       Releasing data buffers.
837 * Manipulating Data Buffers::     Operations on data buffers.
838 @end menu
839
840
841 @node Creating Data Buffers
842 @section Creating Data Buffers
843 @cindex data buffer, creation
844
845 @deftypefun GpgmeError gpgme_data_new (@w{GpgmeData *@var{dh}})
846 The function @code{gpgme_data_new} creates a new @code{GpgmeData}
847 object and returns a handle for it in @var{dh}.  The data object is
848 initially empty.
849
850 The function returns @code{GPGME_No_Error} if the data object was
851 successfully created, @code{GPGME_Invalid_Value} if @var{dh} is not a
852 valid pointer, and @code{GPGME_Out_Of_Core} if not enough memory is
853 available.
854 @end deftypefun
855
856 @deftypefun GpgmeError gpgme_data_new_from_mem (@w{GpgmeData *@var{dh}}, @w{const char *@var{buffer}}, @w{size_t @var{size}}, @w{int @var{copy}})
857 The function @code{gpgme_data_new_from_mem} creates a new
858 @code{GpgmeData} object and fills it with @var{size} bytes starting
859 from @var{buffer}.
860
861 If @var{copy} is not zero, a private copy of the data is made.  If
862 @var{copy} is zero, the data is taken from the specified buffer as
863 needed, and the user has to ensure that the buffer remains valid for
864 the whole life span of the data object.
865
866 The function returns @code{GPGME_No_Error} if the data object was
867 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
868 @var{buffer} is not a valid pointer, and @code{GPGME_Out_Of_Core} if
869 not enough memory is available.
870 @end deftypefun
871
872 @deftypefun GpgmeError gpgme_data_new_from_file (@w{GpgmeData *@var{dh}}, @w{const char *@var{filename}}, @w{int @var{copy}})
873 The function @code{gpgme_data_new_from_file} creates a new
874 @code{GpgmeData} object and fills it with the content of the file
875 @var{filename}.
876
877 If @var{copy} is not zero, the whole file is read in at initialization
878 time and the file is not used anymore after that.  This is the only
879 mode supported currently.  Later, a value of zero for @var{copy} might
880 cause all reads to be delayed until the data is needed, but this is
881 not yet implemented.
882
883 The function returns @code{GPGME_No_Error} if the data object was
884 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
885 @var{filename} is not a valid pointer, @code{GPGME_File_Error} if an
886 I/O operation fails, @code{GPGME_Not_Implemented} if @var{code} is
887 zero, and @code{GPGME_Out_Of_Core} if not enough memory is available.
888 @end deftypefun
889
890 @deftypefun GpgmeError gpgme_data_new_from_filepart (@w{GpgmeData *@var{dh}}, @w{const char *@var{filename}}, @w{FILE *@var{fp}}, @w{off_t @var{offset}}, @w{size_t @var{length}})
891 The function @code{gpgme_data_new_from_filepart} creates a new
892 @code{GpgmeData} object and fills it with a part of the file specified
893 by @var{filename} or @var{fp}.
894
895 Exactly one of @var{filename} and @var{fp} must be non-zero, the other
896 must be zero.  The argument that is not zero specifies the file from
897 which @var{length} bytes are read into the data object, starting from
898 @var{offset}.
899
900 The function returns @code{GPGME_No_Error} if the data object was
901 successfully created, @code{GPGME_Invalid_Value} if @var{dh} and
902 exactly one of @var{filename} and @var{fp} is not a valid pointer,
903 @code{GPGME_File_Error} if an I/O operation fails, and
904 @code{GPGME_Out_Of_Core} if not enough memory is available.
905 @end deftypefun
906
907 @deftypefun GpgmeError gpgme_data_new_with_read_cb (@w{GpgmeData *@var{dh}}, @w{int (*@var{readfunc})} (@w{void *@var{hook}}, @w{char *@var{buffer}}, @w{size_t @var{count}}, @w{size_t *@var{nread}}), @w{void *@var{hook_value}})
908 The function @code{gpgme_data_new_with_read_cb} creates a new
909 @code{GpgmeData} object and uses the callback function @var{readfunc}
910 to retrieve the data on demand.  As the callback function can supply
911 the data in any way it wants, this is the most flexible data type
912 @acronym{GPGME} provides.  However, it can not be used to write data.
913
914 The callback function receives @var{hook_value} as its first argument
915 whenever it is invoked.  It should return up to @var{count} bytes in
916 @var{buffer}, and return the number of bytes actually read in
917 @var{nread}.  It may return @code{0} in @var{nread} if no data is
918 currently available.  To indicate @code{EOF} the function should
919 return with an error code of @code{-1} and set @var{nread} to
920 @code{0}.  The callback function may support to reset its internal
921 read pointer if it is invoked with @var{buffer} and @var{nread} being
922 @code{NULL} and @var{count} being @code{0}.
923
924 The function returns @code{GPGME_No_Error} if the data object was
925 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
926 @var{readfunc} is not a valid pointer, and @code{GPGME_Out_Of_Core} if
927 not enough memory is available.
928 @end deftypefun
929
930
931 @node Destroying Data Buffers
932 @section Destroying Data Buffers
933 @cindex data buffer, destruction
934
935 @deftypefun void gpgme_data_release (@w{GpgmeData @var{dh}})
936 The function @code{gpgme_data_release} destroys the data object with
937 the handle @var{dh}.  It releases all associated resources that were
938 not provided by the user in the first place.
939 @end deftypefun
940
941 @deftypefun {char *} gpgme_data_release_and_get_mem (@w{GpgmeData @var{dh}}, @w{size_t *@var{length}})
942 The function @code{gpgme_data_release_and_get_mem} is like
943 @code{gpgme_data_release}, except that it returns the data buffer and
944 its length that was provided by the object.
945
946 The user has to release the buffer with @code{free}.  In case the user
947 provided the data buffer in non-copy mode, a copy will be made for
948 this purpose.
949
950 In case an error returns, or there is no suitable data buffer that can
951 be returned to the user, the function will return @code{NULL}.
952 @end deftypefun
953
954
955 @node Manipulating Data Buffers
956 @section Manipulating Data Buffers
957 @cindex data buffere, manipulation
958
959 @deftypefun GpgmeError gpgme_data_read (@w{GpgmeData @var{dh}}, @w{void *@var{buffer}}, @w{size_t @var{length}}, @w{size_t *@var{nread}})
960 The function @code{gpgme_data_read} reads up to @var{length} bytes
961 from the data object with the handle @var{dh} into the space starting
962 at @var{buffer}.  The actual amount read is returned in @var{nread}.
963
964 If @var{buffer} is @code{NULL}, the function returns the amount of
965 bytes available in @var{nread} without changing the read pointer.
966 This is not supported by all types of data objects.  If this function
967 is not supported, @code{GPGME_Invalid_Type} is returned.
968
969 If the end of the data object is reached, the function returns
970 @code{GPGME_EOF} and sets @var{nread} to zero.
971
972 In all other cases, the function returns @code{GPGME_No_Error} if the
973 operation was successfully performed and @code{GPGME_Invalid_Value} if
974 @var{dh} is not a valid pointer.
975 @end deftypefun
976
977 @deftypefun GpgmeError gpgme_data_rewind (@w{GpgmeData @var{dh}})
978 The function @code{gpgme_data_rewind} resets the read pointer of the
979 data object with the handle @var{dh}, so that a subsequent
980 @code{gpgme_data_read} operation starts at the beginning of the data.
981
982 The function returns @code{GPGME_No_Error} if the operation was
983 successfully performed, @code{GPGME_Not_Implemented} if the operation
984 is not supported (for example, by a read callback function supplied by
985 the user) and @code{GPGME_Invalid_Value} if @var{dh} is not a valid
986 pointer.
987 @end deftypefun
988
989 @deftypefun GpgmeError gpgme_data_write (@w{GpgmeData @var{dh}}, @w{const void *@var{buffer}}, @w{size_t @var{length}})
990 The function @code{gpgme_data_write} writes @var{length} bytes
991 starting from @var{buffer} into the data object with the handle
992 @var{dh} at the current write position.
993
994 The function returns @code{GPGME_No_Error} if the operation was
995 successfully performed, @code{GPGME_Invalid_Value} if @var{dh} or
996 @var{buffer} is not a valid pointer, @code{GPGME_Invalid_Type} or
997 @code{GPGME_Invalid_Mode} if the data object type does not support
998 writing, and @code{GPGME_Out_Of_Core} if not enough memory is
999 available.
1000 @end deftypefun
1001
1002 @c
1003 @c  GpgmeDataType
1004 @c
1005 @deftp {Data type} {enum GpgmeDataType}
1006 @tindex GpgmeDataType
1007 The @code{GpgmeDataType} type specifies the type of a @code{GpgmeData} object.
1008 The following data types are available:
1009
1010 @table @code
1011 @item GPGME_DATA_TYPE_NONE
1012 This specifies that the type is not yet determined.
1013
1014 @item GPGME_DATA_TYPE_MEM
1015 This specifies that the data is stored in memory.
1016
1017 @item GPGME_DATA_TYPE_FD
1018 This type is not implemented.
1019
1020 @item GPGME_DATA_TYPE_FILE
1021 This type is not implemented.
1022
1023 @item GPGME_DATA_TYPE_CB
1024 This type specifies that the data is provided by a callback function
1025 implemented by the user.
1026 @end table
1027 @end deftp
1028
1029 @deftypefun GpgmeDataType gpgme_data_get_type (@w{GpgmeData @var{dh}})
1030 The function @code{gpgme_data_get_type} returns the type of the data
1031 object with the handle @var{dh}.  If @var{dh} is not a valid pointer,
1032 @code{GPGME_DATA_TYPE_NONE} is returned.
1033 @end deftypefun
1034
1035 @c
1036 @c  GpgmeDataEncoding
1037 @c
1038 @deftp {Data type} {enum GpgmeDataEncoding}
1039 @tindex GpgmeDataEncoding
1040 The @code{GpgmeDataEncoding} type specifies the encoding of a
1041 @code{GpgmeData} object.  This encoding is useful to give the backend
1042 a hint on the type of data.  The following data types are available:
1043
1044 @table @code
1045 @item GPGME_DATA_ENCODING_NONE
1046 This specifies that the encoding is not known.  This is the default
1047 for a new data object.
1048
1049 @item GPGME_DATA_ENCODING_BINARY
1050 This specifies that the data is encoding in binary form; i.e. there is
1051 no special encoding.
1052
1053 @item GPGME_DATA_ENCODING_BASE64
1054 This specifies that the data is encoded using the Base-64 encoding
1055 scheme as used by @acronym{MIME} and other protocols.
1056
1057 @item GPGME_DATA_ENCODING_ARMOR
1058 This specifies that the data is encoded in an armored form as used by
1059 OpenPGP and PEM.
1060 @end table
1061 @end deftp
1062
1063 @deftypefun GpgmeDataEncoding gpgme_data_get_encoding (@w{GpgmeData @var{dh}})
1064 The function @code{gpgme_data_get_encoding} returns the encoding of
1065 the data object with the handle @var{dh}.  If @var{dh} is not a valid
1066 pointer (e.g. @code{NULL}) @code{GPGME_DATA_ENCODING_NONE} is
1067 returned.
1068 @end deftypefun
1069
1070 @deftypefun GpgmeError gpgme_data_set_encoding (@w{GpgmeData @var{dh}, GpgmeDataEncoding @var{enc}})
1071 The function @code{gpgme_data_set_encoding} changes the encoding of
1072 the data object with the handle @var{dh} to @var{enc}.
1073 @end deftypefun
1074
1075
1076 @c
1077 @c    Chapter Contexts
1078 @c 
1079 @node Contexts
1080 @chapter Contexts
1081 @cindex context
1082
1083 All cryptographic operations in @acronym{GPGME} are performed within a
1084 context, which contains the internal state of the operation as well as
1085 configuration parameters.  By using several contexts you can run
1086 several cryptographic operations in parallel, with different
1087 configuration.
1088
1089 @deftp {Data type} {GpgmeCtx}
1090 The @code{GpgmeCtx} type is a handle for a @acronym{GPGME} context,
1091 which is used to hold the configuration, status and result of
1092 cryptographic operations.
1093 @end deftp
1094
1095 @menu
1096 * Creating Contexts::             Creating new @acronym{GPGME} contexts.
1097 * Destroying Contexts::           Releasing @acronym{GPGME} contexts.
1098 * Context Attributes::            Setting properties of a context.
1099 * Key Management::                Managing keys with @acronym{GPGME}.
1100 * Trust Item Management::         Managing trust items with @acronym{GPGME}.
1101 * Crypto Operations::             Using a context for cryptography.
1102 * Run Control::                   Controlling how operations are run.
1103 @end menu
1104
1105
1106 @node Creating Contexts
1107 @section Creating Contexts
1108 @cindex context, creation
1109
1110 @deftypefun GpgmeError gpgme_new (@w{GpgmeCtx *@var{ctx}})
1111 The function @code{gpgme_data_new} creates a new @code{GpgmeCtx}
1112 object and returns a handle for it in @var{ctx}.
1113
1114 The function returns @code{GPGME_No_Error} if the context was
1115 successfully created, @code{GPGME_Invalid_Value} if @var{ctx} is not a
1116 valid pointer, and @code{GPGME_Out_Of_Core} if not enough memory is
1117 available.
1118 @end deftypefun
1119
1120
1121 @node Destroying Contexts
1122 @section Destroying Contexts
1123 @cindex context, destruction
1124
1125 @deftypefun void gpgme_release (@w{GpgmeCtx @var{ctx}})
1126 The function @code{gpgme_release} destroys the context with the handle
1127 @var{ctx} and releases all associated resources.
1128 @end deftypefun
1129
1130
1131 @node Context Attributes
1132 @section Context Attributes
1133 @cindex context, attributes
1134
1135 @menu
1136 * Protocol Selection::            Selecting the protocol used by a context.
1137 * @acronym{ASCII} Armor::                   Requesting @acronym{ASCII} armored output.
1138 * Text Mode::                     Choosing canonical text mode.
1139 * Included Certificates::       Including a number of certificates.
1140 * Key Listing Mode::              Selecting key listing mode.
1141 * Passphrase Callback::           Getting the passphrase from the user.
1142 * Progress Meter Callback::       Being informed about the progress.
1143 @end menu
1144
1145
1146 @node Protocol Selection
1147 @subsection Protocol Selection
1148 @cindex context, selecting protocol
1149 @cindex protocol, selecting
1150
1151 @deftypefun GpgmeError gpgme_set_protocol (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProtocol @var{proto}})
1152 The function @code{gpgme_set_protocol} sets the protocol used within
1153 the context @var{ctx} to @var{proto}.  All crypto operations will be
1154 performed by the crypto engine configured for that protocol.
1155 @xref{Protocols and Engines}.
1156
1157 Setting the protocol with @code{gpgme_set_protocol} does not check if
1158 the crypto engine for that protocol is available and installed
1159 correctly.  @xref{Engine Version Check}.
1160
1161 The function returns @code{GPGME_No_Error} if the protocol could be
1162 set successfully, and @code{GPGME_Invalid_Value} if @var{protocol} is
1163 not a valid protocol.
1164 @end deftypefun
1165
1166 @deftypefun GpgmeProtocol gpgme_get_protocol (@w{GpgmeCtx @var{ctx}})
1167 The function @code{gpgme_get_protocol} retrieves the protocol currently
1168 use with the context @var{ctx}.
1169 @end deftypefun
1170
1171 @node @acronym{ASCII} Armor
1172 @subsection @acronym{ASCII} Armor
1173 @cindex context, armor mode
1174 @cindex @acronym{ASCII} armor
1175 @cindex armor mode
1176
1177 @deftypefun void gpgme_set_armor (@w{GpgmeCtx @var{ctx}}, @w{int @var{yes}})
1178 The function @code{gpgme_set_armor} specifies if the output should be
1179 @acronym{ASCII} armored.  By default, output is not @acronym{ASCII}
1180 armored.
1181
1182 @acronym{ASCII} armored output is disabled if @var{yes} is zero, and
1183 enabled otherwise.
1184 @end deftypefun
1185
1186 @deftypefun int gpgme_get_armor (@w{GpgmeCtx @var{ctx}})
1187 The function @code{gpgme_get_armor} returns 1 if the output is
1188 @acronym{ASCII} armored, and @code{0} if it is not, or if @var{ctx} is
1189 not a valid pointer.
1190 @end deftypefun
1191
1192
1193 @node Text Mode
1194 @subsection Text Mode
1195 @cindex context, text mode
1196 @cindex text mode
1197 @cindex canonical text mode
1198
1199 @deftypefun void gpgme_set_textmode (@w{GpgmeCtx @var{ctx}}, @w{int @var{yes}})
1200 The function @code{gpgme_set_textmode} specifies if canonical text mode
1201 should be used.  By default, text mode is not used.
1202
1203 Text mode is for example used for the RFC2015 signatures; note that
1204 the updated RFC 3156 mandates that the mail user agent does some
1205 preparations so that text mode is not needed anymore.
1206
1207 This option is only relevant to the OpenPGP crypto engine, and ignored
1208 by all other engines.
1209
1210 Canonical text mode is disabled if @var{yes} is zero, and enabled
1211 otherwise.
1212 @end deftypefun
1213
1214 @deftypefun int gpgme_get_textmode (@w{GpgmeCtx @var{ctx}})
1215 The function @code{gpgme_get_textmode} returns 1 if canonical text
1216 mode is enabled, and @code{0} if it is not, or if @var{ctx} is not a
1217 valid pointer.
1218 @end deftypefun
1219
1220
1221 @node Included Certificates
1222 @subsection Included Certificates
1223 @cindex certificates, included
1224
1225 @deftypefun void gpgme_set_include_certs (@w{GpgmeCtx @var{ctx}}, @w{int @var{nr_of_certs}})
1226 The function @code{gpgme_set_include_certs} specifies how many
1227 certificates should be included in an S/MIME signed message.  By
1228 default, only the sender's certificate is included.  The possible
1229 values of @var{nr_of_certs} are:
1230
1231 @table @code
1232 @item -2
1233 Include all certificates except the root certificate.
1234 @item -1
1235 Include all certificates.
1236 @item 0
1237 Include no certificates.
1238 @item 1
1239 Include the sender's certificate only.
1240 @item n
1241 Include the first n certificates of the certificates path, starting
1242 from the sender's certificate.  The number @code{n} must be positive.
1243 @end table
1244
1245 Values of @var{nr_of_certs} smaller than -2 are undefined.
1246
1247 This option is only relevant to the CMS crypto engine, and ignored
1248 by all other engines.
1249 @end deftypefun
1250
1251 @deftypefun int gpgme_get_include_certs (@w{GpgmeCtx @var{ctx}})
1252 The function @code{gpgme_get_include_certs} returns the number of
1253 certificates to include into an S/MIME signed message.
1254 @end deftypefun
1255
1256
1257 @node Key Listing Mode
1258 @subsection Key Listing Mode
1259 @cindex key listing mode
1260 @cindex key listing, mode of
1261
1262 @deftypefun void gpgme_set_keylist_mode (@w{GpgmeCtx @var{ctx}}, @w{int @var{mode}})
1263 The function @code{gpgme_set_keylist_mode} changes the default
1264 behaviour of the key listing functions.  The value in @var{mode} is a
1265 bitwise-or combination of one or multiple of the following bit values:
1266
1267 @table @code
1268 @item GPGME_KEYLIST_MODE_LOCAL
1269 The @code{GPGME_KEYLIST_MODE_LOCAL} symbol specifies that the local
1270 keyring should be searched for keys in the keylisting operation.  This
1271 is the default.
1272
1273 @item GPGME_KEYLIST_MODE_EXTERN
1274 The @code{GPGME_KEYLIST_MODE_EXTERN} symbol specifies that an external
1275 source should be should be searched for keys in the keylisting
1276 operation.  The type of external source is dependant on the crypto
1277 engine used.  For example, it can be a remote keyserver or LDAP
1278 certificate server.
1279 @end table
1280
1281 At least one of @code{GPGME_KEYLIST_MODE_LOCAL} and
1282 @code{GPGME_KEYLIST_MODE_EXTERN} must be specified.  For future binary
1283 compatibility, you should get the current mode with
1284 @code{gpgme_get_keylist_mode} and modify it by setting or clearing the
1285 appropriate bits, and then using that calulcated value in the
1286 @code{gpgme_set_keylisting_mode} operation.  This will leave all other
1287 bits in the mode value intact (in particular those that are not used
1288 in the current version of the library).
1289
1290 The function returns @code{GPGME_No_Error} if the mode could be set
1291 correctly, and @code{GPGME_Invalid_Value} if @var{ctx} is not a valid
1292 pointer or @var{mode} is not a valid mode.
1293 @end deftypefun
1294
1295
1296 @deftypefun int gpgme_get_keylist_mode (@w{GpgmeCtx @var{ctx}})
1297 The function @code{gpgme_get_keylist_mode} returns the current key
1298 listing mode of the context @var{ctx}.  This value can then be
1299 modified and used in a subsequent @code{gpgme_set_keylist_mode}
1300 operation to only affect the desired bits (and leave all others
1301 intact).
1302
1303 The function returns 0 if @var{ctx} is not a valid pointer, and the
1304 current mode otherwise.  Note that 0 is not a valid mode value.
1305 @end deftypefun
1306
1307
1308 @node Passphrase Callback
1309 @subsection Passphrase Callback
1310 @cindex callback, passphrase
1311 @cindex passphrase callback
1312
1313 @deftp {Data type} {const char *(*GpgmePassphraseCb)(void *@var{hook}, const char *@var{desc}, void **@var{r_hd})}
1314 @tindex GpgmePassphraseCb
1315 The @code{GpgmePassphraseCb} type is the type of functions usable as
1316 passphrase callback function.
1317
1318 The string @var{desc} contains a text usable to be displayed to the
1319 user of the application.  The function should return a passphrase for
1320 the context when invoked with @var{desc} not being @code{NULL}.
1321
1322 The user may store information about the resources associated with the
1323 returned passphrase in @var{*r_hd}.  When the passphrase is no longer
1324 needed by @acronym{GPGME}, the passphrase callback function will be
1325 called with @var{desc} being @var{NULL}, and @var{r_hd} being the same
1326 as at the first invocation.
1327 @end deftp
1328
1329 @deftypefun void gpgme_set_passphrase_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmePassphraseCb @var{passfunc}}, @w{void *@var{hook_value}})
1330 The function @code{gpgme_set_passphrase_cb} sets the function that is
1331 used when a passphrase needs to be provided by the user to
1332 @var{passfunc}.  The function @var{passfunc} needs to implemented by
1333 the user, and whenever it is called, it is called with its first
1334 argument being @var{hook_value}.  By default, no passphrase callback
1335 function is set.
1336
1337 Not all crypto engines require this callback to retrieve the
1338 passphrase.  It is better if the engine retrieves the passphrase from
1339 a trusted agent (a daemon process), rather than having each user to
1340 implement their own passphrase query.
1341
1342 The user can disable the use of a passphrase callback function by
1343 calling @code{gpgme_set_passphrase_cb} with @var{passfunc} being
1344 @code{NULL}.
1345 @end deftypefun
1346
1347 @deftypefun void gpgme_get_passphrase_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmePassphraseCb *@var{passfunc}}, @w{void **@var{hook_value}})
1348 The function @code{gpgme_get_passphrase_cb} returns the function that
1349 is used when a passphrase needs to be provided by the user in
1350 @var{*passfunc}, and the first argument for this function in
1351 @var{*hook_value}.  If no passphrase callback is set, or @var{ctx} is
1352 not a valid pointer, @code{NULL} is returned in both variables.
1353
1354 @var{passfunc} or @var{hook_value} can be @code{NULL}.  In this case,
1355 the corresponding value will not be returned.
1356 @end deftypefun
1357
1358
1359 @node Progress Meter Callback
1360 @subsection Progress Meter Callback
1361 @cindex callback, progress meter
1362 @cindex progress meter callback
1363
1364 @deftp {Data type} {const char *(*GpgmeProgressCb)(void *@var{hook}, const char *@var{what}, int @var{type}, int @var{current}, int @var{total})}
1365 @tindex GpgmeProgressCb
1366 The @code{GpgmeProgressCb} type is the type of functions usable as
1367 progress callback function.
1368
1369 The arguments are specific to the crypto engine.  More information
1370 about the progress information returned from the GnuPG engine can be
1371 found in the GnuPG source code in the file @file{doc/DETAILS} in the
1372 section PROGRESS.
1373 @end deftp
1374
1375 @deftypefun void gpgme_set_progress_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProgressCb @var{progfunc}}, @w{void *@var{hook_value}})
1376 The function @code{gpgme_set_progress_cb} sets the function that is
1377 used when progress information about a cryptographic operation is
1378 available.  The function @var{progfunc} needs to implemented by the
1379 user, and whenever it is called, it is called with its first argument
1380 being @var{hook_value}.  By default, no progress callback function
1381 is set.
1382
1383 Setting a callback function allows an interactive program to display
1384 progress information about a long operation to the user.
1385
1386 The user can disable the use of a progress callback function by
1387 calling @code{gpgme_set_progress_cb} with @var{progfunc} being
1388 @code{NULL}.
1389 @end deftypefun
1390
1391 @deftypefun void gpgme_get_progress_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProgressCb *@var{progfunc}}, @w{void **@var{hook_value}})
1392 The function @code{gpgme_get_progress_cb} returns the function that is
1393 used to inform the user about the progress made in @var{*progfunc},
1394 and the first argument for this function in @var{*hook_value}.  If no
1395 progress callback is set, or @var{ctx} is not a valid pointer,
1396 @code{NULL} is returned in both variables.
1397
1398 @var{progfunc} or @var{hook_value} can be @code{NULL}.  In this case,
1399 the corresponding value will not be returned.
1400 @end deftypefun
1401
1402
1403 @node Key Management
1404 @section Key Management
1405 @cindex key management
1406
1407 Some of the cryptographic operations require that recipients or
1408 signers are specified.  This is always done by specifying the
1409 respective keys that should be used for the operation.  The following
1410 section describes how such keys can be selected and manipulated.
1411
1412 @deftp {Data type} GpgmeKey
1413 The @code{GpgmeKey} type is a handle for a public or secret key, and
1414 is used to select the key for operations involving it.
1415
1416 A key can contain several user IDs and sub keys.
1417 @end deftp
1418
1419 @menu
1420 * Listing Keys::                  Browsing the list of available keys.
1421 * Information About Keys::        Requesting detailed information about keys.
1422 * Manipulating Keys::             Operations on keys.
1423 * Generating Keys::               Creating new key pairs.
1424 * Exporting Keys::                Retrieving key data from the key ring.
1425 * Importing Keys::                Adding keys to the key ring.
1426 * Deleting Keys::                 Removing keys from the key ring.
1427 @end menu
1428
1429
1430 @node Listing Keys
1431 @subsection Listing Keys
1432 @cindex listing keys
1433 @cindex key listing
1434 @cindex key listing, start
1435 @cindex key ring, list
1436 @cindex key ring, search
1437
1438 @deftypefun GpgmeError gpgme_op_keylist_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}}, @w{int @var{secret_only}})
1439 The function @code{gpgme_op_keylist_start} initiates a key listing
1440 operation inside the context @var{ctx}.  It sets everything up so that
1441 subsequent invocations of @code{gpgme_op_keylist_next} return the keys
1442 in the list.
1443
1444 If @var{pattern} is @code{NULL}, all available keys are returned.
1445 Otherwise, @var{pattern} contains an engine specific expression that
1446 is used to limit the list to all keys matching the pattern.
1447
1448 If @var{secret_only} is not @code{0}, the list is restricted to secret
1449 keys only.
1450
1451 The context will be busy until either all keys are received (and
1452 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}), or
1453 @code{gpgme_op_keylist_end} is called to finish the operation.
1454
1455 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1456 valid pointer, and passes through any errors that are reported by the
1457 crypto engine support routines.
1458 @end deftypefun
1459
1460 @deftypefun GpgmeError gpgme_op_keylist_ext_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}[]}, @w{int @var{secret_only}}, @w{int @var{reserved}})
1461 The function @code{gpgme_op_keylist_ext_start} initiates an extended
1462 key listing operation inside the context @var{ctx}.  It sets
1463 everything up so that subsequent invocations of
1464 @code{gpgme_op_keylist_next} return the keys in the list.
1465
1466 If @var{pattern} or @var{*pattern} is @code{NULL}, all available keys
1467 are returned.  Otherwise, @var{pattern} is a @code{NULL} terminated
1468 array of strings that are used to limit the list to all keys matching
1469 at least one of the patterns verbatim.
1470
1471 If @var{secret_only} is not @code{0}, the list is restricted to secret
1472 keys only.
1473
1474 The value of @var{reserved} must be @code{0}.
1475
1476 The context will be busy until either all keys are received (and
1477 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}), or
1478 @code{gpgme_op_keylist_end} is called to finish the operation.
1479
1480 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1481 valid pointer, and passes through any errors that are reported by the
1482 crypto engine support routines.
1483 @end deftypefun
1484
1485 @deftypefun GpgmeError gpgme_op_keylist_next (@w{GpgmeCtx @var{ctx}}, @w{GpgmeKey *@var{r_key}})
1486 The function @code{gpgme_op_keylist_next} returns the next key in the
1487 list created by a previous @code{gpgme_op_keylist_start} operation in
1488 the context @var{ctx}.  The key will have one reference for the user.
1489 @xref{Manipulating Keys}.
1490
1491 This is the only way to get at @code{GpgmeKey} objects in
1492 @acronym{GPGME}.
1493
1494 If the last key in the list has already been returned,
1495 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}.
1496
1497 The function returns @code{GPGME_Invalid_Value} if @var{ctx} or
1498 @var{r_key} is not a valid pointer, @code{GPGME_No_Request} if there
1499 is no pending operation, @code{GPGME_Out_Of_Core} if there is not
1500 enough memory for the operation.
1501 @end deftypefun
1502
1503 @deftypefun GpgmeError gpgme_op_keylist_end (@w{GpgmeCtx @var{ctx}})
1504 The function @code{gpgme_op_keylist_next} ends a pending key list
1505 operation in the context @var{ctx}.
1506
1507 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1508 valid pointer, @code{GPGME_No_Request} if there is no pending
1509 operation, @code{GPGME_Out_Of_Core} if at some time during the
1510 operation there was not enough memory available.
1511 @end deftypefun
1512
1513 The following example illustrates how all keys containing a certain
1514 string (@code{g10code}) can be listed with their key ID and the name
1515 and e-mail address of the main user ID:
1516
1517 @example
1518 GpgmeCtx ctx;
1519 GpgmeError err = gpgme_new (&ctx);
1520
1521 if (!err)
1522   @{
1523     err = gpgme_op_keylist_start (ctx, "g10code", 0);
1524     while (!err && (err = gpgme_op_keylist_next (ctx, &key)) != GPGME_EOF)
1525       @{
1526         printf ("%s: %s <%s>\n",
1527                 gpgme_key_get_string_attr (key, GPGME_ATTR_KEYID, 0, 0),
1528                 gpgme_key_get_string_attr (key, GPGME_ATTR_NAME, 0, 0),
1529                 gpgme_key_get_string_attr (key, GPGME_ATTR_EMAIL, 0, 0));
1530         gpgme_key_release (key);
1531       @}
1532     gpgme_release (ctx);
1533   @}
1534 if (err)
1535   @{
1536     fprintf (stderr, "%s: can not list keys: %s\n",
1537              argv[0], gpgme_strerror (err));
1538     exit (1);
1539   @}
1540 @end example
1541
1542
1543 @node Information About Keys
1544 @subsection Information About Keys
1545 @cindex key, information about
1546 @cindex key, attributes
1547 @cindex attributes, of a key
1548
1549 @deftypefun {char *} gpgme_key_get_as_xml (@w{GpgmeKey @var{key}})
1550 The function @code{gpgme_key_get_as_xml} returns a string in
1551 @acronym{XML} format describing the key @var{key}.  The user has to
1552 release the string with @code{free}.
1553
1554 The function returns @code{NULL} if @var{key} is not a valid pointer,
1555 or there is not enough memory available.
1556 @end deftypefun
1557
1558 @deftp {Data type} GpgmeAttr
1559 The @code{GpgmeAttr} type is used to specify a key or trust item
1560 attribute.  The following attributes are defined:
1561
1562 @table @code
1563 @item GPGME_ATTR_KEYID
1564 This is the key ID of a sub key.  It is representable as a string.
1565
1566 For trust items, the trust item refers to the key with this ID.
1567
1568 @item GPGME_ATTR_FPR
1569 This is the fingerprint of a sub key.  It is representable as a
1570 string.
1571
1572 @item GPGME_ATTR_ALGO
1573 This is the crypto algorithm for which the sub key can be used.  It
1574 is representable as a string and as a number.  The numbers correspond
1575 to the @code{enum gcry_pk_algos} values in the gcrypt library.
1576
1577 @item GPGME_ATTR_LEN
1578 This is the key length of a sub key.  It is representable as a
1579 number.
1580
1581 @item GPGME_ATTR_CREATED
1582 This is the timestamp at creation time of a sub key.  It is
1583 representable as a number.
1584
1585 @item GPGME_ATTR_EXPIRE
1586 This is the expiration time of a sub key.  It is representable as a
1587 number.
1588
1589 @item GPGME_ATTR_OTRUST
1590 XXX FIXME  (also for trust items)
1591
1592 @item GPGME_ATTR_USERID
1593 This is a user ID.  There can be more than one user IDs in a
1594 @var{GpgmeKey} object.  The first one (with index 0) is the primary
1595 user ID.  The user ID is representable as a number.
1596
1597 For trust items, this is the user ID associated with this trust item.
1598
1599 @item GPGME_ATTR_NAME
1600 This is the name belonging to a user ID.  It is representable as a string.
1601
1602 @item GPGME_ATTR_EMAIL
1603 This is the email address belonging to a user ID.  It is representable
1604 as a string.
1605
1606 @item GPGME_ATTR_COMMENT
1607 This is the comment belonging to a user ID.  It is representable as a
1608 string.
1609
1610 @item GPGME_ATTR_VALIDITY
1611 This is the validity belonging to a user ID.  It is representable as a
1612 string and as a number.  See below for a list of available validities.
1613
1614 For trust items, this is the validity that is associated with this
1615 trust item.
1616
1617 @item GPGME_ATTR_UID_REVOKED
1618 This specifies if a user ID is revoked.  It is representable as a
1619 number, and is @code{1} if the user ID is revoked, and @code{0}
1620 otherwise.
1621
1622 @item GPGME_ATTR_UID_INVALID
1623 This specifies if a user ID is invalid.  It is representable as a
1624 number, and is @code{1} if the user ID is invalid, and @code{0}
1625 otherwise.
1626
1627 @item GPGME_ATTR_LEVEL
1628 This is the trust level of a trust item.
1629
1630 @item GPGME_ATTR_TYPE
1631 This is the type of a trust item.
1632
1633 @item GPGME_ATTR_IS_SECRET
1634 This specifies if the key is a secret key.  It is representable as a
1635 string or a number.  If the key is a secret key, the representation is
1636 ``1'' or @code{1}, otherwise it is @code{NULL} or @code{0}.
1637
1638 @item GPGME_ATTR_KEY_REVOKED
1639 This specifies if a sub key is revoked.  It is representable as a
1640 number, and is @code{1} if the key is revoked, and @code{0} otherwise.
1641
1642 @item GPGME_ATTR_KEY_INVALID
1643 This specifies if a sub key is invalid.  It is representable as a
1644 number, and is @code{1} if the key is invalid, and @code{0} otherwise.
1645
1646 @item GPGME_ATTR_KEY_EXPIRED
1647 This specifies if a sub key is expired.  It is representable as a
1648 number, and is @code{1} if the key is expired, and @code{0} otherwise.
1649
1650 @item GPGME_ATTR_KEY_DISABLED
1651 This specifies if a sub key is disabled.  It is representable as a
1652 number, and is @code{1} if the key is disabled, and @code{0} otherwise.
1653
1654 @item GPGME_ATTR_KEY_CAPS
1655 This is a description of the capabilities of a sub key.  It is
1656 representable as a string.  The string contains the letter ``e'' if
1657 the key can be used for encryption, ``s'' if the key can be used for
1658 signatures, and ``c'' if the key can be used for certifications.
1659
1660 @item GPGME_ATTR_CAN_ENCRYPT
1661 This specifies if a sub key can be used for encryption.  It is
1662 representable as a number, and is @code{1} if the sub key can be used
1663 for encryption, and @code{0} otherwise.
1664
1665 @item GPGME_ATTR_CAN_SIGN
1666 This specifies if a sub key can be used for signatures.  It is
1667 representable as a number, and is @code{1} if the sub key can be used
1668 for signatures, and @code{0} otherwise.
1669
1670 @item GPGME_ATTR_CAN_CERTIFY
1671 This specifies if a sub key can be used for certifications.  It is
1672 representable as a number, and is @code{1} if the sub key can be used
1673 for certifications, and @code{0} otherwise.
1674 @end table
1675 @end deftp
1676
1677 @deftp {Data type} GpgmeValidity
1678 The @code{GpgmeValidity} type is used to specify the validity of a user ID
1679 in a key.  The following validities are defined:
1680
1681 @table @code
1682 @item GPGME_VALIDITY_UNKNOWN
1683 The user ID is of unknown validity.  The string representation of this
1684 validity is ``?''.
1685
1686 @item GPGME_VALIDITY_UNDEFINED
1687 The validity of the user ID is undefined.  The string representation of this
1688 validity is ``q''.
1689
1690 @item GPGME_VALIDITY_NEVER
1691 The user ID is never valid.  The string representation of this
1692 validity is ``n''.
1693
1694 @item GPGME_VALIDITY_MARGINAL
1695 The user ID is marginally valid.  The string representation of this
1696 validity is ``m''.
1697
1698 @item GPGME_VALIDITY_FULL
1699 The user ID is fully valid.  The string representation of this
1700 validity is ``f''.
1701
1702 @item GPGME_VALIDITY_ULTIMATE
1703 The user ID is ultimately valid.  The string representation of this
1704 validity is ``u''.
1705 @end table
1706 @end deftp
1707
1708 @deftypefun {const char *} gpgme_key_get_string_attr (@w{GpgmeKey @var{key}}, @w{GpgmeAttr @var{what}}, @w{const void *@var{reserved}}, @w{int @var{idx}})
1709 The function @code{gpgme_key_get_string_attr} returns the value of the
1710 string-representable attribute @var{what} of key @var{key}.  If the
1711 attribute occurs more than once in the key, the index is specified by
1712 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1713 argument @var{reserved} is reserved for later use and should be
1714 @code{NULL}.
1715
1716 The string returned is only valid as long as the key is valid.
1717
1718 The function returns @code{0} if an attribute can't be returned as a
1719 string, @var{key} is not a valid pointer, @var{idx} out of range,
1720 or @var{reserved} not @code{NULL}.
1721 @end deftypefun
1722
1723 @deftypefun {unsigned long} gpgme_key_get_ulong_attr (@w{GpgmeKey @var{key}}, @w{GpgmeAttr @var{what}}, @w{const void *@var{reserved}}, @w{int @var{idx}})
1724 The function @code{gpgme_key_get_ulong_attr} returns the value of the
1725 number-representable attribute @var{what} of key @var{key}.  If the
1726 attribute occurs more than once in the key, the index is specified by
1727 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1728 argument @var{reserved} is reserved for later use and should be
1729 @code{NULL}.
1730
1731 The function returns @code{0} if the attribute can't be returned as a
1732 number, @var{key} is not a valid pointer, @var{idx} out of range,
1733 or @var{reserved} not @code{NULL}.
1734 @end deftypefun
1735
1736
1737 @node Manipulating Keys
1738 @subsection Manipulating Keys
1739 @cindex key, manipulation
1740
1741 @deftypefun void gpgme_key_ref (@w{GpgmeKey @var{key}})
1742 The function @code{gpgme_key_ref} acquires an additional reference for
1743 the key @var{key}.
1744 @end deftypefun
1745
1746 @deftypefun void gpgme_key_unref (@w{GpgmeKey @var{key}})
1747 @deftypefunx void gpgme_key_release (@w{GpgmeKey @var{key}})
1748 The function @code{gpgme_key_ref} releases a reference for the key
1749 @var{key}.  If this was the last reference, the key will be destroyed
1750 and all resources associated to it will be released.
1751
1752 The function @code{gpgme_key_release} is an alias for
1753 @code{gpgme_key_unref}.
1754 @end deftypefun
1755
1756
1757 @node Generating Keys
1758 @subsection Generating Keys
1759 @cindex key, creation
1760 @cindex key ring, add
1761
1762 @deftypefun GpgmeError gpgme_op_genkey (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1763 The function @code{gpgme_op_genkey} generates a new key pair in the
1764 context @var{ctx} and puts it into the standard key ring if both
1765 @var{pubkey} and @var{seckey} are @code{NULL}.  In this case the
1766 function returns immediately after starting the operation, and does
1767 not wait for it to complete.  If @var{pubkey} is not @code{NULL} it
1768 should be the handle for an empty (newly created) data object, and
1769 upon successful completion the data object will contain the public
1770 key.  If @var{seckey} is not @code{NULL} it should be the handle for
1771 an empty (newly created) data object, and upon successful completion
1772 the data object will contain the secret key.
1773
1774 Note that not all crypto engines support this interface equally.
1775 GnuPG does not support @var{pubkey} and @var{subkey}, they should be
1776 both @code{NULL}, and the key pair will be added to the standard key
1777 ring.  GpgSM does only support @var{pubkey}, the secret key will be
1778 stored by @command{gpg-agent}.  GpgSM expects @var{pubkey} being not
1779 @code{NULL}.
1780
1781 The argument @var{parms} specifies parameters for the key in an XML
1782 string.  The details about the format of @var{parms} are specific to
1783 the crypto engine used by @var{ctx}.  Here is an example for GnuPG as
1784 the crypto engine:
1785
1786 @example
1787 <GnupgKeyParms format="internal">
1788 Key-Type: DSA
1789 Key-Length: 1024
1790 Subkey-Type: ELG-E
1791 Subkey-Length: 1024
1792 Name-Real: Joe Tester
1793 Name-Comment: with stupid passphrase
1794 Name-Email: joe@@foo.bar
1795 Expire-Date: 0
1796 Passphrase: abc
1797 </GnupgKeyParms>
1798 @end example
1799
1800 Here is an example for GpgSM as the crypto engine:
1801 @example
1802 <GnupgKeyParms format="internal">
1803 Key-Type: RSA
1804 Key-Length: 1024
1805 Name-DN: C=de,O=g10 code,OU=Testlab,CN=Joe 2 Tester
1806 Name-Email: joe@@foo.bar
1807 </GnupgKeyParms>
1808 @end example
1809
1810 Strings should be given in UTF-8 encoding.  The only format supported
1811 for now is ``internal''.  The content of the @code{GnupgKeyParms}
1812 container is passed verbatim to GnuPG.  Control statements are not
1813 allowed.
1814
1815 The function returns @code{GPGME_No_Error} if the operation could be
1816 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1817 a valid XML string, @code{GPGME_Not_Supported} if @var{pubkey} or
1818 @var{seckey} is not valid, and @code{GPGME_General_Error} if no key
1819 was created by the backend.
1820 @end deftypefun
1821
1822 @deftypefun GpgmeError gpgme_op_genkey_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1823 The function @code{gpgme_op_genkey_start} initiates a
1824 @code{gpgme_op_genkey} operation.  It can be completed by calling
1825 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1826
1827 The function returns @code{GPGME_No_Error} if the operation could be
1828 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1829 a valid XML string, and @code{GPGME_Not_Supported} if @var{pubkey} or
1830 @var{seckey} is not @code{NULL}.
1831 @end deftypefun
1832
1833
1834 @node Exporting Keys
1835 @subsection Exporting Keys
1836 @cindex key, export
1837 @cindex key ring, export from
1838
1839 @deftypefun GpgmeError gpgme_op_export (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1840 The function @code{gpgme_op_export} extracts the public keys of the
1841 user IDs in @var{recipients} and returns them in the data buffer
1842 @var{keydata}.  The type of the public keys returned is determined by
1843 the @acronym{ASCII} armor attribute set for the context @var{ctx}.
1844
1845 The function returns @code{GPGME_No_Error} if the operation completed
1846 successfully, @code{GPGME_Invalid_Value} if @var{recipients} is
1847 @code{NULL} or @var{keydata} is not a valid empty data buffer, and
1848 passes through any errors that are reported by the crypto engine
1849 support routines.
1850 @end deftypefun
1851
1852 @deftypefun GpgmeError gpgme_op_export_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1853 The function @code{gpgme_op_export_start} initiates a
1854 @code{gpgme_op_export} operation.  It can be completed by calling
1855 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1856
1857 The function returns @code{GPGME_No_Error} if the operation could be
1858 started successfully, and @code{GPGME_Invalid_Value} if
1859 @var{recipients} is @code{NULL} or @var{keydata} is not a valid empty
1860 data buffer.
1861 @end deftypefun
1862
1863
1864 @node Importing Keys
1865 @subsection Importing Keys
1866 @cindex key, import
1867 @cindex key ring, import to
1868
1869 @deftypefun GpgmeError gpgme_op_import (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1870 The function @code{gpgme_op_import} adds the keys in the data buffer
1871 @var{keydata} to the key ring of the crypto engine used by @var{ctx}.
1872 The format of @var{keydata} can be @var{ASCII} armored, for example,
1873 but the details are specific to the crypto engine.
1874
1875 More information about the import is available with
1876 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
1877
1878 The function returns @code{GPGME_No_Error} if the import was completed
1879 successfully, @code{GPGME_Invalid_Value} if @var{keydata} if @var{ctx}
1880 or @var{keydata} is not a valid pointer, and @code{GPGME_No_Data} if
1881 @var{keydata} is an empty data buffer.
1882 @end deftypefun
1883
1884 @deftypefun GpgmeError gpgme_op_import_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1885 The function @code{gpgme_op_import_start} initiates a
1886 @code{gpgme_op_import} operation.  It can be completed by calling
1887 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1888
1889 The function returns @code{GPGME_No_Error} if the import could be
1890 started successfully, @code{GPGME_Invalid_Value} if @var{keydata} if
1891 @var{ctx} or @var{keydata} is not a valid pointer, and
1892 @code{GPGME_No_Data} if @var{keydata} is an empty data buffer.
1893 @end deftypefun
1894
1895
1896 @node Deleting Keys
1897 @subsection Deleting Keys
1898 @cindex key, delete
1899 @cindex key ring, delete from
1900
1901 @deftypefun GpgmeError gpgme_op_delete (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1902 The function @code{gpgme_op_delete} deletes the key @var{key} from the
1903 key ring of the crypto engine used by @var{ctx}.  If
1904 @var{allow_secret} is @code{0}, only public keys are deleted,
1905 otherwise secret keys are deleted as well.
1906
1907 The function returns @code{GPGME_No_Error} if the key was deleted
1908 successfully, @code{GPGME_Invalid_Value} if @var{ctx} or @var{key} is
1909 not a valid pointer, @code{GPGME_Invalid_Key} if @var{key} could not
1910 be found in the keyring, and @code{GPGME_Conflict} if the secret key
1911 for @var{key} is available, but @var{allow_secret} is zero.
1912 @end deftypefun
1913
1914 @deftypefun GpgmeError gpgme_op_delete_start (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1915 The function @code{gpgme_op_delete_start} initiates a
1916 @code{gpgme_op_delete} operation.  It can be completed by calling
1917 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1918
1919 The function returns @code{GPGME_No_Error} if the operation was
1920 started successfully, and @code{GPGME_Invalid_Value} if @var{ctx} or
1921 @var{key} is not a valid pointer.
1922 @end deftypefun
1923
1924
1925 @node Trust Item Management
1926 @section Trust Item Management
1927 @cindex trust item
1928
1929 @strong{Caution:} The trust items interface is experimental.
1930
1931 @deftp {Data type} GpgmeTrustItem
1932 The @code{GpgmeTrustItem} type is a handle for a trust item.
1933 @end deftp
1934
1935 @menu
1936 * Listing Trust Items::           Browsing the list of available trust items.
1937 * Information About Trust Items:: Requesting detailed information about trust items.
1938 * Manipulating Trust Items::      Operations on trust items.
1939 @end menu
1940
1941
1942 @node Listing Trust Items
1943 @subsection Listing Trust Items
1944 @cindex trust item list
1945
1946 @deftypefun GpgmeError gpgme_op_trustlist_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}}, @w{int @var{max_level}})
1947 The function @code{gpgme_op_trustlist_start} initiates a trust item
1948 listing operation inside the context @var{ctx}.  It sets everything up
1949 so that subsequent invocations of @code{gpgme_op_trustlist_next} return
1950 the trust items in the list.
1951
1952 The string @var{pattern} contains an engine specific expression that
1953 is used to limit the list to all trust items matching the pattern.  It
1954 can not be the empty string.
1955
1956 The argument @var{max_level} is currently ignored.
1957
1958 The context will be busy until either all trust items are received
1959 (and @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}), or
1960 @code{gpgme_op_trustlist_end} is called to finish the operation.
1961
1962 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1963 valid pointer, and passes through any errors that are reported by the
1964 crypto engine support routines.
1965 @end deftypefun
1966
1967 @deftypefun GpgmeError gpgme_op_trustlist_next (@w{GpgmeCtx @var{ctx}}, @w{GpgmeTrustItem *@var{r_item}})
1968 The function @code{gpgme_op_trustlist_next} returns the next trust
1969 item in the list created by a previous @code{gpgme_op_trustlist_start}
1970 operation in the context @var{ctx}.  The trust item can be destroyed
1971 with @code{gpgme_trust_item_release}.  @xref{Manipulating Trust Items}.
1972
1973 This is the only way to get at @code{GpgmeTrustItem} objects in
1974 @acronym{GPGME}.
1975
1976 If the last trust item in the list has already been returned,
1977 @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}.
1978
1979 The function returns @code{GPGME_Invalid_Value} if @var{ctx} or
1980 @var{r_item} is not a valid pointer, @code{GPGME_No_Request} if there
1981 is no pending operation, @code{GPGME_Out_Of_Core} if there is not
1982 enough memory for the operation.
1983 @end deftypefun
1984
1985 @deftypefun GpgmeError gpgme_op_trustlist_end (@w{GpgmeCtx @var{ctx}})
1986 The function @code{gpgme_op_trustlist_next} ends a pending key list
1987 operation in the context @var{ctx}.
1988
1989 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1990 valid pointer, @code{GPGME_No_Request} if there is no pending
1991 operation, @code{GPGME_Out_Of_Core} if at some time during the
1992 operation there was not enough memory available.
1993 @end deftypefun
1994
1995
1996 @node Information About Trust Items
1997 @subsection Information About Trust Items
1998 @cindex trust item, information about
1999 @cindex trust item, attributes
2000 @cindex attributes, of a trust item
2001
2002 Trust items have attributes which can be queried using the interfaces
2003 below.  The attribute identifiers are shared with those for key
2004 attributes.  @xref{Information About Keys}.
2005
2006 @deftypefun {const char *} gpgme_trust_item_get_string_attr (@w{GpgmeTrustItem @var{item}}, @w{GpgmeAttr @var{what}}, @w{const void *@var{reserved}}, @w{int @var{idx}})
2007 The function @code{gpgme_trust_item_get_string_attr} returns the value
2008 of the string-representable attribute @var{what} of trust item
2009 @var{item}.  If the attribute occurs more than once in the trust
2010 items, the index is specified by @var{idx}.  However, currently no
2011 such attributes exists, so @var{idx} should be @code{0}.  The argument
2012 @var{reserved} is reserved for later use and should be @code{NULL}.
2013
2014 The string returned is only valid as long as the key is valid.
2015
2016 The function returns @code{0} if an attribute can't be returned as a
2017 string, @var{key} is not a valid pointer, @var{idx} out of range,
2018 or @var{reserved} not @code{NULL}.
2019 @end deftypefun
2020
2021 @deftypefun int gpgme_trust_item_get_int_attr (@w{GpgmeTrustItem @var{item}}, @w{GpgmeAttr @var{what}}, @w{const void *@var{reserved}}, @w{int @var{idx}})
2022 The function @code{gpgme_trust_item_get_int_attr} returns the value of
2023 the number-representable attribute @var{what} of trust item
2024 @var{item}.  If the attribute occurs more than once in the trust item,
2025 the index is specified by @var{idx}.  However, currently no such
2026 attribute exists, so @var{idx} should be @code{0}.  The argument
2027 @var{reserved} is reserved for later use and should be @code{NULL}.
2028
2029 The function returns @code{0} if the attribute can't be returned as a
2030 number, @var{key} is not a valid pointer, @var{idx} out of range,
2031 or @var{reserved} not @code{NULL}.
2032 @end deftypefun
2033
2034
2035 @node Manipulating Trust Items
2036 @subsection Manipulating Trust Items
2037 @cindex trust item, manipulation
2038
2039 @deftypefun void gpgme_trust_item_release (@w{GpgmeTrustItem @var{item}})
2040 The function @code{gpgme_trust_item_release} destroys a
2041 @code{GpgmeTrustItem} object and releases all associated resources.
2042 @end deftypefun
2043
2044 @node Crypto Operations
2045 @section Crypto Operations
2046 @cindex cryptographic operation
2047
2048 @menu
2049 * Decrypt::                       Decrypting a ciphertext.
2050 * Verify::                        Verifying a signature.
2051 * Decrypt and Verify::            Decrypting a signed ciphertext.
2052 * Sign::                          Creating a signature.
2053 * Encrypt::                       Encrypting a plaintext.
2054 * Detailed Results::              How to obtain more info about the operation.
2055 @end menu
2056
2057
2058 @node Decrypt
2059 @subsection Decrypt
2060 @cindex decryption
2061 @cindex cryptographic operation, decryption
2062
2063 @deftypefun GpgmeError gpgme_op_decrypt (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2064 The function @code{gpgme_op_decrypt} decrypts the ciphertext in the
2065 data object @var{cipher} and stores it into the data object
2066 @var{plain}.
2067
2068 The function returns @code{GPGME_No_Error} if the ciphertext could be
2069 decrypted successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2070 @var{cipher} or @var{plain} is not a valid pointer,
2071 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2072 decrypt, @code{GPGME_Decryption_Failed} if @var{cipher} is not a valid
2073 cipher text, @code{GPGME_No_Passphrase} if the passphrase for the
2074 secret key could not be retrieved, and passes through any errors that
2075 are reported by the crypto engine support routines.
2076 @end deftypefun
2077
2078 @deftypefun GpgmeError gpgme_op_decrypt_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2079 The function @code{gpgme_op_decrypt_start} initiates a
2080 @code{gpgme_op_decrypt} operation.  It can be completed by calling
2081 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2082
2083 The function returns @code{GPGME_No_Error} if the operation could be
2084 started successfully, and @code{GPGME_Invalid_Value} if @var{cipher}
2085 or @var{plain} is not a valid pointer.
2086 @end deftypefun
2087
2088
2089 @node Verify
2090 @subsection Verify
2091 @cindex verification
2092 @cindex signature, verification
2093 @cindex cryptographic operation, verification
2094 @cindex cryptographic operation, signature check
2095 @cindex signature, status
2096
2097 @deftp {Data type} {enum GpgmeSigStat}
2098 @tindex GpgmeSigStat
2099 The @code{GpgmeSigStat} type holds the result of a signature check, or
2100 the combined result of all signatures.  The following results are
2101 possible:
2102
2103 @table @code
2104 @item GPGME_SIG_STAT_NONE
2105 This status should not occur in normal operation.
2106
2107 @item GPGME_SIG_STAT_GOOD
2108 This status indicates that the signature is valid.  For the combined
2109 result this status means that all signatures are valid.
2110
2111 @item GPGME_SIG_STAT_GOOD_EXP
2112 This status indicates that the signature is valid but expired.  For
2113 the combined result this status means that all signatures are valid
2114 and expired.
2115
2116 @item GPGME_SIG_STAT_GOOD_EXPKEY
2117 This status indicates that the signature is valid but the key used to
2118 verify the signature has expired.  For the combined result this status
2119 means that all signatures are valid and all keys are expired.
2120
2121 @item GPGME_SIG_STAT_BAD
2122 This status indicates that the signature is invalid.  For the combined
2123 result this status means that all signatures are invalid.
2124
2125 @item GPGME_SIG_STAT_NOKEY
2126 This status indicates that the signature could not be verified due to
2127 a missing key.  For the combined result this status means that all
2128 signatures could not be checked due to missing keys.
2129
2130 @item GPGME_SIG_STAT_NOSIG
2131 This status indicates that the signature data provided was not a real
2132 signature.
2133
2134 @item GPGME_SIG_STAT_ERROR
2135 This status indicates that there was some other error which prevented
2136 the signature verification.
2137
2138 @item GPGME_SIG_STAT_DIFF
2139 For the combined result this status means that at least two signatures
2140 have a different status.  You can get each key's status with
2141 @code{gpgme_get_sig_status}.
2142 @end table
2143 @end deftp
2144
2145 @deftypefun GpgmeError gpgme_op_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}}, @w{GpgmeSigStat *@var{r_stat}})
2146 The function @code{gpgme_op_verify} verifies that the signature in the
2147 data object @var{sig} is a valid signature.  If @var{plain} is
2148 initialized with plaintext data, it is assumed that @var{sig} is a
2149 detached signature, and its validity for the plaintext given in
2150 @var{plain} is verified.  If @var{plain} is an uninitialized data
2151 object, it is assumed that @var{sig} is a normal (or cleartext)
2152 signature, and the plaintext is available in @var{plain} after
2153 successful verification.
2154
2155 The combined status of all signatures is returned in @var{r_stat}.
2156 The results of the individual signature verifications can be retrieved
2157 with @code{gpgme_get_sig_status} and @code{gpgme_get_sig_key}.
2158
2159 The function returns @code{GPGME_No_Error} if the operation could be
2160 completed successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2161 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer,
2162 @code{GPGME_No_Data} if @var{sig} does not contain any data to verify,
2163 and passes through any errors that are reported by the crypto engine
2164 support routines.
2165 @end deftypefun
2166
2167 @deftypefun GpgmeError gpgme_op_verify_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}})
2168 The function @code{gpgme_op_verify_start} initiates a
2169 @code{gpgme_op_verify} operation.  It can be completed by calling
2170 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2171
2172 The function returns @code{GPGME_No_Error} if the operation could be
2173 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2174 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer, and
2175 @code{GPGME_No_Data} if @var{sig} or @var{plain} does not contain any
2176 data to verify.
2177 @end deftypefun
2178
2179 @deftypefun {const char *} gpgme_get_sig_status (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeSigStat *@var{r_stat}}, @w{time_t *@var{r_created}})
2180 The function @code{gpgme_get_sig_status} receives information about a
2181 signature after the @code{gpgme_op_verify} or
2182 @code{gpgme_op_verify_decrypt} operation.  A single detached signature
2183 can contain signatures by more than one key.  The @var{idx} specifies
2184 which signature's information should be retrieved, starting from
2185 @var{0}.
2186
2187 The status of the signature will be returned in @var{r_stat} if it is
2188 not @code{NULL}.  The creation time stamp of the signature will be
2189 returned in @var{r_created} if it is not @var{NULL}.
2190
2191 The function returns a statically allocated string that contains the
2192 fingerprint of the key which signed the plaintext, or @code{NULL} if
2193 @var{ctx} is not a valid pointer, the operation is still pending, or
2194 no verification could be performed.
2195 @end deftypefun
2196
2197 @deftypefun {const char *} gpgme_get_sig_string_attr (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeAttr @var{waht}}, @w{int @var{reserved}})
2198 This function is similar to @code{gpgme_get_sig_status} but may be used
2199 to retrieve more detailed information.  @var{ctx} should be the context
2200 used for the last signature verification, @var{idx} is used to enumerate
2201 over all signatures starting with @code{0} and @var{reserved} should be
2202 @code{0} for now.
2203
2204 The only attribute @var{what} currently supported is
2205 @code{GPGME_ATTR_FPR} to return the fingerprint of the key used to
2206 create the signature.
2207 @end deftypefun
2208
2209 @deftypefun {const char *} gpgme_get_sig_ulong_attr (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeAttr @var{waht}}, @w{int @var{reserved}})
2210 This fucntion is similar to @code{gpgme_get_sig_string_attr} but used
2211 for attributes which can be represented by an @code{unsigned long} data
2212 type.  @var{ctx} should be the context used for the last signature
2213 verification, @var{idx} is used to enumerate over all signatures
2214 starting with @code{0} and @var{reserved} should be @code{0} for now.
2215
2216 The following values may be used for @var{what}:
2217 @table @code
2218 @item GPGME_ATTR_CREATED
2219 Return the creation time of the signature in seconds since Epoch.  This
2220 is the same value as returned by @code{gpgme_get_sig_status}.
2221
2222 @item GPGME_ATTR_EXPIRE
2223 Return the expiration time of the signature in seconds since Epoch. 
2224
2225 @item GPGME_ATTR_VALIDITY
2226 Returns the validity of the key used to create the signature.  This is a
2227 shortcut function which avoids an extra key lookup.  The value returned
2228 is one of @code{GPGME_VALIDITY_UNKNOWN}, @code{GPGME_VALIDITY_NEVER},
2229 @code{GPGME_VALIDITY_MARGINAL} or @code{GPGME_VALIDITY_FULL}.
2230
2231 @item GPGME_ATTR_SIG_STATUS
2232 This is the same value as returned by @code{gpgme_get_sig_status}.
2233
2234 @end table
2235 @end deftypefun
2236
2237
2238 @deftypefun {const char *} gpgme_get_sig_key (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeSigKey *@var{r_stat}})
2239 The function @code{gpgme_get_sig_status} receives a @code{GpgmeKey}
2240 object for the key which was used to verify the signature after the
2241 @code{gpgme_op_verify} or @code{gpgme_op_verify_decrypt} operation.  A
2242 single detached signature can contain signatures by more than one key.
2243 The @var{idx} specifies which signature's information should be
2244 retrieved, starting from @var{0}.  The key will have on reference for
2245 the user.
2246
2247 The function is a convenient way to retrieve the keys belonging to the
2248 fingerprints returned by @code{gpgme_get_sig_status}.
2249
2250 The function returns @code{GPGME_No_Error} if the key could be
2251 returned, @code{GPGME_Invalid_Value} if @var{r_key} is not a valid
2252 pointer, @code{GPGME_Invalid_Key} if the fingerprint is not valid,
2253 @code{GPGME_EOF} if @var{idx} is too large, or some other error value
2254 if a problem occurred requesting the key.
2255 @end deftypefun
2256
2257 @deftypefun {char *} gpgme_get_notation (@w{GpgmeCtx @var{ctx}})
2258 The function @code{gpgme_get_notation} can be used to retrieve
2259 notation data from the last signature check in the context @var{ctx}.
2260
2261 If there is notation data available from the last signature check,
2262 this function may be used to return this notation data as a string.
2263 The string is an XML representation of that data embedded in a
2264 <notation> container.  The user has to release the string with
2265 @code{free}.
2266
2267 The function returns a string if the notation data is available or
2268 @code{NULL} if there is no such data available.
2269 @end deftypefun
2270
2271
2272 @node Decrypt and Verify
2273 @subsection Decrypt and Verify
2274 @cindex decryption and verification
2275 @cindex verification and decryption
2276 @cindex signature check
2277 @cindex cryptographic operation, decryption and verification
2278
2279 @deftypefun GpgmeError gpgme_op_decrypt_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}}, @w{GpgmeSigStat *@var{r_stat}})
2280 The function @code{gpgme_op_decrypt_verify} decrypts the ciphertext in
2281 the data object @var{cipher} and stores it into the data object
2282 @var{plain}.  If @var{cipher} contains signatures, they will be
2283 verified and their combined status will be returned in @var{r_stat}.
2284
2285 After the operation completed, @code{gpgme_op_get_sig_status} and
2286 @code{gpgme_op_get_sig_key} can be used to retrieve more information
2287 about the signatures.
2288
2289 The function returns @code{GPGME_No_Error} if the ciphertext could be
2290 decrypted successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2291 @var{cipher}, @var{plain} or @var{r_stat} is not a valid pointer,
2292 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2293 decrypt, @code{GPGME_Decryption_Failed} if @var{cipher} is not a valid
2294 cipher text, @code{GPGME_No_Passphrase} if the passphrase for the
2295 secret key could not be retrieved, and passes through any errors that
2296 are reported by the crypto engine support routines.
2297 @end deftypefun
2298
2299 @deftypefun GpgmeError gpgme_op_decrypt_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2300 The function @code{gpgme_op_decrypt_verify_start} initiates a
2301 @code{gpgme_op_decrypt_verify} operation.  It can be completed by
2302 calling @code{gpgme_wait} on the context.  @xref{Waiting For
2303 Completion}.
2304
2305 The function returns @code{GPGME_No_Error} if the operation could be
2306 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2307 @var{cipher}, @var{plain} or @var{r_stat} is not a valid pointer, and
2308 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2309 decrypt.
2310 @end deftypefun
2311
2312
2313 @node Sign
2314 @subsection Sign
2315 @cindex signature, creation
2316 @cindex sign
2317 @cindex cryptographic operation, signing
2318
2319 A signature can contain signatures by one or more keys.  The set of
2320 keys used to create a signatures is contained in a context, and is
2321 applied to all following signing operations in this context (until the
2322 set is changed).
2323
2324 @menu
2325 * Selecting Signers::             How to choose the keys to sign with.
2326 * Creating a Signature::          How to create a signature.
2327 @end menu
2328
2329
2330 @node Selecting Signers
2331 @subsubsection Selecting Signers
2332 @cindex signature, selecting signers
2333 @cindex signers, selecting
2334
2335 @deftypefun void gpgme_signers_clear (@w{GpgmeCtx @var{ctx}})
2336 The function @code{gpgme_signers_clear} releases a reference for each
2337 key on the signers list and removes the list of signers from the
2338 context @var{ctx}.
2339
2340 Every context starts with an empty list.
2341 @end deftypefun
2342
2343 @deftypefun GpgmeError gpgme_signers_add (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}})
2344 The function @code{gpgme_signers_add} adds the key @var{key} to the
2345 list of signers in the context @var{ctx}.
2346
2347 One reference for the key is consumed.
2348 @end deftypefun
2349
2350 @deftypefun GpgmeKey gpgme_signers_enum (@w{const GpgmeCtx @var{ctx}}, @w{int @var{seq}})
2351 The function @code{gpgme_signers_enum} returns the @var{seq}th key in
2352 the list of signers in the context @var{ctx}.  An additional reference
2353 is acquired for the user.
2354
2355 If @var{seq} is out of range, @code{NULL} is returned.
2356 @end deftypefun
2357
2358
2359 @node Creating a Signature
2360 @subsubsection Creating a Signature
2361
2362 @deftp {Data type} {enum GpgmeSigMode}
2363 @tindex GpgmeSigMode
2364 The @code{GpgmeSigMode} type is used to specify the desired type of a
2365 signature.  The following modes are available:
2366
2367 @table @code
2368 @item GPGME_SIG_MODE_NORMAL
2369 A normal signature is made, the output includes the plaintext and the
2370 signature.
2371
2372 @item GPGME_SIG_MODE_DETACH
2373 A detached signature is made.
2374
2375 @item GPGME_SIG_MODE_CLEAR
2376 A clear text signature is made.  The @acronym{ASCII} armor and text
2377 mode settings of the context are ignored.
2378 @end table
2379 @end deftp
2380
2381 @deftypefun GpgmeError gpgme_op_sign (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{sig}}, @w{GpgmeSigMode @var{mode}})
2382 The function @code{gpgme_op_sign} creates a signature for the text in
2383 the data object @var{plain} and returns it in the data object
2384 @var{sig}.  The type of the signature created is determined by the
2385 @acronym{ASCII} armor and text mode attributes set for the context
2386 @var{ctx} and the requested signature mode @var{mode}.
2387
2388 More information about the signatures is available with
2389 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
2390
2391 If an S/MIME signed message is created using the CMS crypto engine,
2392 the number of certificates to include in the message can be specified
2393 with @code{gpgme_set_include_certs}.  @xref{Included Certificates}.
2394
2395 The function returns @code{GPGME_No_Error} if the signature could be
2396 created successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2397 @var{plain} or @var{sig} is not a valid pointer, @code{GPGME_No_Data}
2398 if the signature could not be created, @code{GPGME_No_Passphrase} if
2399 the passphrase for the secret key could not be retrieved, and passes
2400 through any errors that are reported by the crypto engine support
2401 routines.
2402 @end deftypefun
2403
2404 @deftypefun GpgmeError gpgme_op_sign_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{sig}}, @w{GpgmeSigMode @var{mode}})
2405 The function @code{gpgme_op_sign_start} initiates a
2406 @code{gpgme_op_sign} operation.  It can be completed by calling
2407 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2408
2409 The function returns @code{GPGME_No_Error} if the operation could be
2410 started successfully, and @code{GPGME_Invalid_Value} if @var{ctx},
2411 @var{plain} or @var{sig} is not a valid pointer.
2412 @end deftypefun
2413
2414
2415 @node Encrypt
2416 @subsection Encrypt
2417 @cindex encryption
2418 @cindex cryptographic operation, encryption
2419
2420 One plaintext can be encrypted for several recipients at the same
2421 time.  The list of recipients is created independently of any context,
2422 and then passed to the encryption operation.
2423
2424 @menu
2425 * Selecting Recipients::          How to choose the recipients.
2426 * Encrypting a Plaintext::        How to encrypt a plaintext.
2427 @end menu
2428
2429
2430 @node Selecting Recipients
2431 @subsubsection Selecting Recipients
2432 @cindex encryption, selecting recipients
2433 @cindex recipients
2434
2435 @deftp {Data type} GpgmeRecipients
2436 The @code{GpgmeRecipients} type is a handle for a set of recipients
2437 that can be used in an encryption process.
2438 @end deftp
2439
2440 @deftypefun GpgmeError gpgme_recipients_new (@w{GpgmeRecipients *@var{r_rset}})
2441 The function @code{gpgme_recipients_new} creates a new, empty set of
2442 recipients and returns a handle for it in @var{r_rset}.
2443
2444 The function returns @code{GPGME_No_Error} if the recipient set could
2445 be created successfully, and @code{GPGME_Out_Of_Core} if not enough
2446 memory was available.
2447 @end deftypefun
2448
2449 @deftypefun void gpgme_recipients_release (@w{GpgmeRecipients @var{rset}})
2450 The function @code{gpgme_recipients_release} destroys the set of
2451 recipients @var{rset} and releases all associated resources.
2452 @end deftypefun
2453
2454 @deftypefun GpgmeError gpgme_recipients_add_name (@w{GpgmeRecipients @var{rset}}, @w{const char *@var{name}})
2455 The function @code{gpgme_recipients_add_name} adds the recipient
2456 @var{name} to the set of recipients @var{rset}.  This is equivalent to
2457 @code{gpgme_recipients_add_name_with_validity} with a validity of
2458 @code{GPGME_VALIDITY_UNKNOWN}.
2459
2460 The function returns @code{GPGME_No_Error} if the recipient was added
2461 successfully, @code{GPGME_Invalid_Value} if @var{rset} or @var{name}
2462 is not a valid pointer, and @code{GPGME_Out_Of_Core} if not enough
2463 memory is available.
2464 @end deftypefun
2465
2466 @deftypefun GpgmeError gpgme_recipients_add_name_with_validity (@w{GpgmeRecipients @var{rset}}, @w{const char *@var{name}}, @w{GpgmeValidity @var{val}})
2467 The function @code{gpgme_recipients_add_name_with_validity} adds the
2468 recipient @var{name} with the validity @var{val} to the set of
2469 recipients @var{rset}.  If the validity is not known, the function
2470 @code{gpgme_recipients_add_name} can be used.
2471 @xref{Information About Keys}, for the possible values for @var{val}.
2472
2473 The function returns @code{GPGME_No_Error} if the recipient was added
2474 successfully, @code{GPGME_Invalid_Value} if @var{rset} or @var{name}
2475 is not a valid pointer, and @code{GPGME_Out_Of_Core} if not enough
2476 memory is available.
2477 @end deftypefun
2478
2479 @deftypefun {unsigned int} gpgme_recipients_count (@w{const @var{GpgmeRecipients rset}})
2480 The function @code{gpgme_recipients_count} returns the number of
2481 recipients in the set @var{rset}.
2482 @end deftypefun
2483
2484 @deftypefun GpgmeError gpgme_recipients_enum_open (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2485 The function @code{gpgme_recipients_enum_open} creates a new iterator
2486 @var{iter} that can be used to walk through the set of recipients in
2487 @var{rset}, using @code{gpgme_recipients_enum_read}.
2488
2489 If the iterator is not needed anymore, it can be closed with
2490 @code{gpgme_recipients_enum_close}.
2491
2492 The function returns @code{GPGME_No_Error} if the enumerator was
2493 successfully created and @code{GPGME_Invalid_Value} if @var{rset} or
2494 @var{iter} is not a valid pointer.
2495 @end deftypefun
2496
2497 @deftypefun {const char *} gpgme_recipients_enum_read (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2498 The function @code{gpgme_recipients_enum_read} returns a string
2499 containing the name of the next recipient in the set @var{rset} for
2500 the iterator @var{iter}.  The string is valid as long as @var{rset} is
2501 valid or the function is called the next time with the same recipient
2502 set and iterator, whatever is earlier.
2503 @end deftypefun
2504
2505 @deftypefun GpgmeError gpgme_recipients_enum_close (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2506 The function @code{gpgme_recipients_enum_close} releases the iterator
2507 @var{iter} for the recipient set @var{rset}.
2508 @end deftypefun
2509
2510
2511 @node Encrypting a Plaintext
2512 @subsubsection Encrypting a Plaintext
2513
2514 @deftypefun GpgmeError gpgme_op_encrypt (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2515 The function @code{gpgme_op_encrypt} encrypts the plaintext in the data
2516 object @var{plain} for the recipients @var{rset} and stores the
2517 ciphertext in the data object @var{cipher}.  The type of the
2518 ciphertext created is determined by the @acronym{ASCII} armor and text
2519 mode attributes set for the context @var{ctx}.
2520
2521 If @code{GPGME_Invalid_Recipients} is returned, some recipients in
2522 @var{rset} are invalid, but not all.  In this case the plaintext is
2523 encrypted for all valid recipients and returned in @var{cipher}.  More
2524 information about the invalid recipients is available with
2525 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
2526
2527 If @var{recp} is @code{NULL}, symmetric rather than public key
2528 encryption is performed.  Symmetrically encrypted cipher text can be
2529 deciphered with @code{gpgme_op_decrypt}.  Note that in this case the
2530 crypto backend needs to retrieve a passphrase from the user.
2531 Symmetric encryption is currently only supported for the OpenPGP
2532 crypto backend.
2533
2534 The function returns @code{GPGME_No_Error} if the ciphertext could be
2535 created successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2536 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer,
2537 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2538 recipients, @code{GPGME_Invalid_Recipients} if @var{rset} contains
2539 some invalid recipients, @code{GPGME_No_Passphrase} if the passphrase
2540 for the secret key could not be retrieved, and passes through any
2541 errors that are reported by the crypto engine support routines.
2542 @end deftypefun
2543
2544 @deftypefun GpgmeError gpgme_op_encrypt_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2545 The function @code{gpgme_op_encrypt_start} initiates a
2546 @code{gpgme_op_encrypt} operation.  It can be completed by calling
2547 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2548
2549 The function returns @code{GPGME_No_Error} if the operation could be
2550 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2551 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
2552 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2553 recipients.
2554 @end deftypefun
2555
2556
2557 @deftypefun GpgmeError gpgme_op_encrypt_sign (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2558 The function @code{gpgme_op_encrypt_sign} does a combined encrypt and
2559 sign operation.  It is used like @code{gpgme_op_encrypt}, but the
2560 ciphertext also contains signatures for the signers listed in
2561 @var{ctx}.
2562
2563 The combined encrypt and sign operation is currently only available
2564 for the OpenPGP crypto engine.
2565 @end deftypefun
2566
2567 @deftypefun GpgmeError gpgme_op_encrypt_sign_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2568 The function @code{gpgme_op_encrypt_sign_start} initiates a
2569 @code{gpgme_op_encrypt_sign} operation.  It can be completed by
2570 calling @code{gpgme_wait} on the context.  @xref{Waiting For
2571 Completion}.
2572
2573 The function returns @code{GPGME_No_Error} if the operation could be
2574 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2575 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
2576 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2577 recipients.
2578 @end deftypefun
2579
2580
2581 @node Detailed Results
2582 @subsection Detailed Results
2583 @cindex cryptographic operation, detailed results
2584
2585 @deftypefun {char *} gpgme_get_op_info (@w{GpgmeCtx @var{ctx}}, @w{int @var{reserved}})
2586 The function @code{gpgme_get_op_info} retrieves more information about
2587 the last crypto operation.
2588
2589 The function returns a string in the XML format.  The user has to
2590 release the string with @code{free}.
2591
2592 Here is a sample of the information that might be returned:
2593 @example
2594 <GnupgOperationInfo>
2595   <signature>
2596     <detached/> <!-- or cleartext or standard -->
2597     <algo>17</algo>
2598     <hashalgo>2</hashalgo>
2599     <micalg>pgp-sha1</micalg>
2600     <sigclass>01</sigclass>
2601     <created>9222222</created>
2602     <fpr>121212121212121212</fpr>
2603   </signature>
2604 </GnupgOperationInfo>
2605 @end example
2606
2607 Currently, the only operations that return additional information are
2608 encrypt, sign and import.  @xref{Encrypt}, @xref{Sign},
2609 @xref{Importing Keys}.
2610
2611 The function returns a string or @code{NULL} if no such data is
2612 available.
2613 @end deftypefun
2614
2615
2616 @node Run Control
2617 @section Run Control
2618 @cindex run control
2619 @cindex cryptographic operation, running
2620
2621 Some basic support for running operations asynchronously is available
2622 in @acronym{GPGME}.  You can use it to set up a context completely up
2623 to initiating the desired operation, but delay performing it to a
2624 later point.
2625
2626 @menu
2627 * Waiting For Completion::        Waiting until an operation is completed.
2628 * Cancelling an Operation::       Interrupting a running operation.
2629 * Hooking Up Into Idle Time::     Doing something when nothing has to be done.
2630 @end menu
2631
2632
2633 @node Waiting For Completion
2634 @subsection Waiting For Completion
2635 @cindex cryptographic operation, wait for
2636 @cindex wait for completion
2637
2638 @deftypefun GpgmeCtx gpgme_wait (@w{GpgmeCtx @var{ctx}}, @w{GpgmeError *@var{status}}, @w{int @var{hang}})
2639 The function @code{gpgme_wait} does continue the pending operation
2640 within the context @var{ctx}.  In particular, it ensures the data
2641 exchange between @acronym{GPGME} and the crypto backend and watches
2642 over the run time status of the backend process.
2643
2644 If @var{hang} is true, the function does not return until the
2645 operation is completed or cancelled.  Otherwise the function will not
2646 block for a long time.
2647
2648 The error status of the finished operation is returned in
2649 @var{status}.
2650
2651 The @var{ctx} argument can be @code{NULL}.  In that case,
2652 @code{gpgme_wait} waits for any context to complete its operation.
2653
2654 The function returns the @var{ctx} of the context which has finished
2655 the operation.
2656 @end deftypefun
2657
2658
2659 @node Cancelling an Operation
2660 @subsection Cancelling an Operation
2661 @cindex cancellation
2662 @cindex cryptographic operation, cancel
2663
2664 @deftypefun void gpgme_cancel (@w{GpgmeCtx @var{ctx}})
2665 The function @code{gpgme_cancel} tries to cancel the pending
2666 operation.  The function @code{gpgme_wait} might notice the
2667 cancellation flag and return.  It is currently not guaranteed to work
2668 under all circumstances.  It's current primary purpose is to prevent
2669 asking for a passphrase again in the passphrase callback.
2670 @end deftypefun
2671
2672
2673 @node Hooking Up Into Idle Time
2674 @subsection Hooking Up Into Idle Time
2675 @cindex idle time
2676 @cindex idle function
2677
2678 @deftp {Data type} {void (*GpgmeIdleFunc) (void)}
2679 @tindex GpgmeIdleFunc
2680 The @code{GpgmeIdleFunc} type is the type of functions usable as
2681 an idle function that can be registered with @code{gpgme_register_idle}.
2682 @end deftp
2683
2684 @deftypefun GpgmeIdleFunc gpgme_register_idle (@w{GpgmeIdleFunc @var{idle}})
2685 The function @code{gpgme_register_idle} can be used to register
2686 @var{idle} as the idle function.
2687
2688 @var{idle} will be called whenever @acronym{GPGME} thinks that it is
2689 idle and time can better be spent elsewhere.  Setting @var{idle} to
2690 @code{NULL} disables use of the idle function (this is the default).
2691
2692 The function returns the old idle function, or @code{NULL} if none was
2693 registered yet.
2694 @end deftypefun
2695
2696
2697 @include gpl.texi
2698
2699
2700 @include fdl.texi
2701
2702
2703 @node Concept Index
2704 @unnumbered Concept Index
2705
2706 @printindex cp
2707
2708
2709 @node Function and Data Index
2710 @unnumbered Function and Data Index
2711
2712 @printindex fn
2713
2714
2715 @summarycontents
2716 @contents
2717 @bye