gpg: Take care of keydb_new returning NULL.
[gnupg.git] / g10 / keydb.h
1 /* keydb.h - Key database
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006, 2010 Free Software Foundation, Inc.
4  * Copyright (C) 2015 g10 Code GmbH
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #ifndef G10_KEYDB_H
23 #define G10_KEYDB_H
24
25 #include <assuan.h>
26
27 #include "types.h"
28 #include "util.h"
29 #include "packet.h"
30
31 /* What qualifies as a certification (rather than a signature?) */
32 #define IS_CERT(s)       (IS_KEY_SIG(s) || IS_UID_SIG(s) || IS_SUBKEY_SIG(s) \
33                          || IS_KEY_REV(s) || IS_UID_REV(s) || IS_SUBKEY_REV(s))
34 #define IS_SIG(s)        (!IS_CERT(s))
35 #define IS_KEY_SIG(s)    ((s)->sig_class == 0x1f)
36 #define IS_UID_SIG(s)    (((s)->sig_class & ~3) == 0x10)
37 #define IS_SUBKEY_SIG(s) ((s)->sig_class == 0x18)
38 #define IS_KEY_REV(s)    ((s)->sig_class == 0x20)
39 #define IS_UID_REV(s)    ((s)->sig_class == 0x30)
40 #define IS_SUBKEY_REV(s) ((s)->sig_class == 0x28)
41
42 struct getkey_ctx_s;
43 typedef struct getkey_ctx_s *GETKEY_CTX;
44 typedef struct getkey_ctx_s *getkey_ctx_t;
45
46 /****************
47  * A Keyblock is all packets which form an entire certificate;
48  * i.e. the public key, certificate, trust packets, user ids,
49  * signatures, and subkey.
50  *
51  * This structure is also used to bind arbitrary packets together.
52  */
53
54 struct kbnode_struct {
55     KBNODE next;
56     PACKET *pkt;
57     int flag;
58     int private_flag;
59     ulong recno;  /* used while updating the trustdb */
60 };
61
62 #define is_deleted_kbnode(a)  ((a)->private_flag & 1)
63 #define is_cloned_kbnode(a)   ((a)->private_flag & 2)
64
65
66 enum resource_type {
67     rt_UNKNOWN = 0,
68     rt_RING = 1
69 };
70
71
72 /****************
73  * A data structure to hold information about the external position
74  * of a keyblock.
75  */
76 struct keyblock_pos_struct {
77     int   resno;     /* resource number */
78     enum resource_type rt;
79     off_t offset;    /* position information */
80     unsigned count;  /* length of the keyblock in packets */
81     iobuf_t  fp;     /* Used by enum_keyblocks. */
82     int secret;      /* working on a secret keyring */
83     PACKET *pkt;     /* ditto */
84     int valid;
85 };
86 typedef struct keyblock_pos_struct KBPOS;
87
88 /* Structure to hold a couple of public key certificates. */
89 typedef struct pk_list *PK_LIST;  /* Deprecated. */
90 typedef struct pk_list *pk_list_t;
91 struct pk_list
92 {
93   PK_LIST next;
94   PKT_public_key *pk;
95   int flags; /* flag bit 1==throw_keyid */
96 };
97
98 /* Structure to hold a list of secret key certificates.  */
99 typedef struct sk_list *SK_LIST;
100 struct sk_list
101 {
102   SK_LIST next;
103   PKT_public_key *pk;
104   int mark; /* not used */
105 };
106
107 /* structure to collect all information which can be used to
108  * identify a public key */
109 typedef struct pubkey_find_info *PUBKEY_FIND_INFO;
110 struct pubkey_find_info {
111     u32  keyid[2];
112     unsigned nbits;
113     byte pubkey_algo;
114     byte fingerprint[MAX_FINGERPRINT_LEN];
115     char userid[1];
116 };
117
118
119 typedef struct keydb_handle *KEYDB_HANDLE;
120
121
122 /* Helper type for preference fucntions. */
123 union pref_hint
124 {
125   int digest_length;
126 };
127
128
129 /*-- keydb.c --*/
130
131 #define KEYDB_RESOURCE_FLAG_PRIMARY  2  /* The primary resource.  */
132 #define KEYDB_RESOURCE_FLAG_DEFAULT  4  /* The default one.  */
133 #define KEYDB_RESOURCE_FLAG_READONLY 8  /* Open in read only mode.  */
134 #define KEYDB_RESOURCE_FLAG_GPGVDEF 16  /* Default file for gpgv.  */
135
136 /* Format a search term for debugging output.  The caller must free
137    the result.  */
138 char *keydb_search_desc_dump (struct keydb_search_desc *desc);
139
140 /* Register a resource (keyring or keybox).  The first keyring or
141    keybox that is added using this function is created if it does not
142    already exist and the KEYDB_RESOURCE_FLAG_READONLY is not set.
143
144    FLAGS are a combination of the KEYDB_RESOURCE_FLAG_* constants.
145
146    URL must have the following form:
147
148      gnupg-ring:filename  = plain keyring
149      gnupg-kbx:filename   = keybox file
150      filename             = check file's type (create as a plain keyring)
151
152    Note: on systems with drive letters (Windows) invalid URLs (i.e.,
153    those with an unrecognized part before the ':' such as "c:\...")
154    will silently be treated as bare filenames.  On other systems, such
155    URLs will cause this function to return GPG_ERR_GENERAL.
156
157    If KEYDB_RESOURCE_FLAG_DEFAULT is set, the resource is a keyring
158    and the file ends in ".gpg", then this function also checks if a
159    file with the same name, but the extension ".kbx" exists, is a
160    keybox and the OpenPGP flag is set.  If so, this function opens
161    that resource instead.
162
163    If the file is not found, KEYDB_RESOURCE_FLAG_GPGVDEF is set and
164    the URL ends in ".kbx", then this function will try opening the
165    same URL, but with the extension ".gpg".  If that file is a keybox
166    with the OpenPGP flag set or it is a keyring, then we use that
167    instead.
168
169    If the file is not found, KEYDB_RESOURCE_FLAG_DEFAULT is set, the
170    file should be created and the file's extension is ".gpg" then we
171    replace the extension with ".kbx".
172
173
174    If the KEYDB_RESOURCE_FLAG_PRIMARY is set and the resource is a
175    keyring (not a keybox), then this resource is considered the
176    primary resource.  This is used by keydb_locate_writable().  If
177    another primary keyring is set, then that keyring is considered the
178    primary.
179
180    If KEYDB_RESOURCE_FLAG_READONLY is set and the resource is a
181    keyring (not a keybox), then the keyring is marked as read only and
182    operations just as keyring_insert_keyblock will return
183    GPG_ERR_ACCESS.  */
184 gpg_error_t keydb_add_resource (const char *url, unsigned int flags);
185
186 /* Dump some statistics to the log.  */
187 void keydb_dump_stats (void);
188
189 /* Create a new database handle.  Returns NULL on error, sets ERRNO,
190    and prints an error diagnostic. */
191 KEYDB_HANDLE keydb_new (void);
192
193 /* Free all resources owned by the database handle.  */
194 void keydb_release (KEYDB_HANDLE hd);
195
196 /* Set a flag on the handle to suppress use of cached results.  This
197    is required for updating a keyring and for key listings.  Fixme:
198    Using a new parameter for keydb_new might be a better solution.  */
199 void keydb_disable_caching (KEYDB_HANDLE hd);
200
201 /* Save the last found state and invalidate the current selection
202    (i.e., the entry selected by keydb_search() is invalidated and
203    something like keydb_get_keyblock() will return an error).  This
204    does not change the file position.  This makes it possible to do
205    something like:
206
207      keydb_search (hd, ...);  // Result 1.
208      keydb_push_found_state (hd);
209        keydb_search_reset (hd);
210        keydb_search (hd, ...);  // Result 2.
211      keydb_pop_found_state (hd);
212      keydb_get_keyblock (hd, ...);  // -> Result 1.
213
214    Note: it is only possible to save a single save state at a time.
215    In other words, the the save stack only has room for a single
216    instance of the state.  */
217 void keydb_push_found_state (KEYDB_HANDLE hd);
218
219 /* Restore the previous save state.  If the saved state is invalid,
220    this is equivalent to */
221 void keydb_pop_found_state (KEYDB_HANDLE hd);
222
223 /* Return the file name of the resource in which the current search
224    result was found or, if there is no search result, the filename of
225    the current resource (i.e., the resource that the file position
226    points to).  Note: the filename is not necessarily the URL used to
227    open it!
228
229    This function only returns NULL if no handle is specified, in all
230    other error cases an empty string is returned.  */
231 const char *keydb_get_resource_name (KEYDB_HANDLE hd);
232
233 /* Return the keyblock last found by keydb_search() in *RET_KB.
234
235    On success, the function returns 0 and the caller must free *RET_KB
236    using release_kbnode().  Otherwise, the function returns an error
237    code.
238
239    The returned keyblock has the kbnode flag bit 0 set for the node
240    with the public key used to locate the keyblock or flag bit 1 set
241    for the user ID node.  */
242 gpg_error_t keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb);
243
244 /* Replace the currently selected keyblock (i.e., the last result
245    returned by keydb_search) with the key block in KB.
246
247    This doesn't do anything if --dry-run was specified.
248
249    Returns 0 on success.  Otherwise, it returns an error code.  */
250 gpg_error_t keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
251
252 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
253
254    Be default, the keyring / keybox from which the last search result
255    came is used.  If there was no previous search result (or
256    keydb_search_reset was called), then the keyring / keybox where the
257    next search would start is used (i.e., the current file position).
258
259    Note: this doesn't do anything if --dry-run was specified.
260
261    Returns 0 on success.  Otherwise, it returns an error code.  */
262 gpg_error_t keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
263
264 /* Delete the currently selected keyblock.  If you haven't done a
265    search yet on this database handle (or called keydb_search_reset),
266    then this will return an error.
267
268    Returns 0 on success or an error code, if an error occurs.  */
269 gpg_error_t keydb_delete_keyblock (KEYDB_HANDLE hd);
270
271 /* A database may consists of multiple keyrings / key boxes.  This
272    sets the "file position" to the start of the first keyring / key
273    box that is writable (i.e., doesn't have the read-only flag set).
274
275    This first tries the primary keyring (the last keyring (not
276    keybox!) added using keydb_add_resource() and with
277    KEYDB_RESOURCE_FLAG_PRIMARY set).  If that is not writable, then it
278    tries the keyrings / keyboxes in the order in which they were
279    added.  */
280 gpg_error_t keydb_locate_writable (KEYDB_HANDLE hd);
281
282 /* Rebuild the on-disk caches of all key resources.  */
283 void keydb_rebuild_caches (int noisy);
284
285 /* Return the number of skipped blocks (because they were to large to
286    read from a keybox) since the last search reset.  */
287 unsigned long keydb_get_skipped_counter (KEYDB_HANDLE hd);
288
289 /* Clears the current search result and resets the handle's position
290    so that the next search starts at the beginning of the database
291    (the start of the first resource).
292
293    Returns 0 on success and an error code if an error occurred.
294    (Currently, this function always returns 0 if HD is valid.)  */
295 gpg_error_t keydb_search_reset (KEYDB_HANDLE hd);
296
297 /* Search the database for keys matching the search description.  If
298    the DB contains any legacy keys, these are silently ignored.
299
300    DESC is an array of search terms with NDESC entries.  The search
301    terms are or'd together.  That is, the next entry in the DB that
302    matches any of the descriptions will be returned.
303
304    Note: this function resumes searching where the last search left
305    off (i.e., at the current file position).  If you want to search
306    from the start of the database, then you need to first call
307    keydb_search_reset().
308
309    If no key matches the search description, returns
310    GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
311    occurred, returns an error code.
312
313    The returned key is considered to be selected and the raw data can,
314    for instance, be returned by calling keydb_get_keyblock().  */
315 gpg_error_t keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
316                           size_t ndesc, size_t *descindex);
317
318 /* Return the first non-legacy key in the database.
319
320    If you want the very first key in the database, you can directly
321    call keydb_search with the search description
322    KEYDB_SEARCH_MODE_FIRST.  */
323 gpg_error_t keydb_search_first (KEYDB_HANDLE hd);
324
325 /* Return the next key (not the next matching key!).
326
327    Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
328    function silently skips legacy keys.  */
329 gpg_error_t keydb_search_next (KEYDB_HANDLE hd);
330
331 /* This is a convenience function for searching for keys with a long
332    key id.
333
334    Note: this function resumes searching where the last search left
335    off.  If you want to search the whole database, then you need to
336    first call keydb_search_reset().  */
337 gpg_error_t keydb_search_kid (KEYDB_HANDLE hd, u32 *kid);
338
339 /* This is a convenience function for searching for keys with a long
340    (20 byte) fingerprint.
341
342    Note: this function resumes searching where the last search left
343    off.  If you want to search the whole database, then you need to
344    first call keydb_search_reset().  */
345 gpg_error_t keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr);
346
347
348 /*-- pkclist.c --*/
349 void show_revocation_reason( PKT_public_key *pk, int mode );
350 int  check_signatures_trust( PKT_signature *sig );
351
352 void release_pk_list (PK_LIST pk_list);
353 int  build_pk_list (ctrl_t ctrl,
354                     strlist_t rcpts, PK_LIST *ret_pk_list, unsigned use);
355 gpg_error_t find_and_check_key (ctrl_t ctrl,
356                                 const char *name, unsigned int use,
357                                 int mark_hidden, pk_list_t *pk_list_addr);
358
359 int  algo_available( preftype_t preftype, int algo,
360                      const union pref_hint *hint );
361 int  select_algo_from_prefs( PK_LIST pk_list, int preftype,
362                              int request, const union pref_hint *hint);
363 int  select_mdc_from_pklist (PK_LIST pk_list);
364 void warn_missing_mdc_from_pklist (PK_LIST pk_list);
365 void warn_missing_aes_from_pklist (PK_LIST pk_list);
366
367 /*-- skclist.c --*/
368 int  random_is_faked (void);
369 void release_sk_list( SK_LIST sk_list );
370 gpg_error_t build_sk_list (ctrl_t ctrl, strlist_t locusr,
371                            SK_LIST *ret_sk_list, unsigned use);
372
373 /*-- passphrase.h --*/
374 unsigned char encode_s2k_iterations (int iterations);
375 assuan_context_t agent_open (int try, const char *orig_codeset);
376 void agent_close (assuan_context_t ctx);
377 int  have_static_passphrase(void);
378 const char *get_static_passphrase (void);
379 void set_passphrase_from_string(const char *pass);
380 void read_passphrase_from_fd( int fd );
381 void passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo );
382 DEK *passphrase_to_dek_ext(u32 *keyid, int pubkey_algo,
383                            int cipher_algo, STRING2KEY *s2k, int mode,
384                            const char *tryagain_text,
385                            const char *custdesc, const char *custprompt,
386                            int *canceled);
387 DEK *passphrase_to_dek( u32 *keyid, int pubkey_algo,
388                         int cipher_algo, STRING2KEY *s2k, int mode,
389                         const char *tryagain_text, int *canceled);
390 void set_next_passphrase( const char *s );
391 char *get_last_passphrase(void);
392 void next_to_last_passphrase(void);
393
394 void emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo);
395
396 #define FORMAT_KEYDESC_NORMAL  0
397 #define FORMAT_KEYDESC_IMPORT  1
398 #define FORMAT_KEYDESC_EXPORT  2
399 #define FORMAT_KEYDESC_DELKEY  3
400 char *gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped);
401
402
403 /*-- getkey.c --*/
404
405 /* Cache a copy of a public key in the public key cache.  PK is not
406    cached if caching is disabled (via getkey_disable_caches), if
407    PK->FLAGS.DONT_CACHE is set, we don't know how to derive a key id
408    from the public key (e.g., unsupported algorithm), or a key with
409    the key id is already in the cache.
410
411    The public key packet is copied into the cache using
412    copy_public_key.  Thus, any secret parts are not copied, for
413    instance.
414
415    This cache is filled by get_pubkey and is read by get_pubkey and
416    get_pubkey_fast.  */
417 void cache_public_key( PKT_public_key *pk );
418
419 /* Disable and drop the public key cache (which is filled by
420    cache_public_key and get_pubkey).  Note: there is currently no way
421    to reenable this cache.  */
422 void getkey_disable_caches(void);
423
424 /* Return the public key with the key id KEYID and store it in *PK.
425    The resources in *PK should be released using
426    release_public_key_parts().  This function also stores a copy of
427    the public key in the user id cache (see cache_public_key).
428
429    If PK is NULL, this function just stores the public key in the
430    cache and returns the usual return code.
431
432    PK->REQ_USAGE (which is a mask of PUBKEY_USAGE_SIG,
433    PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT) is passed through to the
434    lookup function.  If this is non-zero, only keys with the specified
435    usage will be returned.  As such, it is essential that
436    PK->REQ_USAGE be correctly initialized!
437
438    Returns 0 on success, GPG_ERR_NO_PUBKEY if there is no public key
439    with the specified key id, or another error code if an error
440    occurs.
441
442    If the data was not read from the cache, then the self-signed data
443    has definitely been merged into the public key using
444    merge_selfsigs.  */
445 int get_pubkey( PKT_public_key *pk, u32 *keyid );
446
447 /* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
448    account nor does it merge in the self-signed data.  This function
449    also only considers primary keys.  It is intended to be used as a
450    quick check of the key to avoid recursion.  It should only be used
451    in very certain cases.  Like get_pubkey and unlike any of the other
452    lookup functions, this function also consults the user id cache
453    (see cache_public_key).
454
455    Return the public key in *PK.  The resources in *PK should be
456    released using release_public_key_parts().  */
457 int get_pubkey_fast ( PKT_public_key *pk, u32 *keyid );
458
459 /* Return the key block for the key with key id KEYID or NULL, if an
460    error occurs.  Use release_kbnode() to release the key block.
461
462    The self-signed data has already been merged into the public key
463    using merge_selfsigs.  */
464 KBNODE get_pubkeyblock( u32 *keyid );
465
466 /* Find a public key identified by the name NAME.
467
468    If name appears to be a valid valid RFC822 mailbox (i.e., email
469    address) and auto key lookup is enabled (no_akl == 0), then the
470    specified auto key lookup methods (--auto-key-lookup) are used to
471    import the key into the local keyring.  Otherwise, just the local
472    keyring is consulted.
473
474
475    If RETCTX is not NULL, then the constructed context is returned in
476    *RETCTX so that getpubkey_next can be used to get subsequent
477    results.  In this case, getkey_end() must be used to free the
478    search context.  If RETCTX is not NULL, then RET_KDBHD must be
479    NULL.
480
481    If PK is not NULL, the public key of the first result is returned
482    in *PK.  Note: PK->REQ_USAGE must be valid!!!  PK->REQ_USAGE is
483    passed through to the lookup function and is a mask of
484    PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  If this
485    is non-zero, only keys with the specified usage will be returned.
486    Note: The self-signed data has already been merged into the public
487    key using merge_selfsigs.  Free *PK by calling
488    release_public_key_parts (or, if PK was allocated using xfree, you
489    can use free_public_key, which calls release_public_key_parts(PK)
490    and then xfree(PK)).
491
492    NAME is a string, which is turned into a search query using
493    classify_user_id.
494
495    If RET_KEYBLOCK is not NULL, the keyblock is returned in
496    *RET_KEYBLOCK.  This should be freed using release_kbnode().
497
498    If RET_KDBHD is not NULL, then the new database handle used to
499    conduct the search is returned in *RET_KDBHD.  This can be used to
500    get subsequent results using keydb_search_next or to modify the
501    returned record.  Note: in this case, no advanced filtering is done
502    for subsequent results (e.g., PK->REQ_USAGE is not respected).
503    Unlike RETCTX, this is always returned.
504
505    If INCLUDE_UNUSABLE is set, then unusable keys (see the
506    documentation for skip_unusable for an exact definition) are
507    skipped unless they are looked up by key id or by fingerprint.
508
509    If NO_AKL is set, then the auto key locate functionality is
510    disabled and only the local key ring is considered.  Note: the
511    local key ring is consulted even if local is not in the
512    --auto-key-locate option list!
513
514    This function returns 0 on success.  Otherwise, an error code is
515    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
516    (if want_secret is set) is returned if the key is not found.  */
517 int get_pubkey_byname (ctrl_t ctrl,
518                        GETKEY_CTX *retctx, PKT_public_key *pk,
519                        const char *name,
520                        KBNODE *ret_keyblock, KEYDB_HANDLE *ret_kdbhd,
521                        int include_unusable, int no_akl );
522
523 /* Return the public key with the key id KEYID and store it in *PK.
524    The resources should be released using release_public_key_parts().
525
526    Unlike other lookup functions, PK may not be NULL.  PK->REQ_USAGE
527    is passed through to the lookup function and is a mask of
528    PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  Thus, it
529    must be valid!  If this is non-zero, only keys with the specified
530    usage will be returned.
531
532    Returns 0 on success.  If a public key with the specified key id is
533    not found or a secret key is not available for that public key, an
534    error code is returned.  Note: this function ignores legacy keys.
535    An error code is also return if an error occurs.
536
537    The self-signed data has already been merged into the public key
538    using merge_selfsigs.  */
539 gpg_error_t get_seckey (PKT_public_key *pk, u32 *keyid);
540
541 /* Lookup a key with the specified fingerprint.
542
543    If PK is not NULL, the public key of the first result is returned
544    in *PK.  Note: this function does an exact search and thus the
545    returned public key may be a subkey rather than the primary key.
546    Note: The self-signed data has already been merged into the public
547    key using merge_selfsigs.  Free *PK by calling
548    release_public_key_parts (or, if PK was allocated using xfree, you
549    can use free_public_key, which calls release_public_key_parts(PK)
550    and then xfree(PK)).
551
552    If PK->REQ_USAGE is set, it is used to filter the search results.
553    (Thus, if PK is not NULL, PK->REQ_USAGE must be valid!!!)  See the
554    documentation for finish_lookup to understand exactly how this is
555    used.
556
557    If R_KEYBLOCK is not NULL, then the first result's keyblock is
558    returned in *R_KEYBLOCK.  This should be freed using
559    release_kbnode().
560
561    FPRINT is a byte array whose contents is the fingerprint to use as
562    the search term.  FPRINT_LEN specifies the length of the
563    fingerprint (in bytes).  Currently, only 16 and 20-byte
564    fingerprints are supported.  */
565 int get_pubkey_byfprint (PKT_public_key *pk,  kbnode_t *r_keyblock,
566                          const byte *fprint, size_t fprint_len);
567
568 /* This function is similar to get_pubkey_byfprint, but it doesn't
569    merge the self-signed data into the public key and subkeys or into
570    the user ids.  It also doesn't add the key to the user id cache.
571    Further, this function ignores PK->REQ_USAGE.
572
573    This function is intended to avoid recursion and, as such, should
574    only be used in very specific situations.
575
576    Like get_pubkey_byfprint, PK may be NULL.  In that case, this
577    function effectively just checks for the existence of the key.  */
578 int get_pubkey_byfprint_fast (PKT_public_key *pk,
579                               const byte *fprint, size_t fprint_len);
580
581 /* Returns true if a secret key is available for the public key with
582    key id KEYID.  */
583 int have_secret_key_with_kid (u32 *keyid);
584
585 /* Parse the --default-key parameter.  Returns the last key (in terms
586    of when the option is given) that is available.  */
587 const char *parse_def_secret_key (ctrl_t ctrl);
588
589 /* Look up a secret key.
590
591    If PK is not NULL, the public key of the first result is returned
592    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
593    set, it is used to filter the search results.  See the
594    documentation for finish_lookup to understand exactly how this is
595    used.  Note: The self-signed data has already been merged into the
596    public key using merge_selfsigs.  Free *PK by calling
597    release_public_key_parts (or, if PK was allocated using xfree, you
598    can use free_public_key, which calls release_public_key_parts(PK)
599    and then xfree(PK)).
600
601    If --default-key was set, then the specified key is looked up.  (In
602    this case, the default key is returned even if it is considered
603    unusable.  See the documentation for skip_unusable for exactly what
604    this means.)
605
606    Otherwise, this initiates a DB scan that returns all keys that are
607    usable (see previous paragraph for exactly what usable means) and
608    for which a secret key is available.
609
610    This function returns the first match.  Additional results can be
611    returned using getkey_next.  */
612 gpg_error_t get_seckey_default (ctrl_t ctrl, PKT_public_key *pk);
613
614 /* Search for keys matching some criteria.
615
616    If RETCTX is not NULL, then the constructed context is returned in
617    *RETCTX so that getpubkey_next can be used to get subsequent
618    results.  In this case, getkey_end() must be used to free the
619    search context.  If RETCTX is not NULL, then RET_KDBHD must be
620    NULL.
621
622    If PK is not NULL, the public key of the first result is returned
623    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
624    set, it is used to filter the search results.  See the
625    documentation for finish_lookup to understand exactly how this is
626    used.  Note: The self-signed data has already been merged into the
627    public key using merge_selfsigs.  Free *PK by calling
628    release_public_key_parts (or, if PK was allocated using xfree, you
629    can use free_public_key, which calls release_public_key_parts(PK)
630    and then xfree(PK)).
631
632    If NAMES is not NULL, then a search query is constructed using
633    classify_user_id on each of the strings in the list.  (Recall: the
634    database does an OR of the terms, not an AND.)  If NAMES is
635    NULL, then all results are returned.
636
637    If WANT_SECRET is set, then only keys with an available secret key
638    (either locally or via key registered on a smartcard) are returned.
639
640    This function does not skip unusable keys (see the documentation
641    for skip_unusable for an exact definition).
642
643    If RET_KEYBLOCK is not NULL, the keyblock is returned in
644    *RET_KEYBLOCK.  This should be freed using release_kbnode().
645
646    This function returns 0 on success.  Otherwise, an error code is
647    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
648    (if want_secret is set) is returned if the key is not found.  */
649 gpg_error_t getkey_bynames (getkey_ctx_t *retctx, PKT_public_key *pk,
650                             strlist_t names, int want_secret,
651                             kbnode_t *ret_keyblock);
652
653 /* Search for keys matching some criteria.
654
655    If RETCTX is not NULL, then the constructed context is returned in
656    *RETCTX so that getpubkey_next can be used to get subsequent
657    results.  In this case, getkey_end() must be used to free the
658    search context.  If RETCTX is not NULL, then RET_KDBHD must be
659    NULL.
660
661    If PK is not NULL, the public key of the first result is returned
662    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
663    set, it is used to filter the search results.  See the
664    documentation for finish_lookup to understand exactly how this is
665    used.  Note: The self-signed data has already been merged into the
666    public key using merge_selfsigs.  Free *PK by calling
667    release_public_key_parts (or, if PK was allocated using xfree, you
668    can use free_public_key, which calls release_public_key_parts(PK)
669    and then xfree(PK)).
670
671    If NAME is not NULL, then a search query is constructed using
672    classify_user_id on the string.  In this case, even unusable keys
673    (see the documentation for skip_unusable for an exact definition of
674    unusable) are returned.  Otherwise, if --default-key was set, then
675    that key is returned (even if it is unusable).  If neither of these
676    conditions holds, then the first usable key is returned.
677
678    If WANT_SECRET is set, then only keys with an available secret key
679    (either locally or via key registered on a smartcard) are returned.
680
681    This function does not skip unusable keys (see the documentation
682    for skip_unusable for an exact definition).
683
684    If RET_KEYBLOCK is not NULL, the keyblock is returned in
685    *RET_KEYBLOCK.  This should be freed using release_kbnode().
686
687    This function returns 0 on success.  Otherwise, an error code is
688    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
689    (if want_secret is set) is returned if the key is not found.
690
691    FIXME: We also have the get_pubkey_byname function which has a
692    different semantic.  Should be merged with this one.  */
693 gpg_error_t getkey_byname (ctrl_t ctrl,
694                            getkey_ctx_t *retctx, PKT_public_key *pk,
695                            const char *name, int want_secret,
696                            kbnode_t *ret_keyblock);
697
698 /* Return the next search result.
699
700    If PK is not NULL, the public key of the next result is returned in
701    *PK.  Note: The self-signed data has already been merged into the
702    public key using merge_selfsigs.  Free *PK by calling
703    release_public_key_parts (or, if PK was allocated using xfree, you
704    can use free_public_key, which calls release_public_key_parts(PK)
705    and then xfree(PK)).
706
707    The self-signed data has already been merged into the public key
708    using merge_selfsigs.  */
709 gpg_error_t getkey_next (getkey_ctx_t ctx, PKT_public_key *pk,
710                          kbnode_t *ret_keyblock);
711
712 /* Release any resources used by a key listing content.  This must be
713    called on the context returned by, e.g., getkey_byname.  */
714 void getkey_end (getkey_ctx_t ctx);
715
716 /* Return the database handle used by this context.  The context still
717    owns the handle.  */
718 KEYDB_HANDLE get_ctx_handle(GETKEY_CTX ctx);
719
720 /* Enumerate some secret keys (specifically, those specified with
721    --default-key and --try-secret-key).  Use the following procedure:
722
723     1) Initialize a void pointer to NULL
724     2) Pass a reference to this pointer to this function (content)
725        and provide space for the secret key (sk)
726     3) Call this function as long as it does not return an error (or
727        until you are done).  The error code GPG_ERR_EOF indicates the
728        end of the listing.
729     4) Call this function a last time with SK set to NULL,
730        so that can free it's context.
731
732    In pseudo-code:
733
734      void *ctx = NULL;
735      PKT_public_key *sk = xmalloc_clear (sizeof (*sk));
736      gpg_error_t err;
737
738      while ((err = enum_secret_keys (&ctx, sk)))
739        {
740          // Process SK.
741
742          if (done)
743            break;
744
745          free_public_key (sk);
746          sk = xmalloc_clear (sizeof (*sk));
747        }
748
749      // Release any resources used by CTX.
750      enum_secret_keys (&ctx, NULL);
751      free_public_key (sk);
752
753      if (gpg_err_code (err) != GPG_ERR_EOF)
754        ; // An error occurred.
755  */
756 gpg_error_t enum_secret_keys (ctrl_t ctrl, void **context, PKT_public_key *pk);
757
758 /* Set the mainkey_id fields for all keys in KEYBLOCK.  This is
759    usually done by merge_selfsigs but at some places we only need the
760    main_kid not a full merge.  The function also guarantees that all
761    pk->keyids are computed. */
762 void setup_main_keyids (kbnode_t keyblock);
763
764 /* KEYBLOCK corresponds to a public key block.  This function merges
765    much of the information from the self-signed data into the public
766    key, public subkey and user id data structures.  If you use the
767    high-level search API (e.g., get_pubkey) for looking up key blocks,
768    then you don't need to call this function.  This function is
769    useful, however, if you change the keyblock, e.g., by adding or
770    removing a self-signed data packet.  */
771 void merge_keys_and_selfsig( KBNODE keyblock );
772
773 char*get_user_id_string_native( u32 *keyid );
774 char*get_long_user_id_string( u32 *keyid );
775 char*get_user_id( u32 *keyid, size_t *rn );
776 char*get_user_id_native( u32 *keyid );
777 char *get_user_id_byfpr (const byte *fpr, size_t *rn);
778 char *get_user_id_byfpr_native (const byte *fpr);
779
780 void release_akl(void);
781 int parse_auto_key_locate(char *options);
782
783 /*-- keyid.c --*/
784 int pubkey_letter( int algo );
785 char *pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize);
786 #define PUBKEY_STRING_SIZE 32
787 u32 v3_keyid (gcry_mpi_t a, u32 *ki);
788 void hash_public_key( gcry_md_hd_t md, PKT_public_key *pk );
789 const char *format_keyid (u32 *keyid, int format, char *buffer, int len);
790 size_t keystrlen(void);
791 const char *keystr(u32 *keyid);
792 const char *keystr_with_sub (u32 *main_kid, u32 *sub_kid);
793 const char *keystr_from_pk(PKT_public_key *pk);
794 const char *keystr_from_pk_with_sub (PKT_public_key *main_pk,
795                                      PKT_public_key *sub_pk);
796 const char *keystr_from_desc(KEYDB_SEARCH_DESC *desc);
797 u32 keyid_from_pk( PKT_public_key *pk, u32 *keyid );
798 u32 keyid_from_sig( PKT_signature *sig, u32 *keyid );
799 u32 keyid_from_fingerprint(const byte *fprint, size_t fprint_len, u32 *keyid);
800 byte *namehash_from_uid(PKT_user_id *uid);
801 unsigned nbits_from_pk( PKT_public_key *pk );
802 const char *datestr_from_pk( PKT_public_key *pk );
803 const char *datestr_from_sig( PKT_signature *sig );
804 const char *expirestr_from_pk( PKT_public_key *pk );
805 const char *expirestr_from_sig( PKT_signature *sig );
806 const char *revokestr_from_pk( PKT_public_key *pk );
807 const char *usagestr_from_pk (PKT_public_key *pk, int fill);
808 const char *colon_strtime (u32 t);
809 const char *colon_datestr_from_pk (PKT_public_key *pk);
810 const char *colon_datestr_from_sig (PKT_signature *sig);
811 const char *colon_expirestr_from_sig (PKT_signature *sig);
812 byte *fingerprint_from_pk( PKT_public_key *pk, byte *buf, size_t *ret_len );
813 char *hexfingerprint (PKT_public_key *pk, char *buffer, size_t buflen);
814 char *format_hexfingerprint (const char *fingerprint,
815                              char *buffer, size_t buflen);
816 gpg_error_t keygrip_from_pk (PKT_public_key *pk, unsigned char *array);
817 gpg_error_t hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip);
818
819
820 /*-- kbnode.c --*/
821 KBNODE new_kbnode( PACKET *pkt );
822 KBNODE clone_kbnode( KBNODE node );
823 void release_kbnode( KBNODE n );
824 void delete_kbnode( KBNODE node );
825 void add_kbnode( KBNODE root, KBNODE node );
826 void insert_kbnode( KBNODE root, KBNODE node, int pkttype );
827 void move_kbnode( KBNODE *root, KBNODE node, KBNODE where );
828 void remove_kbnode( KBNODE *root, KBNODE node );
829 KBNODE find_prev_kbnode( KBNODE root, KBNODE node, int pkttype );
830 KBNODE find_next_kbnode( KBNODE node, int pkttype );
831 KBNODE find_kbnode( KBNODE node, int pkttype );
832 KBNODE walk_kbnode( KBNODE root, KBNODE *context, int all );
833 void clear_kbnode_flags( KBNODE n );
834 int  commit_kbnode( KBNODE *root );
835 void dump_kbnode( KBNODE node );
836
837 #endif /*G10_KEYDB_H*/