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