tests/
[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 is allowed to call @code{gpgme_wait} at a time.  If
527 multiple threads call this function, the caller must make sure that
528 all invocations are fully synchronized.
529
530 @item
531 Unfortunately, the last rule implies that all calls to one of the
532 following functions have to be fully synchronized together with
533 @code{gpgme_wait}, as they call @code{gpgme_wait} internally: All
534 functions @code{gpgme_op_FOO} that have a corresponding
535 @code{gpgme_op_FOO_start} function, @code{gpgme_op_keylist_next},
536 @code{gpgme_op_trustlist_next}.
537 @end itemize
538
539
540 @node Protocols and Engines
541 @chapter Protocols and Engines
542 @cindex protocol
543 @cindex engine
544 @cindex crypto engine
545 @cindex backend
546 @cindex crypto backend
547
548 @acronym{GPGME} supports several cryptographic protocols, however, it
549 does not implement them.  Rather it uses backends (also called
550 engines) which implement the protocol.  @acronym{GPGME} uses
551 inter-process communication to pass data back and forth between the
552 application and the backend, but the details of the communication
553 protocol and invocation of the backends is completely hidden by the
554 interface.  All complexity is handled by @acronym{GPGME}.  Where an
555 exchange of information between the application and the backend is
556 necessary, @acronym{GPGME} provides the necessary callback function
557 hooks and further interfaces.
558
559 @deftp {Data type} {enum GpgmeProtocol}
560 @tindex GpgmeProtocol
561 The @code{GpgmeProtocol} type specifies the set of possible protocol
562 values that are supported by @acronym{GPGME}.  The following protocols
563 are supported:
564
565 @table @code
566 @item GPGME_PROTOCOL_OpenPGP
567 This specifies the OpenPGP protocol.
568 @item GPGME_PROTOCOL_CMS
569 This specifies the Cryptographic Message Syntax.
570 @end table
571 @end deftp
572
573 @menu
574 * Engine Version Check::          Verifying the engine version.
575 * Engine Information::            Obtaining more information about the engines.
576 * OpenPGP::                       Support for the OpenPGP protocol.
577 * Cryptographic Message Syntax::  Support for the CMS.
578 @end menu
579
580
581 @node Engine Version Check
582 @section Engine Version Check
583 @cindex version check, of the engines
584
585 @deftypefun GpgmeError gpgme_engine_check_version (@w{GpgmeProtocol @var{protocol}})
586 The function @code{gpgme_engine_check_version} verifies that the
587 engine implementing the protocol @var{PROTOCOL} is installed in the
588 expected path and meets the version requirement of @acronym{GPGME}.
589
590 This function returns @code{GPGME_No_Error} if the engine is available
591 and @code{GPGME_Invalid_Engine} if it is not.
592 @end deftypefun
593
594 @deftypefun GpgmeError gpgme_check_engine (void)
595 The function @code{gpgme_check_engine} is equivalent to
596
597 @example
598 gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
599 @end example
600
601 This function is deprecated and provided for backwards compatibility
602 only.  It is obsoleted by @code{gpgme_engine_check_version}.
603 @end deftypefun
604
605
606 @node Engine Information
607 @section Engine Information
608 @cindex engine, information about
609
610 @deftypefun {const char *} gpgme_get_engine_info (void)
611 The function @code{gpgme_get_engine_info} returns an @acronym{XML}
612 string containing information about the available protocols and the
613 engine which implement them.  The following information is returned
614 for each engine:
615
616 @table @samp
617 @item <protocol>
618 The name of the protocol.
619 @item <version>
620 The version of the engine.
621 @item <path>
622 The path to the engine binary.
623 @end table
624
625 A string is always returned.  If an error occurs, the string will
626 contain an @samp{<error>} tag with a description of the failure.
627 @end deftypefun
628
629 Here is the example output of what @code{gpgme_get_engine_info} might
630 return on your system:
631
632 @example
633 <EngineInfo>
634  <engine>
635   <protocol>OpenPGP</protocol>
636   <version>1.0.6</version>
637   <path>/usr/bin/gpg</path>
638  </engine>
639  <engine>
640   <protocol>CMS</protocol>
641   <version>0.0.0</version>
642   <path>/usr/bin/gpgsm</path>
643  </engine>
644 </EngineInfo>
645 @end example
646
647
648 @node OpenPGP
649 @section OpenPGP
650 @cindex OpenPGP
651 @cindex GnuPG
652 @cindex protocol, GnuPG
653 @cindex engine, GnuPG
654
655 OpenPGP is implemented by GnuPG, the @acronym{GNU} Privacy Guard.
656 This is the first protocol that was supported by @acronym{GPGME}.
657
658 The OpenPGP protocol is specified by @code{GPGME_PROTOCOL_OpenPGP}.
659
660
661 @node Cryptographic Message Syntax
662 @section Cryptographic Message Syntax
663 @cindex CMS
664 @cindex cryptographic message syntax
665 @cindex GpgSM
666 @cindex protocol, CMS
667 @cindex engine, GpgSM
668 @cindex S/MIME
669 @cindex protocol, S/MIME
670
671 @acronym{CMS} is implemented by GpgSM, the S/MIME implementation for
672 GnuPG.
673
674 The @acronym{CMS} protocol is specified by @code{GPGME_PROTOCOL_CMS}.
675
676
677 @node Error Handling
678 @chapter Error Handling
679 @cindex error handling
680
681 Many functions in @acronym{GPGME} can return an error if they fail.
682 For this reason, the application should always catch the error
683 condition and take appropriate measures, for example by releasing the
684 resources and passing the error up to the caller, or by displaying a
685 descriptive message to the user and cancelling the operation.
686
687 Some error values do not indicate a system error or an error in the
688 operation, but the result of an operation that failed properly.  For
689 example, if you try to decrypt a tempered message, the decryption will
690 fail.  Another error value actually means that the end of a data
691 buffer or list has been reached.  The following descriptions explain
692 what each error message means in general.  Some error values have
693 specific meanings if returned by a specific function.  Such cases are
694 described in the documentation of those functions.
695
696 @menu
697 * Error Values::                  A list of all error values used.
698 * Error Strings::                 How to get a descriptive string from a value.
699 @end menu
700
701
702 @node Error Values
703 @section Error Values
704 @cindex error values, list of
705
706 @deftp {Data type} {enum GpgmeError}
707 @tindex GpgmeError
708 The @code{GpgmeError} type specifies the set of all error values that
709 are used by @acronym{GPGME}.  Possible values are:
710
711 @table @code
712 @item GPGME_EOF
713 This value indicates the end of a list, buffer or file.
714
715 @item GPGME_No_Error
716 This value indicates success.  The value of this error is @code{0}.
717
718 @item GPGME_General_Error
719 This value means that something went wrong, but either there is not
720 enough information about the problem to return a more useful error
721 value, or there is no separate error value for this type of problem.
722
723 @item GPGME_Out_Of_Core
724 This value means that an out-of-memory condition occurred.
725
726 @item GPGME_Invalid_Value
727 This value means that some user provided data was out of range.  This
728 can also refer to objects.  For example, if an empty @code{GpgmeData}
729 object was expected, but one containing data was provided, this error
730 value is returned.
731
732 @item GPGME_Busy
733 This value is returned if you try to start a new operation in a
734 context that is already busy with some earlier operation which was not
735 cancelled or finished yet.
736
737 @item GPGME_No_Request
738 This value is in some sense the opposite of @code{GPGME_Busy}.  There
739 is no pending operation, but it is required for the function to
740 succeed.
741
742 @item GPGME_Exec_Error
743 This value means that an error occurred when trying to spawn a child
744 process.
745
746 @item GPGME_Too_Many_Procs
747 This value means that there are too many active backend processes.
748
749 @item GPGME_Pipe_Error
750 This value means that the creation of a pipe failed.
751
752 @item GPGME_No_Recipients 
753 This value means that no valid recipients for a message have been set.
754
755 @item GPGME_Invalid_Recipients 
756 This value means that some, but not all, recipients for a message have
757 been invalid.
758
759 @item GPGME_No_Data
760 This value means that a @code{GpgmeData} object which was expected to
761 have content was found empty.
762
763 @item GPGME_Conflict
764 This value means that a conflict of some sort occurred.
765
766 @item GPGME_Not_Implemented
767 This value indicates that the specific function (or operation) is not
768 implemented.  This error should never happen.  It can only occur if
769 you use certain values or configuration options which do not work,
770 but for which we think that they should work at some later time.
771
772 @item GPGME_Read_Error
773 This value means that an I/O read operation failed.
774
775 @item GPGME_Write_Error
776 This value means that an I/O write operation failed.
777
778 @item GPGME_Invalid_Type
779 This value means that a user provided object was of a wrong or
780 incompatible type.  Usually this refers to the type of a
781 @code{GpgmeData} object.
782
783 @item GPGME_Invalid_Mode
784 This value means that a @code{GpgmeData} object has an incorrect mode
785 of operation (for example, doesn't support output although it is
786 attempted to use it as an output buffer).
787
788 @item GPGME_File_Error
789 This value means that a file I/O operation failed.  The value of
790 @code{errno} contains the system error value.
791
792 @item GPGME_Decryption_Failed
793 This value indicates that a decryption operation was unsuccessful.
794
795 @item GPGME_No_Passphrase
796 This value means that the user did not provide a passphrase when
797 requested.
798
799 @item GPGME_Canceled
800 This value means that the operation was canceled.
801
802 @item GPGME_Invalid_Key
803 This value means that a key was invalid.
804
805 @item GPGME_Invalid_Engine
806 This value means that the engine that implements the desired protocol
807 is currently not available.  This can either be because the sources
808 were configured to exclude support for this engine, or because the
809 engine is not installed properly.
810 @end table
811 @end deftp
812
813
814 @node Error Strings
815 @section Error Strings
816 @cindex error values, printing of
817 @cindex error strings
818
819 @deftypefun {const char *} gpgme_strerror (@w{GpgmeError @var{err}})
820 The function @code{gpgme_strerror} returns a pointer to a statically
821 allocated string containing a description of the error with the error
822 value @var{err}.  This string can be used to output a diagnostic
823 message to the user.
824
825 The following example illustrates the use of @code{gpgme_strerror}:
826
827 @example
828 GpgmeCtx ctx;
829 GpgmeError err = gpgme_new (&ctx);
830 if (err)
831   @{
832     fprintf (stderr, "%s: creating GpgME context failed: %s\n",
833              argv[0], gpgme_strerror (err));
834     exit (1);
835   @}
836 @end example
837 @end deftypefun
838
839
840 @node Exchanging Data
841 @chapter Exchanging Data
842 @cindex data, exchanging
843
844 A lot of data has to be exchanged between the user and the crypto
845 engine, like plaintext messages, ciphertext, signatures and
846 information about the keys.  The technical details about exchanging
847 the data information are completely abstracted by @acronym{GPGME}.
848 The user provides and receives the data via @code{GpgmeData} objects,
849 regardless of the communication protocol between @acronym{GPGME} and
850 the crypto engine in use.
851
852 @deftp {Data type} {GpgmeData}
853 The @code{GpgmeData} type is a handle for a container for generic
854 data, which is used by @acronym{GPGME} to exchange data with the user.
855 @end deftp
856
857 @menu
858 * Creating Data Buffers::         Creating new data buffers.
859 * Destroying Data Buffers::       Releasing data buffers.
860 * Manipulating Data Buffers::     Operations on data buffers.
861 @end menu
862
863
864 @node Creating Data Buffers
865 @section Creating Data Buffers
866 @cindex data buffer, creation
867
868 @deftypefun GpgmeError gpgme_data_new (@w{GpgmeData *@var{dh}})
869 The function @code{gpgme_data_new} creates a new @code{GpgmeData}
870 object and returns a handle for it in @var{dh}.  The data object is
871 initially empty.
872
873 The function returns @code{GPGME_No_Error} if the data object was
874 successfully created, @code{GPGME_Invalid_Value} if @var{dh} is not a
875 valid pointer, and @code{GPGME_Out_Of_Core} if not enough memory is
876 available.
877 @end deftypefun
878
879 @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}})
880 The function @code{gpgme_data_new_from_mem} creates a new
881 @code{GpgmeData} object and fills it with @var{size} bytes starting
882 from @var{buffer}.
883
884 If @var{copy} is not zero, a private copy of the data is made.  If
885 @var{copy} is zero, the data is taken from the specified buffer as
886 needed, and the user has to ensure that the buffer remains valid for
887 the whole life span of the data object.
888
889 The function returns @code{GPGME_No_Error} if the data object was
890 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
891 @var{buffer} is not a valid pointer, and @code{GPGME_Out_Of_Core} if
892 not enough memory is available.
893 @end deftypefun
894
895 @deftypefun GpgmeError gpgme_data_new_from_file (@w{GpgmeData *@var{dh}}, @w{const char *@var{filename}}, @w{int @var{copy}})
896 The function @code{gpgme_data_new_from_file} creates a new
897 @code{GpgmeData} object and fills it with the content of the file
898 @var{filename}.
899
900 If @var{copy} is not zero, the whole file is read in at initialization
901 time and the file is not used anymore after that.  This is the only
902 mode supported currently.  Later, a value of zero for @var{copy} might
903 cause all reads to be delayed until the data is needed, but this is
904 not yet implemented.
905
906 The function returns @code{GPGME_No_Error} if the data object was
907 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
908 @var{filename} is not a valid pointer, @code{GPGME_File_Error} if an
909 I/O operation fails, @code{GPGME_Not_Implemented} if @var{code} is
910 zero, and @code{GPGME_Out_Of_Core} if not enough memory is available.
911 @end deftypefun
912
913 @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}})
914 The function @code{gpgme_data_new_from_filepart} creates a new
915 @code{GpgmeData} object and fills it with a part of the file specified
916 by @var{filename} or @var{fp}.
917
918 Exactly one of @var{filename} and @var{fp} must be non-zero, the other
919 must be zero.  The argument that is not zero specifies the file from
920 which @var{length} bytes are read into the data object, starting from
921 @var{offset}.
922
923 The function returns @code{GPGME_No_Error} if the data object was
924 successfully created, @code{GPGME_Invalid_Value} if @var{dh} and
925 exactly one of @var{filename} and @var{fp} is not a valid pointer,
926 @code{GPGME_File_Error} if an I/O operation fails, and
927 @code{GPGME_Out_Of_Core} if not enough memory is available.
928 @end deftypefun
929
930 @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}})
931 The function @code{gpgme_data_new_with_read_cb} creates a new
932 @code{GpgmeData} object and uses the callback function @var{readfunc}
933 to retrieve the data on demand.  As the callback function can supply
934 the data in any way it wants, this is the most flexible data type
935 @acronym{GPGME} provides.  However, it can not be used to write data.
936
937 The callback function receives @var{hook_value} as its first argument
938 whenever it is invoked.  It should return up to @var{count} bytes in
939 @var{buffer}, and return the number of bytes actually read in
940 @var{nread}.  It may return @code{0} in @var{nread} if no data is
941 currently available.  To indicate @code{EOF} the function should
942 return with an error code of @code{-1} and set @var{nread} to
943 @code{0}.  The callback function may support to reset its internal
944 read pointer if it is invoked with @var{buffer} and @var{nread} being
945 @code{NULL} and @var{count} being @code{0}.
946
947 The function returns @code{GPGME_No_Error} if the data object was
948 successfully created, @code{GPGME_Invalid_Value} if @var{dh} or
949 @var{readfunc} is not a valid pointer, and @code{GPGME_Out_Of_Core} if
950 not enough memory is available.
951 @end deftypefun
952
953
954 @node Destroying Data Buffers
955 @section Destroying Data Buffers
956 @cindex data buffer, destruction
957
958 @deftypefun void gpgme_data_release (@w{GpgmeData @var{dh}})
959 The function @code{gpgme_data_release} destroys the data object with
960 the handle @var{dh}.  It releases all associated resources that were
961 not provided by the user in the first place.
962 @end deftypefun
963
964 @deftypefun {char *} gpgme_data_release_and_get_mem (@w{GpgmeData @var{dh}}, @w{size_t *@var{length}})
965 The function @code{gpgme_data_release_and_get_mem} is like
966 @code{gpgme_data_release}, except that it returns the data buffer and
967 its length that was provided by the object.
968
969 The user has to release the buffer with @code{free}.  In case the user
970 provided the data buffer in non-copy mode, a copy will be made for
971 this purpose.
972
973 In case an error returns, or there is no suitable data buffer that can
974 be returned to the user, the function will return @code{NULL}.
975 @end deftypefun
976
977
978 @node Manipulating Data Buffers
979 @section Manipulating Data Buffers
980 @cindex data buffere, manipulation
981
982 @deftypefun GpgmeError gpgme_data_read (@w{GpgmeData @var{dh}}, @w{void *@var{buffer}}, @w{size_t @var{length}}, @w{size_t *@var{nread}})
983 The function @code{gpgme_data_read} reads up to @var{length} bytes
984 from the data object with the handle @var{dh} into the space starting
985 at @var{buffer}.  The actual amount read is returned in @var{nread}.
986
987 If @var{buffer} is @code{NULL}, the function returns the amount of
988 bytes available in @var{nread} without changing the read pointer.
989 This is not supported by all types of data objects.  If this function
990 is not supported, @code{GPGME_Invalid_Type} is returned.
991
992 If the end of the data object is reached, the function returns
993 @code{GPGME_EOF} and sets @var{nread} to zero.
994
995 In all other cases, the function returns @code{GPGME_No_Error} if the
996 operation was successfully performed and @code{GPGME_Invalid_Value} if
997 @var{dh} is not a valid pointer.
998 @end deftypefun
999
1000 @deftypefun GpgmeError gpgme_data_rewind (@w{GpgmeData @var{dh}})
1001 The function @code{gpgme_data_rewind} resets the read pointer of the
1002 data object with the handle @var{dh}, so that a subsequent
1003 @code{gpgme_data_read} operation starts at the beginning of the data.
1004
1005 The function returns @code{GPGME_No_Error} if the operation was
1006 successfully performed, @code{GPGME_Not_Implemented} if the operation
1007 is not supported (for example, by a read callback function supplied by
1008 the user) and @code{GPGME_Invalid_Value} if @var{dh} is not a valid
1009 pointer.
1010 @end deftypefun
1011
1012 @deftypefun GpgmeError gpgme_data_write (@w{GpgmeData @var{dh}}, @w{const void *@var{buffer}}, @w{size_t @var{length}})
1013 The function @code{gpgme_data_write} writes @var{length} bytes
1014 starting from @var{buffer} into the data object with the handle
1015 @var{dh} at the current write position.
1016
1017 The function returns @code{GPGME_No_Error} if the operation was
1018 successfully performed, @code{GPGME_Invalid_Value} if @var{dh} or
1019 @var{buffer} is not a valid pointer, @code{GPGME_Invalid_Type} or
1020 @code{GPGME_Invalid_Mode} if the data object type does not support
1021 writing, and @code{GPGME_Out_Of_Core} if not enough memory is
1022 available.
1023 @end deftypefun
1024
1025 @c
1026 @c  GpgmeDataType
1027 @c
1028 @deftp {Data type} {enum GpgmeDataType}
1029 @tindex GpgmeDataType
1030 The @code{GpgmeDataType} type specifies the type of a @code{GpgmeData} object.
1031 The following data types are available:
1032
1033 @table @code
1034 @item GPGME_DATA_TYPE_NONE
1035 This specifies that the type is not yet determined.
1036
1037 @item GPGME_DATA_TYPE_MEM
1038 This specifies that the data is stored in memory.
1039
1040 @item GPGME_DATA_TYPE_FD
1041 This type is not implemented.
1042
1043 @item GPGME_DATA_TYPE_FILE
1044 This type is not implemented.
1045
1046 @item GPGME_DATA_TYPE_CB
1047 This type specifies that the data is provided by a callback function
1048 implemented by the user.
1049 @end table
1050 @end deftp
1051
1052 @deftypefun GpgmeDataType gpgme_data_get_type (@w{GpgmeData @var{dh}})
1053 The function @code{gpgme_data_get_type} returns the type of the data
1054 object with the handle @var{dh}.  If @var{dh} is not a valid pointer,
1055 @code{GPGME_DATA_TYPE_NONE} is returned.
1056 @end deftypefun
1057
1058 @c
1059 @c  GpgmeDataEncoding
1060 @c
1061 @deftp {Data type} {enum GpgmeDataEncoding}
1062 @tindex GpgmeDataEncoding
1063 The @code{GpgmeDataEncoding} type specifies the encoding of a
1064 @code{GpgmeData} object.  This encoding is useful to give the backend
1065 a hint on the type of data.  The following data types are available:
1066
1067 @table @code
1068 @item GPGME_DATA_ENCODING_NONE
1069 This specifies that the encoding is not known.  This is the default
1070 for a new data object.
1071
1072 @item GPGME_DATA_ENCODING_BINARY
1073 This specifies that the data is encoding in binary form; i.e. there is
1074 no special encoding.
1075
1076 @item GPGME_DATA_ENCODING_BASE64
1077 This specifies that the data is encoded using the Base-64 encoding
1078 scheme as used by @acronym{MIME} and other protocols.
1079
1080 @item GPGME_DATA_ENCODING_ARMOR
1081 This specifies that the data is encoded in an armored form as used by
1082 OpenPGP and PEM.
1083 @end table
1084 @end deftp
1085
1086 @deftypefun GpgmeDataEncoding gpgme_data_get_encoding (@w{GpgmeData @var{dh}})
1087 The function @code{gpgme_data_get_encoding} returns the encoding of
1088 the data object with the handle @var{dh}.  If @var{dh} is not a valid
1089 pointer (e.g. @code{NULL}) @code{GPGME_DATA_ENCODING_NONE} is
1090 returned.
1091 @end deftypefun
1092
1093 @deftypefun GpgmeError gpgme_data_set_encoding (@w{GpgmeData @var{dh}, GpgmeDataEncoding @var{enc}})
1094 The function @code{gpgme_data_set_encoding} changes the encoding of
1095 the data object with the handle @var{dh} to @var{enc}.
1096 @end deftypefun
1097
1098
1099 @c
1100 @c    Chapter Contexts
1101 @c 
1102 @node Contexts
1103 @chapter Contexts
1104 @cindex context
1105
1106 All cryptographic operations in @acronym{GPGME} are performed within a
1107 context, which contains the internal state of the operation as well as
1108 configuration parameters.  By using several contexts you can run
1109 several cryptographic operations in parallel, with different
1110 configuration.
1111
1112 @deftp {Data type} {GpgmeCtx}
1113 The @code{GpgmeCtx} type is a handle for a @acronym{GPGME} context,
1114 which is used to hold the configuration, status and result of
1115 cryptographic operations.
1116 @end deftp
1117
1118 @menu
1119 * Creating Contexts::             Creating new @acronym{GPGME} contexts.
1120 * Destroying Contexts::           Releasing @acronym{GPGME} contexts.
1121 * Context Attributes::            Setting properties of a context.
1122 * Key Management::                Managing keys with @acronym{GPGME}.
1123 * Trust Item Management::         Managing trust items with @acronym{GPGME}.
1124 * Crypto Operations::             Using a context for cryptography.
1125 * Run Control::                   Controlling how operations are run.
1126 @end menu
1127
1128
1129 @node Creating Contexts
1130 @section Creating Contexts
1131 @cindex context, creation
1132
1133 @deftypefun GpgmeError gpgme_new (@w{GpgmeCtx *@var{ctx}})
1134 The function @code{gpgme_data_new} creates a new @code{GpgmeCtx}
1135 object and returns a handle for it in @var{ctx}.
1136
1137 The function returns @code{GPGME_No_Error} if the context was
1138 successfully created, @code{GPGME_Invalid_Value} if @var{ctx} is not a
1139 valid pointer, and @code{GPGME_Out_Of_Core} if not enough memory is
1140 available.
1141 @end deftypefun
1142
1143
1144 @node Destroying Contexts
1145 @section Destroying Contexts
1146 @cindex context, destruction
1147
1148 @deftypefun void gpgme_release (@w{GpgmeCtx @var{ctx}})
1149 The function @code{gpgme_release} destroys the context with the handle
1150 @var{ctx} and releases all associated resources.
1151 @end deftypefun
1152
1153
1154 @node Context Attributes
1155 @section Context Attributes
1156 @cindex context, attributes
1157
1158 @menu
1159 * Protocol Selection::            Selecting the protocol used by a context.
1160 * @acronym{ASCII} Armor::                   Requesting @acronym{ASCII} armored output.
1161 * Text Mode::                     Choosing canonical text mode.
1162 * Included Certificates::       Including a number of certificates.
1163 * Key Listing Mode::              Selecting key listing mode.
1164 * Passphrase Callback::           Getting the passphrase from the user.
1165 * Progress Meter Callback::       Being informed about the progress.
1166 @end menu
1167
1168
1169 @node Protocol Selection
1170 @subsection Protocol Selection
1171 @cindex context, selecting protocol
1172 @cindex protocol, selecting
1173
1174 @deftypefun GpgmeError gpgme_set_protocol (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProtocol @var{proto}})
1175 The function @code{gpgme_set_protocol} sets the protocol used within
1176 the context @var{ctx} to @var{proto}.  All crypto operations will be
1177 performed by the crypto engine configured for that protocol.
1178 @xref{Protocols and Engines}.
1179
1180 Setting the protocol with @code{gpgme_set_protocol} does not check if
1181 the crypto engine for that protocol is available and installed
1182 correctly.  @xref{Engine Version Check}.
1183
1184 The function returns @code{GPGME_No_Error} if the protocol could be
1185 set successfully, and @code{GPGME_Invalid_Value} if @var{protocol} is
1186 not a valid protocol.
1187 @end deftypefun
1188
1189 @deftypefun GpgmeProtocol gpgme_get_protocol (@w{GpgmeCtx @var{ctx}})
1190 The function @code{gpgme_get_protocol} retrieves the protocol currently
1191 use with the context @var{ctx}.
1192 @end deftypefun
1193
1194 @node @acronym{ASCII} Armor
1195 @subsection @acronym{ASCII} Armor
1196 @cindex context, armor mode
1197 @cindex @acronym{ASCII} armor
1198 @cindex armor mode
1199
1200 @deftypefun void gpgme_set_armor (@w{GpgmeCtx @var{ctx}}, @w{int @var{yes}})
1201 The function @code{gpgme_set_armor} specifies if the output should be
1202 @acronym{ASCII} armored.  By default, output is not @acronym{ASCII}
1203 armored.
1204
1205 @acronym{ASCII} armored output is disabled if @var{yes} is zero, and
1206 enabled otherwise.
1207 @end deftypefun
1208
1209 @deftypefun int gpgme_get_armor (@w{GpgmeCtx @var{ctx}})
1210 The function @code{gpgme_get_armor} returns 1 if the output is
1211 @acronym{ASCII} armored, and @code{0} if it is not, or if @var{ctx} is
1212 not a valid pointer.
1213 @end deftypefun
1214
1215
1216 @node Text Mode
1217 @subsection Text Mode
1218 @cindex context, text mode
1219 @cindex text mode
1220 @cindex canonical text mode
1221
1222 @deftypefun void gpgme_set_textmode (@w{GpgmeCtx @var{ctx}}, @w{int @var{yes}})
1223 The function @code{gpgme_set_textmode} specifies if canonical text mode
1224 should be used.  By default, text mode is not used.
1225
1226 Text mode is for example used for the RFC2015 signatures; note that
1227 the updated RFC 3156 mandates that the mail user agent does some
1228 preparations so that text mode is not needed anymore.
1229
1230 This option is only relevant to the OpenPGP crypto engine, and ignored
1231 by all other engines.
1232
1233 Canonical text mode is disabled if @var{yes} is zero, and enabled
1234 otherwise.
1235 @end deftypefun
1236
1237 @deftypefun int gpgme_get_textmode (@w{GpgmeCtx @var{ctx}})
1238 The function @code{gpgme_get_textmode} returns 1 if canonical text
1239 mode is enabled, and @code{0} if it is not, or if @var{ctx} is not a
1240 valid pointer.
1241 @end deftypefun
1242
1243
1244 @node Included Certificates
1245 @subsection Included Certificates
1246 @cindex certificates, included
1247
1248 @deftypefun void gpgme_set_include_certs (@w{GpgmeCtx @var{ctx}}, @w{int @var{nr_of_certs}})
1249 The function @code{gpgme_set_include_certs} specifies how many
1250 certificates should be included in an S/MIME signed message.  By
1251 default, only the sender's certificate is included.  The possible
1252 values of @var{nr_of_certs} are:
1253
1254 @table @code
1255 @item -2
1256 Include all certificates except the root certificate.
1257 @item -1
1258 Include all certificates.
1259 @item 0
1260 Include no certificates.
1261 @item 1
1262 Include the sender's certificate only.
1263 @item n
1264 Include the first n certificates of the certificates path, starting
1265 from the sender's certificate.  The number @code{n} must be positive.
1266 @end table
1267
1268 Values of @var{nr_of_certs} smaller than -2 are undefined.
1269
1270 This option is only relevant to the CMS crypto engine, and ignored
1271 by all other engines.
1272 @end deftypefun
1273
1274 @deftypefun int gpgme_get_include_certs (@w{GpgmeCtx @var{ctx}})
1275 The function @code{gpgme_get_include_certs} returns the number of
1276 certificates to include into an S/MIME signed message.
1277 @end deftypefun
1278
1279
1280 @node Key Listing Mode
1281 @subsection Key Listing Mode
1282 @cindex key listing mode
1283 @cindex key listing, mode of
1284
1285 @deftypefun void gpgme_set_keylist_mode (@w{GpgmeCtx @var{ctx}}, @w{int @var{mode}})
1286 The function @code{gpgme_set_keylist_mode} changes the default
1287 behaviour of the key listing functions.  The value in @var{mode} is a
1288 bitwise-or combination of one or multiple of the following bit values:
1289
1290 @table @code
1291 @item GPGME_KEYLIST_MODE_LOCAL
1292 The @code{GPGME_KEYLIST_MODE_LOCAL} symbol specifies that the local
1293 keyring should be searched for keys in the keylisting operation.  This
1294 is the default.
1295
1296 @item GPGME_KEYLIST_MODE_EXTERN
1297 The @code{GPGME_KEYLIST_MODE_EXTERN} symbol specifies that an external
1298 source should be should be searched for keys in the keylisting
1299 operation.  The type of external source is dependant on the crypto
1300 engine used.  For example, it can be a remote keyserver or LDAP
1301 certificate server.
1302 @end table
1303
1304 At least one of @code{GPGME_KEYLIST_MODE_LOCAL} and
1305 @code{GPGME_KEYLIST_MODE_EXTERN} must be specified.  For future binary
1306 compatibility, you should get the current mode with
1307 @code{gpgme_get_keylist_mode} and modify it by setting or clearing the
1308 appropriate bits, and then using that calulcated value in the
1309 @code{gpgme_set_keylisting_mode} operation.  This will leave all other
1310 bits in the mode value intact (in particular those that are not used
1311 in the current version of the library).
1312
1313 The function returns @code{GPGME_No_Error} if the mode could be set
1314 correctly, and @code{GPGME_Invalid_Value} if @var{ctx} is not a valid
1315 pointer or @var{mode} is not a valid mode.
1316 @end deftypefun
1317
1318
1319 @deftypefun int gpgme_get_keylist_mode (@w{GpgmeCtx @var{ctx}})
1320 The function @code{gpgme_get_keylist_mode} returns the current key
1321 listing mode of the context @var{ctx}.  This value can then be
1322 modified and used in a subsequent @code{gpgme_set_keylist_mode}
1323 operation to only affect the desired bits (and leave all others
1324 intact).
1325
1326 The function returns 0 if @var{ctx} is not a valid pointer, and the
1327 current mode otherwise.  Note that 0 is not a valid mode value.
1328 @end deftypefun
1329
1330
1331 @node Passphrase Callback
1332 @subsection Passphrase Callback
1333 @cindex callback, passphrase
1334 @cindex passphrase callback
1335
1336 @deftp {Data type} {const char *(*GpgmePassphraseCb)(void *@var{hook}, const char *@var{desc}, void **@var{r_hd})}
1337 @tindex GpgmePassphraseCb
1338 The @code{GpgmePassphraseCb} type is the type of functions usable as
1339 passphrase callback function.
1340
1341 The string @var{desc} contains a text usable to be displayed to the
1342 user of the application.  The function should return a passphrase for
1343 the context when invoked with @var{desc} not being @code{NULL}.
1344
1345 The user may store information about the resources associated with the
1346 returned passphrase in @var{*r_hd}.  When the passphrase is no longer
1347 needed by @acronym{GPGME}, the passphrase callback function will be
1348 called with @var{desc} being @var{NULL}, and @var{r_hd} being the same
1349 as at the first invocation.
1350 @end deftp
1351
1352 @deftypefun void gpgme_set_passphrase_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmePassphraseCb @var{passfunc}}, @w{void *@var{hook_value}})
1353 The function @code{gpgme_set_passphrase_cb} sets the function that is
1354 used when a passphrase needs to be provided by the user to
1355 @var{passfunc}.  The function @var{passfunc} needs to implemented by
1356 the user, and whenever it is called, it is called with its first
1357 argument being @var{hook_value}.  By default, no passphrase callback
1358 function is set.
1359
1360 Not all crypto engines require this callback to retrieve the
1361 passphrase.  It is better if the engine retrieves the passphrase from
1362 a trusted agent (a daemon process), rather than having each user to
1363 implement their own passphrase query.
1364
1365 The user can disable the use of a passphrase callback function by
1366 calling @code{gpgme_set_passphrase_cb} with @var{passfunc} being
1367 @code{NULL}.
1368 @end deftypefun
1369
1370 @deftypefun void gpgme_get_passphrase_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmePassphraseCb *@var{passfunc}}, @w{void **@var{hook_value}})
1371 The function @code{gpgme_get_passphrase_cb} returns the function that
1372 is used when a passphrase needs to be provided by the user in
1373 @var{*passfunc}, and the first argument for this function in
1374 @var{*hook_value}.  If no passphrase callback is set, or @var{ctx} is
1375 not a valid pointer, @code{NULL} is returned in both variables.
1376
1377 @var{passfunc} or @var{hook_value} can be @code{NULL}.  In this case,
1378 the corresponding value will not be returned.
1379 @end deftypefun
1380
1381
1382 @node Progress Meter Callback
1383 @subsection Progress Meter Callback
1384 @cindex callback, progress meter
1385 @cindex progress meter callback
1386
1387 @deftp {Data type} {const char *(*GpgmeProgressCb)(void *@var{hook}, const char *@var{what}, int @var{type}, int @var{current}, int @var{total})}
1388 @tindex GpgmeProgressCb
1389 The @code{GpgmeProgressCb} type is the type of functions usable as
1390 progress callback function.
1391
1392 The arguments are specific to the crypto engine.  More information
1393 about the progress information returned from the GnuPG engine can be
1394 found in the GnuPG source code in the file @file{doc/DETAILS} in the
1395 section PROGRESS.
1396 @end deftp
1397
1398 @deftypefun void gpgme_set_progress_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProgressCb @var{progfunc}}, @w{void *@var{hook_value}})
1399 The function @code{gpgme_set_progress_cb} sets the function that is
1400 used when progress information about a cryptographic operation is
1401 available.  The function @var{progfunc} needs to implemented by the
1402 user, and whenever it is called, it is called with its first argument
1403 being @var{hook_value}.  By default, no progress callback function
1404 is set.
1405
1406 Setting a callback function allows an interactive program to display
1407 progress information about a long operation to the user.
1408
1409 The user can disable the use of a progress callback function by
1410 calling @code{gpgme_set_progress_cb} with @var{progfunc} being
1411 @code{NULL}.
1412 @end deftypefun
1413
1414 @deftypefun void gpgme_get_progress_cb (@w{GpgmeCtx @var{ctx}}, @w{GpgmeProgressCb *@var{progfunc}}, @w{void **@var{hook_value}})
1415 The function @code{gpgme_get_progress_cb} returns the function that is
1416 used to inform the user about the progress made in @var{*progfunc},
1417 and the first argument for this function in @var{*hook_value}.  If no
1418 progress callback is set, or @var{ctx} is not a valid pointer,
1419 @code{NULL} is returned in both variables.
1420
1421 @var{progfunc} or @var{hook_value} can be @code{NULL}.  In this case,
1422 the corresponding value will not be returned.
1423 @end deftypefun
1424
1425
1426 @node Key Management
1427 @section Key Management
1428 @cindex key management
1429
1430 Some of the cryptographic operations require that recipients or
1431 signers are specified.  This is always done by specifying the
1432 respective keys that should be used for the operation.  The following
1433 section describes how such keys can be selected and manipulated.
1434
1435 @deftp {Data type} GpgmeKey
1436 The @code{GpgmeKey} type is a handle for a public or secret key, and
1437 is used to select the key for operations involving it.
1438
1439 A key can contain several user IDs and sub keys.
1440 @end deftp
1441
1442 @menu
1443 * Listing Keys::                  Browsing the list of available keys.
1444 * Information About Keys::        Requesting detailed information about keys.
1445 * Manipulating Keys::             Operations on keys.
1446 * Generating Keys::               Creating new key pairs.
1447 * Exporting Keys::                Retrieving key data from the key ring.
1448 * Importing Keys::                Adding keys to the key ring.
1449 * Deleting Keys::                 Removing keys from the key ring.
1450 @end menu
1451
1452
1453 @node Listing Keys
1454 @subsection Listing Keys
1455 @cindex listing keys
1456 @cindex key listing
1457 @cindex key listing, start
1458 @cindex key ring, list
1459 @cindex key ring, search
1460
1461 @deftypefun GpgmeError gpgme_op_keylist_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}}, @w{int @var{secret_only}})
1462 The function @code{gpgme_op_keylist_start} initiates a key listing
1463 operation inside the context @var{ctx}.  It sets everything up so that
1464 subsequent invocations of @code{gpgme_op_keylist_next} return the keys
1465 in the list.
1466
1467 If @var{pattern} is @code{NULL}, all available keys are returned.
1468 Otherwise, @var{pattern} contains an engine specific expression that
1469 is used to limit the list to all keys matching the pattern.
1470
1471 If @var{secret_only} is not @code{0}, the list is restricted to secret
1472 keys only.
1473
1474 The context will be busy until either all keys are received (and
1475 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}), or
1476 @code{gpgme_op_keylist_end} is called to finish the operation.
1477
1478 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1479 valid pointer, and passes through any errors that are reported by the
1480 crypto engine support routines.
1481 @end deftypefun
1482
1483 @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}})
1484 The function @code{gpgme_op_keylist_ext_start} initiates an extended
1485 key listing operation inside the context @var{ctx}.  It sets
1486 everything up so that subsequent invocations of
1487 @code{gpgme_op_keylist_next} return the keys in the list.
1488
1489 If @var{pattern} or @var{*pattern} is @code{NULL}, all available keys
1490 are returned.  Otherwise, @var{pattern} is a @code{NULL} terminated
1491 array of strings that are used to limit the list to all keys matching
1492 at least one of the patterns verbatim.
1493
1494 If @var{secret_only} is not @code{0}, the list is restricted to secret
1495 keys only.
1496
1497 The value of @var{reserved} must be @code{0}.
1498
1499 The context will be busy until either all keys are received (and
1500 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}), or
1501 @code{gpgme_op_keylist_end} is called to finish the operation.
1502
1503 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1504 valid pointer, and passes through any errors that are reported by the
1505 crypto engine support routines.
1506 @end deftypefun
1507
1508 @deftypefun GpgmeError gpgme_op_keylist_next (@w{GpgmeCtx @var{ctx}}, @w{GpgmeKey *@var{r_key}})
1509 The function @code{gpgme_op_keylist_next} returns the next key in the
1510 list created by a previous @code{gpgme_op_keylist_start} operation in
1511 the context @var{ctx}.  The key will have one reference for the user.
1512 @xref{Manipulating Keys}.
1513
1514 This is the only way to get at @code{GpgmeKey} objects in
1515 @acronym{GPGME}.
1516
1517 If the last key in the list has already been returned,
1518 @code{gpgme_op_keylist_next} returns @code{GPGME_EOF}.
1519
1520 The function returns @code{GPGME_Invalid_Value} if @var{ctx} or
1521 @var{r_key} is not a valid pointer, @code{GPGME_No_Request} if there
1522 is no pending operation, @code{GPGME_Out_Of_Core} if there is not
1523 enough memory for the operation.
1524 @end deftypefun
1525
1526 @deftypefun GpgmeError gpgme_op_keylist_end (@w{GpgmeCtx @var{ctx}})
1527 The function @code{gpgme_op_keylist_next} ends a pending key list
1528 operation in the context @var{ctx}.
1529
1530 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1531 valid pointer, @code{GPGME_No_Request} if there is no pending
1532 operation, @code{GPGME_Out_Of_Core} if at some time during the
1533 operation there was not enough memory available.
1534 @end deftypefun
1535
1536 The following example illustrates how all keys containing a certain
1537 string (@code{g10code}) can be listed with their key ID and the name
1538 and e-mail address of the main user ID:
1539
1540 @example
1541 GpgmeCtx ctx;
1542 GpgmeError err = gpgme_new (&ctx);
1543
1544 if (!err)
1545   @{
1546     err = gpgme_op_keylist_start (ctx, "g10code", 0);
1547     while (!err && (err = gpgme_op_keylist_next (ctx, &key)) != GPGME_EOF)
1548       @{
1549         printf ("%s: %s <%s>\n",
1550                 gpgme_key_get_string_attr (key, GPGME_ATTR_KEYID, 0, 0),
1551                 gpgme_key_get_string_attr (key, GPGME_ATTR_NAME, 0, 0),
1552                 gpgme_key_get_string_attr (key, GPGME_ATTR_EMAIL, 0, 0));
1553         gpgme_key_release (key);
1554       @}
1555     gpgme_release (ctx);
1556   @}
1557 if (err)
1558   @{
1559     fprintf (stderr, "%s: can not list keys: %s\n",
1560              argv[0], gpgme_strerror (err));
1561     exit (1);
1562   @}
1563 @end example
1564
1565
1566 @node Information About Keys
1567 @subsection Information About Keys
1568 @cindex key, information about
1569 @cindex key, attributes
1570 @cindex attributes, of a key
1571
1572 @deftypefun {char *} gpgme_key_get_as_xml (@w{GpgmeKey @var{key}})
1573 The function @code{gpgme_key_get_as_xml} returns a string in
1574 @acronym{XML} format describing the key @var{key}.  The user has to
1575 release the string with @code{free}.
1576
1577 The function returns @code{NULL} if @var{key} is not a valid pointer,
1578 or there is not enough memory available.
1579 @end deftypefun
1580
1581 @deftp {Data type} GpgmeAttr
1582 The @code{GpgmeAttr} type is used to specify a key or trust item
1583 attribute.  The following attributes are defined:
1584
1585 @table @code
1586 @item GPGME_ATTR_KEYID
1587 This is the key ID of a sub key.  It is representable as a string.
1588
1589 For trust items, the trust item refers to the key with this ID.
1590
1591 @item GPGME_ATTR_FPR
1592 This is the fingerprint of a sub key.  It is representable as a
1593 string.
1594
1595 @item GPGME_ATTR_ALGO
1596 This is the crypto algorithm for which the sub key can be used.  It
1597 is representable as a string and as a number.  The numbers correspond
1598 to the @code{enum gcry_pk_algos} values in the gcrypt library.
1599
1600 @item GPGME_ATTR_LEN
1601 This is the key length of a sub key.  It is representable as a
1602 number.
1603
1604 @item GPGME_ATTR_CREATED
1605 This is the timestamp at creation time of a sub key.  It is
1606 representable as a number.
1607
1608 @item GPGME_ATTR_EXPIRE
1609 This is the expiration time of a sub key.  It is representable as a
1610 number.
1611
1612 @item GPGME_ATTR_OTRUST
1613 XXX FIXME  (also for trust items)
1614
1615 @item GPGME_ATTR_USERID
1616 This is a user ID.  There can be more than one user IDs in a
1617 @var{GpgmeKey} object.  The first one (with index 0) is the primary
1618 user ID.  The user ID is representable as a number.
1619
1620 For trust items, this is the user ID associated with this trust item.
1621
1622 @item GPGME_ATTR_NAME
1623 This is the name belonging to a user ID.  It is representable as a string.
1624
1625 @item GPGME_ATTR_EMAIL
1626 This is the email address belonging to a user ID.  It is representable
1627 as a string.
1628
1629 @item GPGME_ATTR_COMMENT
1630 This is the comment belonging to a user ID.  It is representable as a
1631 string.
1632
1633 @item GPGME_ATTR_VALIDITY
1634 This is the validity belonging to a user ID.  It is representable as a
1635 string and as a number.  See below for a list of available validities.
1636
1637 For trust items, this is the validity that is associated with this
1638 trust item.
1639
1640 @item GPGME_ATTR_UID_REVOKED
1641 This specifies if a user ID is revoked.  It is representable as a
1642 number, and is @code{1} if the user ID is revoked, and @code{0}
1643 otherwise.
1644
1645 @item GPGME_ATTR_UID_INVALID
1646 This specifies if a user ID is invalid.  It is representable as a
1647 number, and is @code{1} if the user ID is invalid, and @code{0}
1648 otherwise.
1649
1650 @item GPGME_ATTR_LEVEL
1651 This is the trust level of a trust item.
1652
1653 @item GPGME_ATTR_TYPE
1654 This is the type of a trust item.
1655
1656 @item GPGME_ATTR_IS_SECRET
1657 This specifies if the key is a secret key.  It is representable as a
1658 string or a number.  If the key is a secret key, the representation is
1659 ``1'' or @code{1}, otherwise it is @code{NULL} or @code{0}.
1660
1661 @item GPGME_ATTR_KEY_REVOKED
1662 This specifies if a sub key is revoked.  It is representable as a
1663 number, and is @code{1} if the key is revoked, and @code{0} otherwise.
1664
1665 @item GPGME_ATTR_KEY_INVALID
1666 This specifies if a sub key is invalid.  It is representable as a
1667 number, and is @code{1} if the key is invalid, and @code{0} otherwise.
1668
1669 @item GPGME_ATTR_KEY_EXPIRED
1670 This specifies if a sub key is expired.  It is representable as a
1671 number, and is @code{1} if the key is expired, and @code{0} otherwise.
1672
1673 @item GPGME_ATTR_KEY_DISABLED
1674 This specifies if a sub key is disabled.  It is representable as a
1675 number, and is @code{1} if the key is disabled, and @code{0} otherwise.
1676
1677 @item GPGME_ATTR_KEY_CAPS
1678 This is a description of the capabilities of a sub key.  It is
1679 representable as a string.  The string contains the letter ``e'' if
1680 the key can be used for encryption, ``s'' if the key can be used for
1681 signatures, and ``c'' if the key can be used for certifications.
1682
1683 @item GPGME_ATTR_CAN_ENCRYPT
1684 This specifies if a sub key can be used for encryption.  It is
1685 representable as a number, and is @code{1} if the sub key can be used
1686 for encryption, and @code{0} otherwise.
1687
1688 @item GPGME_ATTR_CAN_SIGN
1689 This specifies if a sub key can be used for signatures.  It is
1690 representable as a number, and is @code{1} if the sub key can be used
1691 for signatures, and @code{0} otherwise.
1692
1693 @item GPGME_ATTR_CAN_CERTIFY
1694 This specifies if a sub key can be used for certifications.  It is
1695 representable as a number, and is @code{1} if the sub key can be used
1696 for certifications, and @code{0} otherwise.
1697 @end table
1698 @end deftp
1699
1700 @deftp {Data type} GpgmeValidity
1701 The @code{GpgmeValidity} type is used to specify the validity of a user ID
1702 in a key.  The following validities are defined:
1703
1704 @table @code
1705 @item GPGME_VALIDITY_UNKNOWN
1706 The user ID is of unknown validity.  The string representation of this
1707 validity is ``?''.
1708
1709 @item GPGME_VALIDITY_UNDEFINED
1710 The validity of the user ID is undefined.  The string representation of this
1711 validity is ``q''.
1712
1713 @item GPGME_VALIDITY_NEVER
1714 The user ID is never valid.  The string representation of this
1715 validity is ``n''.
1716
1717 @item GPGME_VALIDITY_MARGINAL
1718 The user ID is marginally valid.  The string representation of this
1719 validity is ``m''.
1720
1721 @item GPGME_VALIDITY_FULL
1722 The user ID is fully valid.  The string representation of this
1723 validity is ``f''.
1724
1725 @item GPGME_VALIDITY_ULTIMATE
1726 The user ID is ultimately valid.  The string representation of this
1727 validity is ``u''.
1728 @end table
1729 @end deftp
1730
1731 @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}})
1732 The function @code{gpgme_key_get_string_attr} returns the value of the
1733 string-representable attribute @var{what} of key @var{key}.  If the
1734 attribute occurs more than once in the key, the index is specified by
1735 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1736 argument @var{reserved} is reserved for later use and should be
1737 @code{NULL}.
1738
1739 The string returned is only valid as long as the key is valid.
1740
1741 The function returns @code{0} if an attribute can't be returned as a
1742 string, @var{key} is not a valid pointer, @var{idx} out of range,
1743 or @var{reserved} not @code{NULL}.
1744 @end deftypefun
1745
1746 @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}})
1747 The function @code{gpgme_key_get_ulong_attr} returns the value of the
1748 number-representable attribute @var{what} of key @var{key}.  If the
1749 attribute occurs more than once in the key, the index is specified by
1750 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1751 argument @var{reserved} is reserved for later use and should be
1752 @code{NULL}.
1753
1754 The function returns @code{0} if the attribute can't be returned as a
1755 number, @var{key} is not a valid pointer, @var{idx} out of range,
1756 or @var{reserved} not @code{NULL}.
1757 @end deftypefun
1758
1759
1760 @node Manipulating Keys
1761 @subsection Manipulating Keys
1762 @cindex key, manipulation
1763
1764 @deftypefun void gpgme_key_ref (@w{GpgmeKey @var{key}})
1765 The function @code{gpgme_key_ref} acquires an additional reference for
1766 the key @var{key}.
1767 @end deftypefun
1768
1769 @deftypefun void gpgme_key_unref (@w{GpgmeKey @var{key}})
1770 @deftypefunx void gpgme_key_release (@w{GpgmeKey @var{key}})
1771 The function @code{gpgme_key_ref} releases a reference for the key
1772 @var{key}.  If this was the last reference, the key will be destroyed
1773 and all resources associated to it will be released.
1774
1775 The function @code{gpgme_key_release} is an alias for
1776 @code{gpgme_key_unref}.
1777 @end deftypefun
1778
1779
1780 @node Generating Keys
1781 @subsection Generating Keys
1782 @cindex key, creation
1783 @cindex key ring, add
1784
1785 @deftypefun GpgmeError gpgme_op_genkey (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1786 The function @code{gpgme_op_genkey} generates a new key pair in the
1787 context @var{ctx} and puts it into the standard key ring if both
1788 @var{pubkey} and @var{seckey} are @code{NULL}.  In this case the
1789 function returns immediately after starting the operation, and does
1790 not wait for it to complete.  If @var{pubkey} is not @code{NULL} it
1791 should be the handle for an empty (newly created) data object, and
1792 upon successful completion the data object will contain the public
1793 key.  If @var{seckey} is not @code{NULL} it should be the handle for
1794 an empty (newly created) data object, and upon successful completion
1795 the data object will contain the secret key.
1796
1797 Note that not all crypto engines support this interface equally.
1798 GnuPG does not support @var{pubkey} and @var{subkey}, they should be
1799 both @code{NULL}, and the key pair will be added to the standard key
1800 ring.  GpgSM does only support @var{pubkey}, the secret key will be
1801 stored by @command{gpg-agent}.  GpgSM expects @var{pubkey} being not
1802 @code{NULL}.
1803
1804 The argument @var{parms} specifies parameters for the key in an XML
1805 string.  The details about the format of @var{parms} are specific to
1806 the crypto engine used by @var{ctx}.  Here is an example for GnuPG as
1807 the crypto engine:
1808
1809 @example
1810 <GnupgKeyParms format="internal">
1811 Key-Type: DSA
1812 Key-Length: 1024
1813 Subkey-Type: ELG-E
1814 Subkey-Length: 1024
1815 Name-Real: Joe Tester
1816 Name-Comment: with stupid passphrase
1817 Name-Email: joe@@foo.bar
1818 Expire-Date: 0
1819 Passphrase: abc
1820 </GnupgKeyParms>
1821 @end example
1822
1823 Here is an example for GpgSM as the crypto engine:
1824 @example
1825 <GnupgKeyParms format="internal">
1826 Key-Type: RSA
1827 Key-Length: 1024
1828 Name-DN: C=de,O=g10 code,OU=Testlab,CN=Joe 2 Tester
1829 Name-Email: joe@@foo.bar
1830 </GnupgKeyParms>
1831 @end example
1832
1833 Strings should be given in UTF-8 encoding.  The only format supported
1834 for now is ``internal''.  The content of the @code{GnupgKeyParms}
1835 container is passed verbatim to GnuPG.  Control statements are not
1836 allowed.
1837
1838 The function returns @code{GPGME_No_Error} if the operation could be
1839 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1840 a valid XML string, @code{GPGME_Not_Supported} if @var{pubkey} or
1841 @var{seckey} is not valid, and @code{GPGME_General_Error} if no key
1842 was created by the backend.
1843 @end deftypefun
1844
1845 @deftypefun GpgmeError gpgme_op_genkey_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1846 The function @code{gpgme_op_genkey_start} initiates a
1847 @code{gpgme_op_genkey} operation.  It can be completed by calling
1848 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1849
1850 The function returns @code{GPGME_No_Error} if the operation could be
1851 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1852 a valid XML string, and @code{GPGME_Not_Supported} if @var{pubkey} or
1853 @var{seckey} is not @code{NULL}.
1854 @end deftypefun
1855
1856
1857 @node Exporting Keys
1858 @subsection Exporting Keys
1859 @cindex key, export
1860 @cindex key ring, export from
1861
1862 @deftypefun GpgmeError gpgme_op_export (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1863 The function @code{gpgme_op_export} extracts the public keys of the
1864 user IDs in @var{recipients} and returns them in the data buffer
1865 @var{keydata}.  The type of the public keys returned is determined by
1866 the @acronym{ASCII} armor attribute set for the context @var{ctx}.
1867
1868 The function returns @code{GPGME_No_Error} if the operation completed
1869 successfully, @code{GPGME_Invalid_Value} if @var{recipients} is
1870 @code{NULL} or @var{keydata} is not a valid empty data buffer, and
1871 passes through any errors that are reported by the crypto engine
1872 support routines.
1873 @end deftypefun
1874
1875 @deftypefun GpgmeError gpgme_op_export_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1876 The function @code{gpgme_op_export_start} initiates a
1877 @code{gpgme_op_export} operation.  It can be completed by calling
1878 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1879
1880 The function returns @code{GPGME_No_Error} if the operation could be
1881 started successfully, and @code{GPGME_Invalid_Value} if
1882 @var{recipients} is @code{NULL} or @var{keydata} is not a valid empty
1883 data buffer.
1884 @end deftypefun
1885
1886
1887 @node Importing Keys
1888 @subsection Importing Keys
1889 @cindex key, import
1890 @cindex key ring, import to
1891
1892 @deftypefun GpgmeError gpgme_op_import (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1893 The function @code{gpgme_op_import} adds the keys in the data buffer
1894 @var{keydata} to the key ring of the crypto engine used by @var{ctx}.
1895 The format of @var{keydata} can be @var{ASCII} armored, for example,
1896 but the details are specific to the crypto engine.
1897
1898 More information about the import is available with
1899 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
1900
1901 The function returns @code{GPGME_No_Error} if the import was completed
1902 successfully, @code{GPGME_Invalid_Value} if @var{keydata} if @var{ctx}
1903 or @var{keydata} is not a valid pointer, and @code{GPGME_No_Data} if
1904 @var{keydata} is an empty data buffer.
1905 @end deftypefun
1906
1907 @deftypefun GpgmeError gpgme_op_import_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1908 The function @code{gpgme_op_import_start} initiates a
1909 @code{gpgme_op_import} operation.  It can be completed by calling
1910 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1911
1912 The function returns @code{GPGME_No_Error} if the import could be
1913 started successfully, @code{GPGME_Invalid_Value} if @var{keydata} if
1914 @var{ctx} or @var{keydata} is not a valid pointer, and
1915 @code{GPGME_No_Data} if @var{keydata} is an empty data buffer.
1916 @end deftypefun
1917
1918
1919 @node Deleting Keys
1920 @subsection Deleting Keys
1921 @cindex key, delete
1922 @cindex key ring, delete from
1923
1924 @deftypefun GpgmeError gpgme_op_delete (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1925 The function @code{gpgme_op_delete} deletes the key @var{key} from the
1926 key ring of the crypto engine used by @var{ctx}.  If
1927 @var{allow_secret} is @code{0}, only public keys are deleted,
1928 otherwise secret keys are deleted as well.
1929
1930 The function returns @code{GPGME_No_Error} if the key was deleted
1931 successfully, @code{GPGME_Invalid_Value} if @var{ctx} or @var{key} is
1932 not a valid pointer, @code{GPGME_Invalid_Key} if @var{key} could not
1933 be found in the keyring, and @code{GPGME_Conflict} if the secret key
1934 for @var{key} is available, but @var{allow_secret} is zero.
1935 @end deftypefun
1936
1937 @deftypefun GpgmeError gpgme_op_delete_start (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1938 The function @code{gpgme_op_delete_start} initiates a
1939 @code{gpgme_op_delete} operation.  It can be completed by calling
1940 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1941
1942 The function returns @code{GPGME_No_Error} if the operation was
1943 started successfully, and @code{GPGME_Invalid_Value} if @var{ctx} or
1944 @var{key} is not a valid pointer.
1945 @end deftypefun
1946
1947
1948 @node Trust Item Management
1949 @section Trust Item Management
1950 @cindex trust item
1951
1952 @strong{Caution:} The trust items interface is experimental.
1953
1954 @deftp {Data type} GpgmeTrustItem
1955 The @code{GpgmeTrustItem} type is a handle for a trust item.
1956 @end deftp
1957
1958 @menu
1959 * Listing Trust Items::           Browsing the list of available trust items.
1960 * Information About Trust Items:: Requesting detailed information about trust items.
1961 * Manipulating Trust Items::      Operations on trust items.
1962 @end menu
1963
1964
1965 @node Listing Trust Items
1966 @subsection Listing Trust Items
1967 @cindex trust item list
1968
1969 @deftypefun GpgmeError gpgme_op_trustlist_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}}, @w{int @var{max_level}})
1970 The function @code{gpgme_op_trustlist_start} initiates a trust item
1971 listing operation inside the context @var{ctx}.  It sets everything up
1972 so that subsequent invocations of @code{gpgme_op_trustlist_next} return
1973 the trust items in the list.
1974
1975 The string @var{pattern} contains an engine specific expression that
1976 is used to limit the list to all trust items matching the pattern.  It
1977 can not be the empty string.
1978
1979 The argument @var{max_level} is currently ignored.
1980
1981 The context will be busy until either all trust items are received
1982 (and @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}), or
1983 @code{gpgme_op_trustlist_end} is called to finish the operation.
1984
1985 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1986 valid pointer, and passes through any errors that are reported by the
1987 crypto engine support routines.
1988 @end deftypefun
1989
1990 @deftypefun GpgmeError gpgme_op_trustlist_next (@w{GpgmeCtx @var{ctx}}, @w{GpgmeTrustItem *@var{r_item}})
1991 The function @code{gpgme_op_trustlist_next} returns the next trust
1992 item in the list created by a previous @code{gpgme_op_trustlist_start}
1993 operation in the context @var{ctx}.  The trust item can be destroyed
1994 with @code{gpgme_trust_item_release}.  @xref{Manipulating Trust Items}.
1995
1996 This is the only way to get at @code{GpgmeTrustItem} objects in
1997 @acronym{GPGME}.
1998
1999 If the last trust item in the list has already been returned,
2000 @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}.
2001
2002 The function returns @code{GPGME_Invalid_Value} if @var{ctx} or
2003 @var{r_item} is not a valid pointer, @code{GPGME_No_Request} if there
2004 is no pending operation, @code{GPGME_Out_Of_Core} if there is not
2005 enough memory for the operation.
2006 @end deftypefun
2007
2008 @deftypefun GpgmeError gpgme_op_trustlist_end (@w{GpgmeCtx @var{ctx}})
2009 The function @code{gpgme_op_trustlist_next} ends a pending key list
2010 operation in the context @var{ctx}.
2011
2012 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
2013 valid pointer, @code{GPGME_No_Request} if there is no pending
2014 operation, @code{GPGME_Out_Of_Core} if at some time during the
2015 operation there was not enough memory available.
2016 @end deftypefun
2017
2018
2019 @node Information About Trust Items
2020 @subsection Information About Trust Items
2021 @cindex trust item, information about
2022 @cindex trust item, attributes
2023 @cindex attributes, of a trust item
2024
2025 Trust items have attributes which can be queried using the interfaces
2026 below.  The attribute identifiers are shared with those for key
2027 attributes.  @xref{Information About Keys}.
2028
2029 @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}})
2030 The function @code{gpgme_trust_item_get_string_attr} returns the value
2031 of the string-representable attribute @var{what} of trust item
2032 @var{item}.  If the attribute occurs more than once in the trust
2033 items, the index is specified by @var{idx}.  However, currently no
2034 such attributes exists, so @var{idx} should be @code{0}.  The argument
2035 @var{reserved} is reserved for later use and should be @code{NULL}.
2036
2037 The string returned is only valid as long as the key is valid.
2038
2039 The function returns @code{0} if an attribute can't be returned as a
2040 string, @var{key} is not a valid pointer, @var{idx} out of range,
2041 or @var{reserved} not @code{NULL}.
2042 @end deftypefun
2043
2044 @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}})
2045 The function @code{gpgme_trust_item_get_int_attr} returns the value of
2046 the number-representable attribute @var{what} of trust item
2047 @var{item}.  If the attribute occurs more than once in the trust item,
2048 the index is specified by @var{idx}.  However, currently no such
2049 attribute exists, so @var{idx} should be @code{0}.  The argument
2050 @var{reserved} is reserved for later use and should be @code{NULL}.
2051
2052 The function returns @code{0} if the attribute can't be returned as a
2053 number, @var{key} is not a valid pointer, @var{idx} out of range,
2054 or @var{reserved} not @code{NULL}.
2055 @end deftypefun
2056
2057
2058 @node Manipulating Trust Items
2059 @subsection Manipulating Trust Items
2060 @cindex trust item, manipulation
2061
2062 @deftypefun void gpgme_trust_item_release (@w{GpgmeTrustItem @var{item}})
2063 The function @code{gpgme_trust_item_release} destroys a
2064 @code{GpgmeTrustItem} object and releases all associated resources.
2065 @end deftypefun
2066
2067 @node Crypto Operations
2068 @section Crypto Operations
2069 @cindex cryptographic operation
2070
2071 @menu
2072 * Decrypt::                       Decrypting a ciphertext.
2073 * Verify::                        Verifying a signature.
2074 * Decrypt and Verify::            Decrypting a signed ciphertext.
2075 * Sign::                          Creating a signature.
2076 * Encrypt::                       Encrypting a plaintext.
2077 * Detailed Results::              How to obtain more info about the operation.
2078 @end menu
2079
2080
2081 @node Decrypt
2082 @subsection Decrypt
2083 @cindex decryption
2084 @cindex cryptographic operation, decryption
2085
2086 @deftypefun GpgmeError gpgme_op_decrypt (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2087 The function @code{gpgme_op_decrypt} decrypts the ciphertext in the
2088 data object @var{cipher} and stores it into the data object
2089 @var{plain}.
2090
2091 The function returns @code{GPGME_No_Error} if the ciphertext could be
2092 decrypted successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2093 @var{cipher} or @var{plain} is not a valid pointer,
2094 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2095 decrypt, @code{GPGME_Decryption_Failed} if @var{cipher} is not a valid
2096 cipher text, @code{GPGME_No_Passphrase} if the passphrase for the
2097 secret key could not be retrieved, and passes through any errors that
2098 are reported by the crypto engine support routines.
2099 @end deftypefun
2100
2101 @deftypefun GpgmeError gpgme_op_decrypt_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2102 The function @code{gpgme_op_decrypt_start} initiates a
2103 @code{gpgme_op_decrypt} operation.  It can be completed by calling
2104 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2105
2106 The function returns @code{GPGME_No_Error} if the operation could be
2107 started successfully, and @code{GPGME_Invalid_Value} if @var{cipher}
2108 or @var{plain} is not a valid pointer.
2109 @end deftypefun
2110
2111
2112 @node Verify
2113 @subsection Verify
2114 @cindex verification
2115 @cindex signature, verification
2116 @cindex cryptographic operation, verification
2117 @cindex cryptographic operation, signature check
2118 @cindex signature, status
2119
2120 @deftp {Data type} {enum GpgmeSigStat}
2121 @tindex GpgmeSigStat
2122 The @code{GpgmeSigStat} type holds the result of a signature check, or
2123 the combined result of all signatures.  The following results are
2124 possible:
2125
2126 @table @code
2127 @item GPGME_SIG_STAT_NONE
2128 This status should not occur in normal operation.
2129
2130 @item GPGME_SIG_STAT_GOOD
2131 This status indicates that the signature is valid.  For the combined
2132 result this status means that all signatures are valid.
2133
2134 @item GPGME_SIG_STAT_GOOD_EXP
2135 This status indicates that the signature is valid but expired.  For
2136 the combined result this status means that all signatures are valid
2137 and expired.
2138
2139 @item GPGME_SIG_STAT_GOOD_EXPKEY
2140 This status indicates that the signature is valid but the key used to
2141 verify the signature has expired.  For the combined result this status
2142 means that all signatures are valid and all keys are expired.
2143
2144 @item GPGME_SIG_STAT_BAD
2145 This status indicates that the signature is invalid.  For the combined
2146 result this status means that all signatures are invalid.
2147
2148 @item GPGME_SIG_STAT_NOKEY
2149 This status indicates that the signature could not be verified due to
2150 a missing key.  For the combined result this status means that all
2151 signatures could not be checked due to missing keys.
2152
2153 @item GPGME_SIG_STAT_NOSIG
2154 This status indicates that the signature data provided was not a real
2155 signature.
2156
2157 @item GPGME_SIG_STAT_ERROR
2158 This status indicates that there was some other error which prevented
2159 the signature verification.
2160
2161 @item GPGME_SIG_STAT_DIFF
2162 For the combined result this status means that at least two signatures
2163 have a different status.  You can get each key's status with
2164 @code{gpgme_get_sig_status}.
2165 @end table
2166 @end deftp
2167
2168 @deftypefun GpgmeError gpgme_op_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}}, @w{GpgmeSigStat *@var{r_stat}})
2169 The function @code{gpgme_op_verify} verifies that the signature in the
2170 data object @var{sig} is a valid signature.  If @var{plain} is
2171 initialized with plaintext data, it is assumed that @var{sig} is a
2172 detached signature, and its validity for the plaintext given in
2173 @var{plain} is verified.  If @var{plain} is an uninitialized data
2174 object, it is assumed that @var{sig} is a normal (or cleartext)
2175 signature, and the plaintext is available in @var{plain} after
2176 successful verification.
2177
2178 The combined status of all signatures is returned in @var{r_stat}.
2179 The results of the individual signature verifications can be retrieved
2180 with @code{gpgme_get_sig_status} and @code{gpgme_get_sig_key}.
2181
2182 The function returns @code{GPGME_No_Error} if the operation could be
2183 completed successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2184 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer,
2185 @code{GPGME_No_Data} if @var{sig} does not contain any data to verify,
2186 and passes through any errors that are reported by the crypto engine
2187 support routines.
2188 @end deftypefun
2189
2190 @deftypefun GpgmeError gpgme_op_verify_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}})
2191 The function @code{gpgme_op_verify_start} initiates a
2192 @code{gpgme_op_verify} operation.  It can be completed by calling
2193 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2194
2195 The function returns @code{GPGME_No_Error} if the operation could be
2196 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2197 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer, and
2198 @code{GPGME_No_Data} if @var{sig} or @var{plain} does not contain any
2199 data to verify.
2200 @end deftypefun
2201
2202 @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}})
2203 The function @code{gpgme_get_sig_status} receives information about a
2204 signature after the @code{gpgme_op_verify} or
2205 @code{gpgme_op_verify_decrypt} operation.  A single detached signature
2206 can contain signatures by more than one key.  The @var{idx} specifies
2207 which signature's information should be retrieved, starting from
2208 @var{0}.
2209
2210 The status of the signature will be returned in @var{r_stat} if it is
2211 not @code{NULL}.  The creation time stamp of the signature will be
2212 returned in @var{r_created} if it is not @var{NULL}.
2213
2214 The function returns a statically allocated string that contains the
2215 fingerprint of the key which signed the plaintext, or @code{NULL} if
2216 @var{ctx} is not a valid pointer, the operation is still pending, or
2217 no verification could be performed.
2218 @end deftypefun
2219
2220 @deftypefun {const char *} gpgme_get_sig_string_attr (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeAttr @var{what}}, @w{int @var{reserved}})
2221 This function is similar to @code{gpgme_get_sig_status} but may be used
2222 to retrieve more detailed information.  @var{ctx} should be the context
2223 used for the last signature verification, @var{idx} is used to enumerate
2224 over all signatures starting with @code{0} and @var{reserved} should be
2225 @code{0} for now.
2226
2227 The attributes @var{what} currently supports are
2228 @code{GPGME_ATTR_FPR} to return the fingerprint of the key used to
2229 create the signature and @code{GPGME_ERRTOK} to return a token
2230 with a more detailed error description.
2231 @end deftypefun
2232
2233 @deftypefun {const char *} gpgme_get_sig_ulong_attr (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeAttr @var{waht}}, @w{int @var{reserved}})
2234 This fucntion is similar to @code{gpgme_get_sig_string_attr} but used
2235 for attributes which can be represented by an @code{unsigned long} data
2236 type.  @var{ctx} should be the context used for the last signature
2237 verification, @var{idx} is used to enumerate over all signatures
2238 starting with @code{0} and @var{reserved} should be @code{0} for now.
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