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