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 XXX FIXME
1362
1363 @item GPGME_ATTR_OTRUST
1364 XXX FIXME  (also for trust items)
1365
1366 @item GPGME_ATTR_USERID
1367 This is a user ID.  There can be more than one user IDs in a
1368 @var{GpgmeKey} object.  The first one (with index 0) is the primary
1369 user ID.  The user ID is representable as a number.
1370
1371 For trust items, this is the user ID associated with this trust item.
1372
1373 @item GPGME_ATTR_NAME
1374 This is the name belonging to a user ID.  It is representable as a string.
1375
1376 @item GPGME_ATTR_EMAIL
1377 This is the email address belonging to a user ID.  It is representable
1378 as a string.
1379
1380 @item GPGME_ATTR_COMMENT
1381 This is the comment belonging to a user ID.  It is representable as a
1382 string.
1383
1384 @item GPGME_ATTR_VALIDITY
1385 This is the validity belonging to a user ID.  It is representable as a
1386 string and as a number.  See below for a list of available validities.
1387
1388 For trust items, this is the validity that is associated with this
1389 trust item.
1390
1391 @item GPGME_ATTR_UID_REVOKED
1392 This specifies if a user ID is revoked.  It is representable as a
1393 number, and is @code{1} if the user ID is revoked, and @code{0}
1394 otherwise.
1395
1396 @item GPGME_ATTR_UID_INVALID
1397 This specifies if a user ID is invalid.  It is representable as a
1398 number, and is @code{1} if the user ID is invalid, and @code{0}
1399 otherwise.
1400
1401 @item GPGME_ATTR_LEVEL
1402 This is the trust level of a trust item.
1403
1404 @item GPGME_ATTR_TYPE
1405 This is the type of a trust item.
1406
1407 @item GPGME_ATTR_IS_SECRET
1408 This specifies if the key is a secret key.  It is representable as a
1409 string or a number.  If the key is a secret key, the representation is
1410 ``1'' or @code{1}, otherwise it is @code{NULL} or @code{0}.
1411
1412 @item GPGME_ATTR_KEY_REVOKED
1413 This specifies if a sub key is revoked.  It is representable as a
1414 number, and is @code{1} if the key is revoked, and @code{0} otherwise.
1415
1416 @item GPGME_ATTR_KEY_INVALID
1417 This specifies if a sub key is invalid.  It is representable as a
1418 number, and is @code{1} if the key is invalid, and @code{0} otherwise.
1419
1420 @item GPGME_ATTR_KEY_EXPIRED
1421 This specifies if a sub key is expired.  It is representable as a
1422 number, and is @code{1} if the key is expired, and @code{0} otherwise.
1423
1424 @item GPGME_ATTR_KEY_DISABLED
1425 This specifies if a sub key is disabled.  It is representable as a
1426 number, and is @code{1} if the key is disabled, and @code{0} otherwise.
1427
1428 @item GPGME_ATTR_KEY_CAPS
1429 This is a description of the capabilities of a sub key.  It is
1430 representable as a string.  The string contains the letter ``e'' if
1431 the key can be used for encryption, ``s'' if the key can be used for
1432 signatures, and ``c'' if the key can be used for certifications.
1433
1434 @item GPGME_ATTR_CAN_ENCRYPT
1435 This specifies if a sub key can be used for encryption.  It is
1436 representable as a number, and is @code{1} if the sub key can be used
1437 for encryption, and @code{0} otherwise.
1438
1439 @item GPGME_ATTR_CAN_SIGN
1440 This specifies if a sub key can be used for signatures.  It is
1441 representable as a number, and is @code{1} if the sub key can be used
1442 for signatures, and @code{0} otherwise.
1443
1444 @item GPGME_ATTR_CAN_CERTIFY
1445 This specifies if a sub key can be used for certifications.  It is
1446 representable as a number, and is @code{1} if the sub key can be used
1447 for certifications, and @code{0} otherwise.
1448 @end table
1449 @end deftp
1450
1451 @deftp {Data type} GpgmeValidity
1452 The @code{GpgmeValidity} type is used to specify the validity of a user ID
1453 in a key.  The following validities are defined:
1454
1455 @table @code
1456 @item GPGME_VALIDITY_UNKNOWN
1457 The user ID is of unknown validity.  The string representation of this
1458 validity is ``?''.
1459
1460 @item GPGME_VALIDITY_UNDEFINED
1461 The validity of the user ID is undefined.  The string representation of this
1462 validity is ``q''.
1463
1464 @item GPGME_VALIDITY_NEVER
1465 The user ID is never valid.  The string representation of this
1466 validity is ``n''.
1467
1468 @item GPGME_VALIDITY_MARGINAL
1469 The user ID is marginally valid.  The string representation of this
1470 validity is ``m''.
1471
1472 @item GPGME_VALIDITY_FULL
1473 The user ID is fully valid.  The string representation of this
1474 validity is ``f''.
1475
1476 @item GPGME_VALIDITY_ULTIMATE
1477 The user ID is ultimately valid.  The string representation of this
1478 validity is ``u''.
1479 @end table
1480 @end deftp
1481
1482 @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}})
1483 The function @code{gpgme_key_get_string_attr} returns the value of the
1484 string-representable attribute @var{what} of key @var{key}.  If the
1485 attribute occurs more than once in the key, the index is specified by
1486 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1487 argument @var{reserved} is reserved for later use and should be
1488 @code{NULL}.
1489
1490 The string returned is only valid as long as the key is valid.
1491
1492 The function returns @code{0} if an attribute can't be returned as a
1493 string, @var{key} is not a valid pointer, @var{idx} out of range,
1494 or @var{reserved} not @code{NULL}.
1495 @end deftypefun
1496
1497 @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}})
1498 The function @code{gpgme_key_get_ulong_attr} returns the value of the
1499 number-representable attribute @var{what} of key @var{key}.  If the
1500 attribute occurs more than once in the key, the index is specified by
1501 @var{idx}.  This applies to attributes of sub keys and user IDs.  The
1502 argument @var{reserved} is reserved for later use and should be
1503 @code{NULL}.
1504
1505 The function returns @code{0} if the attribute can't be returned as a
1506 number, @var{key} is not a valid pointer, @var{idx} out of range,
1507 or @var{reserved} not @code{NULL}.
1508 @end deftypefun
1509
1510
1511 @node Manipulating Keys
1512 @subsection Manipulating Keys
1513 @cindex key, manipulation
1514
1515 @deftypefun void gpgme_key_ref (@w{GpgmeKey @var{key}})
1516 The function @code{gpgme_key_ref} acquires an additional reference for
1517 the key @var{key}.
1518 @end deftypefun
1519
1520 @deftypefun void gpgme_key_unref (@w{GpgmeKey @var{key}})
1521 @deftypefunx void gpgme_key_release (@w{GpgmeKey @var{key}})
1522 The function @code{gpgme_key_ref} releases a reference for the key
1523 @var{key}.  If this was the last reference, the key will be destroyed
1524 and all resources associated to it will be released.
1525
1526 The function @code{gpgme_key_release} is an alias for
1527 @code{gpgme_key_unref}.
1528 @end deftypefun
1529
1530
1531 @node Generating Keys
1532 @subsection Generating Keys
1533 @cindex key, creation
1534 @cindex key ring, add
1535
1536 @deftypefun GpgmeError gpgme_op_genkey (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1537 The function @code{gpgme_op_genkey} generates a new key pair in the
1538 context @var{ctx} and puts it into the standard key ring if both
1539 @var{pubkey} and @var{seckey} are @code{NULL}.  In this case the
1540 function returns immediately after starting the operation, and does
1541 not wait for it to complete.  If @var{pubkey} is not @code{NULL} it
1542 should be the handle for an empty (newly created) data object, and
1543 upon successful completion the data object will contain the public
1544 key.  If @var{seckey} is not @code{NULL} it should be the handle for
1545 an empty (newly created) data object, and upon successful completion
1546 the data object will contain the secret key.
1547
1548 Note that not all crypto engines support this interface equally.
1549 GnuPG does not support @var{pubkey} and @var{subkey}, they should be
1550 both @code{NULL}, and the key pair will be added to the standard key
1551 ring.  GpgSM does only support @var{pubkey}, the secret key will be
1552 stored by @command{gpg-agent}.  GpgSM expects @var{pubkey} being not
1553 @code{NULL}.
1554
1555 The argument @var{parms} specifies parameters for the key in an XML
1556 string.  The details about the format of @var{parms} are specific to
1557 the crypto engine used by @var{ctx}.  Here is an example for GnuPG as
1558 the crypto engine:
1559
1560 @example
1561 <GnupgKeyParms format="internal">
1562 Key-Type: DSA
1563 Key-Length: 1024
1564 Subkey-Type: ELG-E
1565 Subkey-Length: 1024
1566 Name-Real: Joe Tester
1567 Name-Comment: with stupid passphrase
1568 Name-Email: joe@@foo.bar
1569 Expire-Date: 0
1570 Passphrase: abc
1571 </GnupgKeyParms>
1572 @end example
1573
1574 Here is an example for GpgSM as the crypto engine:
1575 @example
1576 <GnupgKeyParms format="internal">
1577 Key-Type: RSA
1578 Key-Length: 1024
1579 Name-DN: C=de,O=g10 code,OU=Testlab,CN=Joe 2 Tester
1580 Name-Email: joe@@foo.bar
1581 </GnupgKeyParms>
1582 @end example
1583
1584 Strings should be given in UTF-8 encoding.  The only format supported
1585 for now is ``internal''.  The content of the @code{GnupgKeyParms}
1586 container is passed verbatim to GnuPG.  Control statements are not
1587 allowed.
1588
1589 The function returns @code{GPGME_No_Error} if the operation could be
1590 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1591 a valid XML string, @code{GPGME_Not_Supported} if @var{pubkey} or
1592 @var{seckey} is not valid, and @code{GPGME_General_Error} if no key
1593 was created by the backend.
1594 @end deftypefun
1595
1596 @deftypefun GpgmeError gpgme_op_genkey_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{parms}}, @w{GpgmeData @var{pubkey}}, @w{GpgmeData @var{seckey}})
1597 The function @code{gpgme_op_genkey_start} initiates a
1598 @code{gpgme_op_genkey} operation.  It can be completed by calling
1599 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1600
1601 The function returns @code{GPGME_No_Error} if the operation could be
1602 started successfully, @code{GPGME_Invalid_Value} if @var{parms} is not
1603 a valid XML string, and @code{GPGME_Not_Supported} if @var{pubkey} or
1604 @var{seckey} is not @code{NULL}.
1605 @end deftypefun
1606
1607
1608 @node Exporting Keys
1609 @subsection Exporting Keys
1610 @cindex key, export
1611 @cindex key ring, export from
1612
1613 @deftypefun GpgmeError gpgme_op_export (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1614 The function @code{gpgme_op_export} extracts the public keys of the
1615 user IDs in @var{recipients} and returns them in the data buffer
1616 @var{keydata}.  The type of the public keys returned is determined by
1617 the @acronym{ASCII} armor attribute set for the context @var{ctx}.
1618
1619 The function returns @code{GPGME_No_Error} if the operation completed
1620 successfully, @code{GPGME_Invalid_Value} if @var{recipients} is
1621 @code{NULL} or @var{keydata} is not a valid empty data buffer, and
1622 passes through any errors that are reported by the crypto engine
1623 support routines.
1624 @end deftypefun
1625
1626 @deftypefun GpgmeError gpgme_op_export_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{recipients}}, @w{GpgmeData @var{keydata}})
1627 The function @code{gpgme_op_export_start} initiates a
1628 @code{gpgme_op_export} operation.  It can be completed by calling
1629 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1630
1631 The function returns @code{GPGME_No_Error} if the operation could be
1632 started successfully, and @code{GPGME_Invalid_Value} if
1633 @var{recipients} is @code{NULL} or @var{keydata} is not a valid empty
1634 data buffer.
1635 @end deftypefun
1636
1637
1638 @node Importing Keys
1639 @subsection Importing Keys
1640 @cindex key, import
1641 @cindex key ring, import to
1642
1643 @deftypefun GpgmeError gpgme_op_import (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1644 The function @code{gpgme_op_import} adds the keys in the data buffer
1645 @var{keydata} to the key ring of the crypto engine used by @var{ctx}.
1646 The format of @var{keydata} can be @var{ASCII} armored, for example,
1647 but the details are specific to the crypto engine.
1648
1649 More information about the import is available with
1650 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
1651
1652 The function returns @code{GPGME_No_Error} if the import was completed
1653 successfully, @code{GPGME_Invalid_Value} if @var{keydata} if @var{ctx}
1654 or @var{keydata} is not a valid pointer, and @code{GPGME_No_Data} if
1655 @var{keydata} is an empty data buffer.
1656 @end deftypefun
1657
1658 @deftypefun GpgmeError gpgme_op_import_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{keydata}})
1659 The function @code{gpgme_op_import_start} initiates a
1660 @code{gpgme_op_import} operation.  It can be completed by calling
1661 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1662
1663 The function returns @code{GPGME_No_Error} if the import could be
1664 started successfully, @code{GPGME_Invalid_Value} if @var{keydata} if
1665 @var{ctx} or @var{keydata} is not a valid pointer, and
1666 @code{GPGME_No_Data} if @var{keydata} is an empty data buffer.
1667 @end deftypefun
1668
1669
1670 @node Deleting Keys
1671 @subsection Deleting Keys
1672 @cindex key, delete
1673 @cindex key ring, delete from
1674
1675 @deftypefun GpgmeError gpgme_op_delete (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1676 The function @code{gpgme_op_delete} deletes the key @var{key} from the
1677 key ring of the crypto engine used by @var{ctx}.  If
1678 @var{allow_secret} is @code{0}, only public keys are deleted,
1679 otherwise secret keys are deleted as well.
1680
1681 The function returns @code{GPGME_No_Error} if the key was deleted
1682 successfully, @code{GPGME_Invalid_Value} if @var{ctx} or @var{key} is
1683 not a valid pointer, @code{GPGME_Invalid_Key} if @var{key} could not
1684 be found in the keyring, and @code{GPGME_Conflict} if the secret key
1685 for @var{key} is available, but @var{allow_secret} is zero.
1686 @end deftypefun
1687
1688 @deftypefun GpgmeError gpgme_op_delete_start (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}}, @w{int @var{allow_secret}})
1689 The function @code{gpgme_op_delete_start} initiates a
1690 @code{gpgme_op_delete} operation.  It can be completed by calling
1691 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1692
1693 The function returns @code{GPGME_No_Error} if the operation was
1694 started successfully, and @code{GPGME_Invalid_Value} if @var{ctx} or
1695 @var{key} is not a valid pointer.
1696 @end deftypefun
1697
1698
1699 @node Trust Item Management
1700 @section Trust Item Management
1701 @cindex trust item
1702
1703 @strong{Caution:} The trust items interface is experimental.
1704
1705 @deftp {Data type} GpgmeTrustItem
1706 The @code{GpgmeTrustItem} type is a handle for a trust item.
1707 @end deftp
1708
1709 @menu
1710 * Listing Trust Items::           Browsing the list of available trust items.
1711 * Information About Trust Items:: Requesting detailed information about trust items.
1712 * Manipulating Trust Items::      Operations on trust items.
1713 @end menu
1714
1715
1716 @node Listing Trust Items
1717 @subsection Listing Trust Items
1718 @cindex trust item list
1719
1720 @deftypefun GpgmeError gpgme_op_trustlist_start (@w{GpgmeCtx @var{ctx}}, @w{const char *@var{pattern}}, @w{int @var{max_level}})
1721 The function @code{gpgme_op_trustlist_start} initiates a trust item
1722 listing operation inside the context @var{ctx}.  It sets everything up
1723 so that subsequent invocations of @code{gpgme_op_trustlist_next} return
1724 the trust items in the list.
1725
1726 The string @var{pattern} contains an engine specific expression that
1727 is used to limit the list to all trust items matching the pattern.  It
1728 can not be the empty string.
1729
1730 The argument @var{max_level} is currently ignored.
1731
1732 The context will be busy until either all trust items are received
1733 (and @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}), or
1734 @code{gpgme_op_trustlist_end} is called to finish the operation.
1735
1736 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1737 valid pointer, and passes through any errors that are reported by the
1738 crypto engine support routines.
1739 @end deftypefun
1740
1741 @deftypefun GpgmeError gpgme_op_trustlist_next (@w{GpgmeCtx @var{ctx}}, @w{GpgmeTrustItem *@var{r_item}})
1742 The function @code{gpgme_op_trustlist_next} returns the next trust
1743 item in the list created by a previous @code{gpgme_op_trustlist_start}
1744 operation in the context @var{ctx}.  The trust item can be destroyed
1745 with @code{gpgme_trust_item_release}.  @xref{Manipulating Trust Items}.
1746
1747 This is the only way to get at @code{GpgmeTrustItem} objects in
1748 @acronym{GPGME}.
1749
1750 If the last trust item in the list has already been returned,
1751 @code{gpgme_op_trustlist_next} returns @code{GPGME_EOF}.
1752
1753 The function returns @code{GPGME_Invalid_Value} if @var{ctx} or
1754 @var{r_item} is not a valid pointer, @code{GPGME_No_Request} if there
1755 is no pending operation, @code{GPGME_Out_Of_Core} if there is not
1756 enough memory for the operation.
1757 @end deftypefun
1758
1759 @deftypefun GpgmeError gpgme_op_trustlist_end (@w{GpgmeCtx @var{ctx}})
1760 The function @code{gpgme_op_trustlist_next} ends a pending key list
1761 operation in the context @var{ctx}.
1762
1763 The function returns @code{GPGME_Invalid_Value} if @var{ctx} is not a
1764 valid pointer, @code{GPGME_No_Request} if there is no pending
1765 operation, @code{GPGME_Out_Of_Core} if at some time during the
1766 operation there was not enough memory available.
1767 @end deftypefun
1768
1769
1770 @node Information About Trust Items
1771 @subsection Information About Trust Items
1772 @cindex trust item, information about
1773 @cindex trust item, attributes
1774 @cindex attributes, of a trust item
1775
1776 Trust items have attributes which can be queried using the interfaces
1777 below.  The attribute identifiers are shared with those for key
1778 attributes.  @xref{Information About Keys}.
1779
1780 @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}})
1781 The function @code{gpgme_trust_item_get_string_attr} returns the value
1782 of the string-representable attribute @var{what} of trust item
1783 @var{item}.  If the attribute occurs more than once in the trust
1784 items, the index is specified by @var{idx}.  However, currently no
1785 such attributes exists, so @var{idx} should be @code{0}.  The argument
1786 @var{reserved} is reserved for later use and should be @code{NULL}.
1787
1788 The string returned is only valid as long as the key is valid.
1789
1790 The function returns @code{0} if an attribute can't be returned as a
1791 string, @var{key} is not a valid pointer, @var{idx} out of range,
1792 or @var{reserved} not @code{NULL}.
1793 @end deftypefun
1794
1795 @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}})
1796 The function @code{gpgme_trust_item_get_int_attr} returns the value of
1797 the number-representable attribute @var{what} of trust item
1798 @var{item}.  If the attribute occurs more than once in the trust item,
1799 the index is specified by @var{idx}.  However, currently no such
1800 attribute exists, so @var{idx} should be @code{0}.  The argument
1801 @var{reserved} is reserved for later use and should be @code{NULL}.
1802
1803 The function returns @code{0} if the attribute can't be returned as a
1804 number, @var{key} is not a valid pointer, @var{idx} out of range,
1805 or @var{reserved} not @code{NULL}.
1806 @end deftypefun
1807
1808
1809 @node Manipulating Trust Items
1810 @subsection Manipulating Trust Items
1811 @cindex trust item, manipulation
1812
1813 @deftypefun void gpgme_trust_item_release (@w{GpgmeTrustItem @var{item}})
1814 The function @code{gpgme_trust_item_release} destroys a
1815 @code{GpgmeTrustItem} object and releases all associated resources.
1816 @end deftypefun
1817
1818 @node Crypto Operations
1819 @section Crypto Operations
1820 @cindex cryptographic operation
1821
1822 @menu
1823 * Decrypt::                       Decrypting a ciphertext.
1824 * Verify::                        Verifying a signature.
1825 * Decrypt and Verify::            Decrypting a signed ciphertext.
1826 * Sign::                          Creating a signature.
1827 * Encrypt::                       Encrypting a plaintext.
1828 * Detailed Results::              How to obtain more info about the operation.
1829 @end menu
1830
1831
1832 @node Decrypt
1833 @subsection Decrypt
1834 @cindex decryption
1835 @cindex cryptographic operation, decryption
1836
1837 @deftypefun GpgmeError gpgme_op_decrypt (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
1838 The function @code{gpgme_op_decrypt} decrypts the ciphertext in the
1839 data object @var{cipher} and stores it into the data object
1840 @var{plain}.
1841
1842 The function returns @code{GPGME_No_Error} if the ciphertext could be
1843 decrypted successfully, @code{GPGME_Invalid_Value} if @var{ctx},
1844 @var{cipher} or @var{plain} is not a valid pointer,
1845 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
1846 decrypt, @code{GPGME_Decryption_Failed} if @var{cipher} is not a valid
1847 cipher text, @code{GPGME_No_Passphrase} if the passphrase for the
1848 secret key could not be retrieved, and passes through any errors that
1849 are reported by the crypto engine support routines.
1850 @end deftypefun
1851
1852 @deftypefun GpgmeError gpgme_op_decrypt_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
1853 The function @code{gpgme_op_decrypt_start} initiates a
1854 @code{gpgme_op_decrypt} operation.  It can be completed by calling
1855 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1856
1857 The function returns @code{GPGME_No_Error} if the operation could be
1858 started successfully, and @code{GPGME_Invalid_Value} if @var{cipher}
1859 or @var{plain} is not a valid pointer.
1860 @end deftypefun
1861
1862
1863 @node Verify
1864 @subsection Verify
1865 @cindex verification
1866 @cindex signature, verification
1867 @cindex cryptographic operation, verification
1868 @cindex cryptographic operation, signature check
1869 @cindex signature, status
1870
1871 @deftp {Data type} {enum GpgmeSigStat}
1872 @tindex GpgmeSigStat
1873 The @code{GpgmeSigStat} type holds the result of a signature check, or
1874 the combined result of all signatures.  The following results are
1875 possible:
1876
1877 @table @code
1878 @item GPGME_SIG_STAT_NONE
1879 This status should not occur in normal operation.
1880
1881 @item GPGME_SIG_STAT_GOOD
1882 This status indicates that the signature is valid.  For the combined
1883 result this status means that all signatures are valid.
1884
1885 @item GPGME_SIG_STAT_BAD
1886 This status indicates that the signature is invalid.  For the combined
1887 result this status means that all signatures are invalid.
1888
1889 @item GPGME_SIG_STAT_NOKEY
1890 This status indicates that the signature could not be verified due to
1891 a missing key.  For the combined result this status means that all
1892 signatures could not be checked due to missing keys.
1893
1894 @item GPGME_SIG_STAT_NOSIG
1895 This status indicates that the signature data provided was not a real
1896 signature.
1897
1898 @item GPGME_SIG_STAT_ERROR
1899 This status indicates that there was some other error which prevented
1900 the signature verification.
1901
1902 @item GPGME_SIG_STAT_DIFF
1903 For the combined result this status means that at least two signatures
1904 have a different status.  You can get each key's status with
1905 @code{gpgme_get_sig_status}.
1906 @end table
1907 @end deftp
1908
1909 @deftypefun GpgmeError gpgme_op_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}}, @w{GpgmeSigStat *@var{r_stat}})
1910 The function @code{gpgme_op_verify} verifies that the detached
1911 signature in the data object @var{sig} is a valid signature for the
1912 plaintext in the data object @var{plain}.
1913
1914 The combined status of all signatures is returned in @var{r_stat}.
1915 The results of the individual signature verifications can be retrieved
1916 with @code{gpgme_get_sig_status} and @code{gpgme_get_sig_key}.
1917
1918 The function returns @code{GPGME_No_Error} if the operation could be
1919 completed successfully, @code{GPGME_Invalid_Value} if @var{ctx},
1920 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer,
1921 @code{GPGME_No_Data} if @var{sig} or @var{plain} does not contain any
1922 data to verify, and passes through any errors that are reported by the
1923 crypto engine support routines.
1924 @end deftypefun
1925
1926 @deftypefun GpgmeError gpgme_op_verify_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{sig}}, @w{GpgmeData @var{plain}})
1927 The function @code{gpgme_op_verify_start} initiates a
1928 @code{gpgme_op_verify} operation.  It can be completed by calling
1929 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
1930
1931 The function returns @code{GPGME_No_Error} if the operation could be
1932 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
1933 @var{sig}, @var{plain} or @var{r_stat} is not a valid pointer, and
1934 @code{GPGME_No_Data} if @var{sig} or @var{plain} does not contain any
1935 data to verify.
1936 @end deftypefun
1937
1938 @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}})
1939 The function @code{gpgme_get_sig_status} receives information about a
1940 signature after the @code{gpgme_op_verify} or
1941 @code{gpgme_op_verify_decrypt} operation.  A single detached signature
1942 can contain signatures by more than one key.  The @var{idx} specifies
1943 which signature's information should be retrieved, starting from
1944 @var{0}.
1945
1946 The status of the signature will be returned in @var{r_stat} if it is
1947 not @code{NULL}.  The creation time stamp of the signature will be
1948 returned in @var{r_created} if it is not @var{NULL}.
1949
1950 The function returns a statically allocated string that contains the
1951 fingerprint of the key which signed the plaintext, or @code{NULL} if
1952 @var{ctx} is not a valid pointer, the operation is still pending, or
1953 no verification could be performed.
1954 @end deftypefun
1955
1956 @deftypefun {const char *} gpgme_get_sig_key (@w{GpgmeCtx @var{ctx}}, @w{int @var{idx}}, @w{GpgmeSigKey *@var{r_stat}})
1957 The function @code{gpgme_get_sig_status} receives a @code{GpgmeKey}
1958 object for the key which was used to verify the signature after the
1959 @code{gpgme_op_verify} or @code{gpgme_op_verify_decrypt} operation.  A
1960 single detached signature can contain signatures by more than one key.
1961 The @var{idx} specifies which signature's information should be
1962 retrieved, starting from @var{0}.  The key will have on reference for
1963 the user.
1964
1965 The function is a convenient way to retrieve the keys belonging to the
1966 fingerprints returned by @code{gpgme_get_sig_status}.
1967
1968 The function returns @code{GPGME_No_Error} if the key could be
1969 returned, @code{GPGME_Invalid_Value} if @var{r_key} is not a valid
1970 pointer, @code{GPGME_Invalid_Key} if the fingerprint is not valid,
1971 @code{GPGME_EOF} if @var{idx} is too large, or some other error value
1972 if a problem occurred requesting the key.
1973 @end deftypefun
1974
1975 @deftypefun {char *} gpgme_get_notation (@w{GpgmeCtx @var{ctx}})
1976 The function @code{gpgme_get_notation} can be used to retrieve
1977 notation data from the last signature check in the context @var{ctx}.
1978
1979 If there is notation data available from the last signature check,
1980 this function may be used to return this notation data as a string.
1981 The string is an XML representation of that data embedded in a
1982 <notation> container.  The user has to release the string with
1983 @code{free}.
1984
1985 The function returns a string if the notation data is available or
1986 @code{NULL} if there is no such data available.
1987 @end deftypefun
1988
1989
1990 @node Decrypt and Verify
1991 @subsection Decrypt and Verify
1992 @cindex decryption and verification
1993 @cindex verification and decryption
1994 @cindex signature check
1995 @cindex cryptographic operation, decryption and verification
1996
1997 @deftypefun GpgmeError gpgme_op_decrypt_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}}, @w{GpgmeSigStat *@var{r_stat}})
1998 The function @code{gpgme_op_decrypt_verify} decrypts the ciphertext in
1999 the data object @var{cipher} and stores it into the data object
2000 @var{plain}.  If @var{cipher} contains signatures, they will be
2001 verified and their combined status will be returned in @var{r_stat}.
2002
2003 After the operation completed, @code{gpgme_op_get_sig_status} and
2004 @code{gpgme_op_get_sig_key} can be used to retrieve more information
2005 about the signatures.
2006
2007 The function returns @code{GPGME_No_Error} if the ciphertext could be
2008 decrypted successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2009 @var{cipher}, @var{plain} or @var{r_stat} is not a valid pointer,
2010 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2011 decrypt, @code{GPGME_Decryption_Failed} if @var{cipher} is not a valid
2012 cipher text, @code{GPGME_No_Passphrase} if the passphrase for the
2013 secret key could not be retrieved, and passes through any errors that
2014 are reported by the crypto engine support routines.
2015 @end deftypefun
2016
2017 @deftypefun GpgmeError gpgme_op_decrypt_verify (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{cipher}}, @w{GpgmeData @var{plain}})
2018 The function @code{gpgme_op_decrypt_verify_start} initiates a
2019 @code{gpgme_op_decrypt_verify} operation.  It can be completed by
2020 calling @code{gpgme_wait} on the context.  @xref{Waiting For
2021 Completion}.
2022
2023 The function returns @code{GPGME_No_Error} if the operation could be
2024 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2025 @var{cipher}, @var{plain} or @var{r_stat} is not a valid pointer, and
2026 @code{GPGME_No_Data} if @var{cipher} does not contain any data to
2027 decrypt.
2028 @end deftypefun
2029
2030
2031 @node Sign
2032 @subsection Sign
2033 @cindex signature, creation
2034 @cindex sign
2035 @cindex cryptographic operation, signing
2036
2037 A signature can contain signatures by one or more keys.  The set of
2038 keys used to create a signatures is contained in a context, and is
2039 applied to all following signing operations in this context (until the
2040 set is changed).
2041
2042 @menu
2043 * Selecting Signers::             How to choose the keys to sign with.
2044 * Creating a Signature::          How to create a signature.
2045 @end menu
2046
2047
2048 @node Selecting Signers
2049 @subsubsection Selecting Signers
2050 @cindex signature, selecting signers
2051 @cindex signers, selecting
2052
2053 @deftypefun void gpgme_signers_clear (@w{GpgmeCtx @var{ctx}})
2054 The function @code{gpgme_signers_clear} releases a reference for each
2055 key on the signers list and removes the list of signers from the
2056 context @var{ctx}.
2057
2058 Every context starts with an empty list.
2059 @end deftypefun
2060
2061 @deftypefun GpgmeError gpgme_signers_add (@w{GpgmeCtx @var{ctx}}, @w{const GpgmeKey @var{key}})
2062 The function @code{gpgme_signers_add} adds the key @var{key} to the
2063 list of signers in the context @var{ctx}.
2064
2065 One reference for the key is consumed.
2066 @end deftypefun
2067
2068 @deftypefun GpgmeKey gpgme_signers_enum (@w{const GpgmeCtx @var{ctx}}, @w{int @var{seq}})
2069 The function @code{gpgme_signers_enum} returns the @var{seq}th key in
2070 the list of signers in the context @var{ctx}.  An additional reference
2071 is acquired for the user.
2072
2073 If @var{seq} is out of range, @code{NULL} is returned.
2074 @end deftypefun
2075
2076
2077 @node Creating a Signature
2078 @subsubsection Creating a Signature
2079
2080 @deftp {Data type} {enum GpgmeSigMode}
2081 @tindex GpgmeSigMode
2082 The @code{GpgmeSigMode} type is used to specify the desired type of a
2083 signature.  The following modes are available:
2084
2085 @table @code
2086 @item GPGME_SIG_MODE_NORMAL
2087 A normal signature is made, the output includes the plaintext and the
2088 signature.
2089
2090 @item GPGME_SIG_MODE_DETACH
2091 A detached signature is made.
2092
2093 @item GPGME_SIG_MODE_CLEAR
2094 A clear text signature is made.  The @acronym{ASCII} armor and text
2095 mode settings of the context are ignored.
2096 @end table
2097 @end deftp
2098
2099 @deftypefun GpgmeError gpgme_op_sign (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{sig}}, @w{GpgmeSigMode @var{mode}})
2100 The function @code{gpgme_op_sign} creates a signature for the text in
2101 the data object @var{plain} and returns it in the data object
2102 @var{sig}.  The type of the signature created is determined by the
2103 @acronym{ASCII} armor and text mode attributes set for the context
2104 @var{ctx} and the requested signature mode @var{mode}.
2105
2106 More information about the signatures is available with
2107 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
2108
2109 If an S/MIME signed message is created using the CMS crypto engine,
2110 the number of certificates to include in the message can be specified
2111 with @code{gpgme_set_include_certs}.  @xref{Included Certificates}.
2112
2113 The function returns @code{GPGME_No_Error} if the signature could be
2114 created successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2115 @var{plain} or @var{sig} is not a valid pointer, @code{GPGME_No_Data}
2116 if the signature could not be created, @code{GPGME_No_Passphrase} if
2117 the passphrase for the secret key could not be retrieved, and passes
2118 through any errors that are reported by the crypto engine support
2119 routines.
2120 @end deftypefun
2121
2122 @deftypefun GpgmeError gpgme_op_sign (@w{GpgmeCtx @var{ctx}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{sig}}, @w{GpgmeSigMode @var{mode}})
2123 The function @code{gpgme_op_sign_start} initiates a
2124 @code{gpgme_op_sign} operation.  It can be completed by calling
2125 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2126
2127 The function returns @code{GPGME_No_Error} if the operation could be
2128 started successfully, and @code{GPGME_Invalid_Value} if @var{ctx},
2129 @var{plain} or @var{sig} is not a valid pointer.
2130 @end deftypefun
2131
2132
2133 @node Encrypt
2134 @subsection Encrypt
2135 @cindex encryption
2136 @cindex cryptographic operation, encryption
2137
2138 One plaintext can be encrypted for several recipients at the same
2139 time.  The list of recipients is created independently of any context,
2140 and then passed to the encryption operation.
2141
2142 @menu
2143 * Selecting Recipients::          How to choose the recipients.
2144 * Encrypting a Plaintext::        How to encrypt a plaintext.
2145 @end menu
2146
2147
2148 @node Selecting Recipients
2149 @subsubsection Selecting Recipients
2150 @cindex encryption, selecting recipients
2151 @cindex recipients
2152
2153 @deftp {Data type} GpgmeRecipients
2154 The @code{GpgmeRecipients} type is a handle for a set of recipients
2155 that can be used in an encryption process.
2156 @end deftp
2157
2158 @deftypefun GpgmeError gpgme_recipients_new (@w{GpgmeRecipients *@var{r_rset}})
2159 The function @code{gpgme_recipients_new} creates a new, empty set of
2160 recipients and returns a handle for it in @var{r_rset}.
2161
2162 The function returns @code{GPGME_No_Error} if the recipient set could
2163 be created successfully, and @code{GPGME_Out_Of_Core} if not enough
2164 memory was available.
2165 @end deftypefun
2166
2167 @deftypefun void gpgme_recipients_release (@w{GpgmeRecipients @var{rset}})
2168 The function @code{gpgme_recipients_release} destroys the set of
2169 recipients @var{rset} and releases all associated resources.
2170 @end deftypefun
2171
2172 @deftypefun GpgmeError gpgme_recipients_add_name (@w{GpgmeRecipients @var{rset}}, @w{const char *@var{name}})
2173 The function @code{gpgme_recipients_add_name} adds the recipient
2174 @var{name} to the set of recipients @var{rset}.  This is equivalent to
2175 @code{gpgme_recipients_add_name_with_validity} with a validity of
2176 @code{GPGME_VALIDITY_UNKNOWN}.
2177
2178 The function returns @code{GPGME_No_Error} if the recipient was added
2179 successfully, @code{GPGME_Invalid_Value} if @var{rset} or @var{name}
2180 is not a valid pointer, and @code{GPGME_Out_Of_Core} if not enough
2181 memory is available.
2182 @end deftypefun
2183
2184 @deftypefun GpgmeError gpgme_recipients_add_name_with_validity (@w{GpgmeRecipients @var{rset}}, @w{const char *@var{name}}, @w{GpgmeValidity @var{val}})
2185 The function @code{gpgme_recipients_add_name_with_validity} adds the
2186 recipient @var{name} with the validity @var{val} to the set of
2187 recipients @var{rset}.  If the validity is not known, the function
2188 @code{gpgme_recipients_add_name} can be used.
2189 @xref{Information About Keys}, for the possible values for @var{val}.
2190
2191 The function returns @code{GPGME_No_Error} if the recipient was added
2192 successfully, @code{GPGME_Invalid_Value} if @var{rset} or @var{name}
2193 is not a valid pointer, and @code{GPGME_Out_Of_Core} if not enough
2194 memory is available.
2195 @end deftypefun
2196
2197 @deftypefun {unsigned int} gpgme_recipients_count (@w{const @var{GpgmeRecipients rset}})
2198 The function @code{gpgme_recipients_count} returns the number of
2199 recipients in the set @var{rset}.
2200 @end deftypefun
2201
2202 @deftypefun GpgmeError gpgme_recipients_enum_open (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2203 The function @code{gpgme_recipients_enum_open} creates a new iterator
2204 @var{iter} that can be used to walk through the set of recipients in
2205 @var{rset}, using @code{gpgme_recipients_enum_read}.
2206
2207 If the iterator is not needed anymore, it can be closed with
2208 @code{gpgme_recipients_enum_close}.
2209
2210 The function returns @code{GPGME_No_Error} if the enumerator was
2211 successfully created and @code{GPGME_Invalid_Value} if @var{rset} or
2212 @var{iter} is not a valid pointer.
2213 @end deftypefun
2214
2215 @deftypefun {const char *} gpgme_recipients_enum_read (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2216 The function @code{gpgme_recipients_enum_read} returns a string
2217 containing the name of the next recipient in the set @var{rset} for
2218 the iterator @var{iter}.  The string is valid as long as @var{rset} is
2219 valid or the function is called the next time with the same recipient
2220 set and iterator, whatever is earlier.
2221 @end deftypefun
2222
2223 @deftypefun GpgmeError gpgme_recipients_enum_close (@w{const GpgmeRecipients @var{rset}}, @w{void **@var{iter}})
2224 The function @code{gpgme_recipients_enum_close} releases the iterator
2225 @var{iter} for the recipient set @var{rset}.
2226 @end deftypefun
2227
2228
2229 @node Encrypting a Plaintext
2230 @subsubsection Encrypting a Plaintext
2231
2232 @deftypefun GpgmeError gpgme_op_encrypt (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2233 The function @code{gpgme_op_encrypt} encrypts the plaintext in the data
2234 object @var{plain} for the recipients @var{rset} and stores the
2235 ciphertext in the data object @var{cipher}.  The type of the
2236 ciphertext created is determined by the @acronym{ASCII} armor and text
2237 mode attributes set for the context @var{ctx}.
2238
2239 If @code{GPGME_Invalid_Recipients} is returned, some recipients in
2240 @var{rset} are invalid, but not all.  In this case the plaintext is
2241 encrypted for all valid recipients and returned in @var{cipher}.  More
2242 information about the invalid recipients is available with
2243 @code{gpgme_get_op_info}.  @xref{Detailed Results}.
2244
2245 The function returns @code{GPGME_No_Error} if the ciphertext could be
2246 created successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2247 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer,
2248 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2249 recipients, @code{GPGME_Invalid_Recipients} if @var{rset} contains
2250 some invalid recipients, @code{GPGME_No_Passphrase} if the passphrase
2251 for the secret key could not be retrieved, and passes through any
2252 errors that are reported by the crypto engine support routines.
2253 @end deftypefun
2254
2255 @deftypefun GpgmeError gpgme_op_encrypt_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2256 The function @code{gpgme_op_encrypt_start} initiates a
2257 @code{gpgme_op_encrypt} operation.  It can be completed by calling
2258 @code{gpgme_wait} on the context.  @xref{Waiting For Completion}.
2259
2260 The function returns @code{GPGME_No_Error} if the operation could be
2261 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2262 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
2263 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2264 recipients.
2265 @end deftypefun
2266
2267
2268 @deftypefun GpgmeError gpgme_op_encrypt_sign (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2269 The function @code{gpgme_op_encrypt_sign} does a combined encrypt and
2270 sign operation.  It is used like @code{gpgme_op_encrypt}, but the
2271 ciphertext also contains signatures for the signers listed in
2272 @var{ctx}.
2273
2274 The combined encrypt and sign operation is currently only available
2275 for the OpenPGP crypto engine.
2276 @end deftypefun
2277
2278 @deftypefun GpgmeError gpgme_op_encrypt_sign_start (@w{GpgmeCtx @var{ctx}}, @w{GpgmeRecipients @var{rset}}, @w{GpgmeData @var{plain}}, @w{GpgmeData @var{cipher}})
2279 The function @code{gpgme_op_encrypt_sign_start} initiates a
2280 @code{gpgme_op_encrypt_sign} operation.  It can be completed by
2281 calling @code{gpgme_wait} on the context.  @xref{Waiting For
2282 Completion}.
2283
2284 The function returns @code{GPGME_No_Error} if the operation could be
2285 started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
2286 @var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
2287 @code{GPGME_No_Recipients} if @var{rset} does not contain any valid
2288 recipients.
2289 @end deftypefun
2290
2291
2292 @node Detailed Results
2293 @subsection Detailed Results
2294 @cindex cryptographic operation, detailed results
2295
2296 @deftypefun {char *} gpgme_get_op_info (@w{GpgmeCtx @var{ctx}}, @w{int @var{reserved}})
2297 The function @code{gpgme_get_op_info} retrieves more information about
2298 the last crypto operation.
2299
2300 The function returns a string in the XML format.  The user has to
2301 release the string with @code{free}.
2302
2303 Here is a sample of the information that might be returned:
2304 @example
2305 <GnupgOperationInfo>
2306   <signature>
2307     <detached/> <!-- or cleartext or standard -->
2308     <algo>17</algo>
2309     <hashalgo>2</hashalgo>
2310     <micalg>pgp-sha1</micalg>
2311     <sigclass>01</sigclass>
2312     <created>9222222</created>
2313     <fpr>121212121212121212</fpr>
2314   </signature>
2315 </GnupgOperationInfo>
2316 @end example
2317
2318 Currently, the only operations that return additional information are
2319 encrypt and sign.  @xref{Encrypt}, @xref{Sign}.
2320
2321 The function returns a string or @code{NULL} if no such data is
2322 available.
2323 @end deftypefun
2324
2325
2326 @node Run Control
2327 @section Run Control
2328 @cindex run control
2329 @cindex cryptographic operation, running
2330
2331 Some basic support for running operations asynchronously is available
2332 in @acronym{GPGME}.  You can use it to set up a context completely up
2333 to initiating the desired operation, but delay performing it to a
2334 later point.
2335
2336 @menu
2337 * Waiting For Completion::        Waiting until an operation is completed.
2338 * Cancelling an Operation::       Interrupting a running operation.
2339 * Hooking Up Into Idle Time::     Doing something when nothing has to be done.
2340 @end menu
2341
2342
2343 @node Waiting For Completion
2344 @subsection Waiting For Completion
2345 @cindex cryptographic operation, wait for
2346 @cindex wait for completion
2347
2348 @deftypefun GpgmeCtx gpgme_wait (@w{GpgmeCtx @var{ctx}}, @w{GpgmeError *@var{status}}, @w{int @var{hang}})
2349 The function @code{gpgme_wait} does continue the pending operation
2350 within the context @var{ctx}.  In particular, it ensures the data
2351 exchange between @acronym{GPGME} and the crypto backend and watches
2352 over the run time status of the backend process.
2353
2354 If @var{hang} is true, the function does not return until the
2355 operation is completed or cancelled.  Otherwise the function will not
2356 block for a long time.
2357
2358 The error status of the finished operation is returned in
2359 @var{status}.
2360
2361 The @var{ctx} argument can be @code{NULL}.  In that case,
2362 @code{gpgme_wait} waits for any context to complete its operation.
2363
2364 The function returns the @var{ctx} of the context which has finished
2365 the operation.
2366 @end deftypefun
2367
2368
2369 @node Cancelling an Operation
2370 @subsection Cancelling an Operation
2371 @cindex cancellation
2372 @cindex cryptographic operation, cancel
2373
2374 @deftypefun void gpgme_cancel (@w{GpgmeCtx @var{ctx}})
2375 The function @code{gpgme_cancel} tries to cancel the pending
2376 operation.  The function @code{gpgme_wait} might notice the
2377 cancellation flag and return.  It is currently not guaranteed to work
2378 under all circumstances.  It's current primary purpose is to prevent
2379 asking for a passphrase again in the passphrase callback.
2380 @end deftypefun
2381
2382
2383 @node Hooking Up Into Idle Time
2384 @subsection Hooking Up Into Idle Time
2385 @cindex idle time
2386 @cindex idle function
2387
2388 @deftp {Data type} {void (*GpgmeIdleFunc) (void)}
2389 @tindex GpgmeIdleFunc
2390 The @code{GpgmeIdleFunc} type is the type of functions usable as
2391 an idle function that can be registered with @code{gpgme_register_idle}.
2392 @end deftp
2393
2394 @deftypefun GpgmeIdleFunc gpgme_register_idle (@w{GpgmeIdleFunc @var{idle}})
2395 The function @code{gpgme_register_idle} can be used to register
2396 @var{idle} as the idle function.
2397
2398 @var{idle} will be called whenever @acronym{GPGME} thinks that it is
2399 idle and time can better be spent elsewhere.  Setting @var{idle} to
2400 @code{NULL} disables use of the idle function (this is the default).
2401
2402 The function returns the old idle function, or @code{NULL} if none was
2403 registered yet.
2404 @end deftypefun
2405
2406
2407 @include gpl.texi
2408
2409
2410 @include fdl.texi
2411
2412
2413 @node Concept Index
2414 @unnumbered Concept Index
2415
2416 @printindex cp
2417
2418
2419 @node Function and Data Index
2420 @unnumbered Function and Data Index
2421
2422 @printindex fn
2423
2424
2425 @summarycontents
2426 @contents
2427 @bye
2428
2429 @c  LocalWords:  GPGME gpgme