gpg: Change keydb_search to not return legacy keys.
[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.  A database handle is similar to a
190    file handle: it contains a local file position.  This is used when
191    searching: subsequent searches resume where the previous search
192    left off.  To rewind the position, use keydb_search_reset().  */
193 KEYDB_HANDLE keydb_new (void);
194
195 /* Free all resources owned by the database handle.  */
196 void keydb_release (KEYDB_HANDLE hd);
197
198 /* Set a flag on the handle to suppress use of cached results.  This
199    is required for updating a keyring and for key listings.  Fixme:
200    Using a new parameter for keydb_new might be a better solution.  */
201 void keydb_disable_caching (KEYDB_HANDLE hd);
202
203 /* Save the last found state and invalidate the current selection
204    (i.e., the entry selected by keydb_search() is invalidated and
205    something like keydb_get_keyblock() will return an error).  This
206    does not change the file position.  This makes it possible to do
207    something like:
208
209      keydb_search (hd, ...);  // Result 1.
210      keydb_push_found_state (hd);
211        keydb_search_reset (hd);
212        keydb_search (hd, ...);  // Result 2.
213      keydb_pop_found_state (hd);
214      keydb_get_keyblock (hd, ...);  // -> Result 1.
215
216    Note: it is only possible to save a single save state at a time.
217    In other words, the the save stack only has room for a single
218    instance of the state.  */
219 void keydb_push_found_state (KEYDB_HANDLE hd);
220
221 /* Restore the previous save state.  If the saved state is invalid,
222    this is equivalent to */
223 void keydb_pop_found_state (KEYDB_HANDLE hd);
224
225 /* Return the file name of the resource in which the current search
226    result was found or, if there is no search result, the filename of
227    the current resource (i.e., the resource that the file position
228    points to).  Note: the filename is not necessarily the URL used to
229    open it!
230
231    This function only returns NULL if no handle is specified, in all
232    other error cases an empty string is returned.  */
233 const char *keydb_get_resource_name (KEYDB_HANDLE hd);
234
235 /* Return the keyblock last found by keydb_search() in *RET_KB.
236
237    On success, the function returns 0 and the caller must free *RET_KB
238    using release_kbnode().  Otherwise, the function returns an error
239    code.
240
241    The returned keyblock has the kbnode flag bit 0 set for the node
242    with the public key used to locate the keyblock or flag bit 1 set
243    for the user ID node.  */
244 gpg_error_t keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb);
245
246 /* Replace the currently selected keyblock (i.e., the last result
247    returned by keydb_search) with the key block in KB.
248
249    This doesn't do anything if --dry-run was specified.
250
251    Returns 0 on success.  Otherwise, it returns an error code.  */
252 gpg_error_t keydb_update_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
253
254 /* Insert a keyblock into one of the underlying keyrings or keyboxes.
255
256    Be default, the keyring / keybox from which the last search result
257    came is used.  If there was no previous search result (or
258    keydb_search_reset was called), then the keyring / keybox where the
259    next search would start is used (i.e., the current file position).
260
261    Note: this doesn't do anything if --dry-run was specified.
262
263    Returns 0 on success.  Otherwise, it returns an error code.  */
264 gpg_error_t keydb_insert_keyblock (KEYDB_HANDLE hd, kbnode_t kb);
265
266 /* Delete the currently selected keyblock.  If you haven't done a
267    search yet on this database handle (or called keydb_search_reset),
268    then this will return an error.
269
270    Returns 0 on success or an error code, if an error occurs.  */
271 gpg_error_t keydb_delete_keyblock (KEYDB_HANDLE hd);
272
273 /* A database may consists of multiple keyrings / key boxes.  This
274    sets the "file position" to the start of the first keyring / key
275    box that is writable (i.e., doesn't have the read-only flag set).
276
277    This first tries the primary keyring (the last keyring (not
278    keybox!) added using keydb_add_resource() and with
279    KEYDB_RESOURCE_FLAG_PRIMARY set).  If that is not writable, then it
280    tries the keyrings / keyboxes in the order in which they were
281    added.  */
282 gpg_error_t keydb_locate_writable (KEYDB_HANDLE hd);
283
284 /* Rebuild the on-disk caches of all key resources.  */
285 void keydb_rebuild_caches (int noisy);
286
287 /* Return the number of skipped blocks (because they were to large to
288    read from a keybox) since the last search reset.  */
289 unsigned long keydb_get_skipped_counter (KEYDB_HANDLE hd);
290
291 /* Clears the current search result and resets the handle's position
292    so that the next search starts at the beginning of the database
293    (the start of the first resource).
294
295    Returns 0 on success and an error code if an error occurred.
296    (Currently, this function always returns 0 if HD is valid.)  */
297 gpg_error_t keydb_search_reset (KEYDB_HANDLE hd);
298
299 /* Search the database for keys matching the search description.  If
300    the DB contains any legacy keys, these are silently ignored.
301
302    DESC is an array of search terms with NDESC entries.  The search
303    terms are or'd together.  That is, the next entry in the DB that
304    matches any of the descriptions will be returned.
305
306    Note: this function resumes searching where the last search left
307    off (i.e., at the current file position).  If you want to search
308    from the start of the database, then you need to first call
309    keydb_search_reset().
310
311    If no key matches the search description, returns
312    GPG_ERR_NOT_FOUND.  If there was a match, returns 0.  If an error
313    occurred, returns an error code.
314
315    The returned key is considered to be selected and the raw data can,
316    for instance, be returned by calling keydb_get_keyblock().  */
317 gpg_error_t keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
318                           size_t ndesc, size_t *descindex);
319
320 /* Return the first non-legacy key in the database.
321
322    If you want the very first key in the database, you can directly
323    call keydb_search with the search description
324    KEYDB_SEARCH_MODE_FIRST.  */
325 gpg_error_t keydb_search_first (KEYDB_HANDLE hd);
326
327 /* Return the next key (not the next matching key!).
328
329    Unlike calling keydb_search with KEYDB_SEARCH_MODE_NEXT, this
330    function silently skips legacy keys.  */
331 gpg_error_t keydb_search_next (KEYDB_HANDLE hd);
332
333 /* This is a convenience function for searching for keys with a long
334    key id.
335
336    Note: this function resumes searching where the last search left
337    off.  If you want to search the whole database, then you need to
338    first call keydb_search_reset().  */
339 gpg_error_t keydb_search_kid (KEYDB_HANDLE hd, u32 *kid);
340
341 /* This is a convenience function for searching for keys with a long
342    (20 byte) fingerprint.
343
344    Note: this function resumes searching where the last search left
345    off.  If you want to search the whole database, then you need to
346    first call keydb_search_reset().  */
347 gpg_error_t keydb_search_fpr (KEYDB_HANDLE hd, const byte *fpr);
348
349
350 /*-- pkclist.c --*/
351 void show_revocation_reason( PKT_public_key *pk, int mode );
352 int  check_signatures_trust( PKT_signature *sig );
353
354 void release_pk_list (PK_LIST pk_list);
355 int  build_pk_list (ctrl_t ctrl,
356                     strlist_t rcpts, PK_LIST *ret_pk_list, unsigned use);
357 gpg_error_t find_and_check_key (ctrl_t ctrl,
358                                 const char *name, unsigned int use,
359                                 int mark_hidden, pk_list_t *pk_list_addr);
360
361 int  algo_available( preftype_t preftype, int algo,
362                      const union pref_hint *hint );
363 int  select_algo_from_prefs( PK_LIST pk_list, int preftype,
364                              int request, const union pref_hint *hint);
365 int  select_mdc_from_pklist (PK_LIST pk_list);
366 void warn_missing_mdc_from_pklist (PK_LIST pk_list);
367 void warn_missing_aes_from_pklist (PK_LIST pk_list);
368
369 /*-- skclist.c --*/
370 int  random_is_faked (void);
371 void release_sk_list( SK_LIST sk_list );
372 gpg_error_t build_sk_list (ctrl_t ctrl, strlist_t locusr,
373                            SK_LIST *ret_sk_list, unsigned use);
374
375 /*-- passphrase.h --*/
376 unsigned char encode_s2k_iterations (int iterations);
377 assuan_context_t agent_open (int try, const char *orig_codeset);
378 void agent_close (assuan_context_t ctx);
379 int  have_static_passphrase(void);
380 const char *get_static_passphrase (void);
381 void set_passphrase_from_string(const char *pass);
382 void read_passphrase_from_fd( int fd );
383 void passphrase_clear_cache ( u32 *keyid, const char *cacheid, int algo );
384 DEK *passphrase_to_dek_ext(u32 *keyid, int pubkey_algo,
385                            int cipher_algo, STRING2KEY *s2k, int mode,
386                            const char *tryagain_text,
387                            const char *custdesc, const char *custprompt,
388                            int *canceled);
389 DEK *passphrase_to_dek( u32 *keyid, int pubkey_algo,
390                         int cipher_algo, STRING2KEY *s2k, int mode,
391                         const char *tryagain_text, int *canceled);
392 void set_next_passphrase( const char *s );
393 char *get_last_passphrase(void);
394 void next_to_last_passphrase(void);
395
396 void emit_status_need_passphrase (u32 *keyid, u32 *mainkeyid, int pubkey_algo);
397
398 #define FORMAT_KEYDESC_NORMAL  0
399 #define FORMAT_KEYDESC_IMPORT  1
400 #define FORMAT_KEYDESC_EXPORT  2
401 #define FORMAT_KEYDESC_DELKEY  3
402 char *gpg_format_keydesc (PKT_public_key *pk, int mode, int escaped);
403
404
405 /*-- getkey.c --*/
406
407 /* Cache a copy of a public key in the public key cache.  PK is not
408    cached if caching is disabled (via getkey_disable_caches), if
409    PK->FLAGS.DONT_CACHE is set, we don't know how to derive a key id
410    from the public key (e.g., unsupported algorithm), or a key with
411    the key id is already in the cache.
412
413    The public key packet is copied into the cache using
414    copy_public_key.  Thus, any secret parts are not copied, for
415    instance.
416
417    This cache is filled by get_pubkey and is read by get_pubkey and
418    get_pubkey_fast.  */
419 void cache_public_key( PKT_public_key *pk );
420
421 /* Disable and drop the public key cache (which is filled by
422    cache_public_key and get_pubkey).  Note: there is currently no way
423    to reenable this cache.  */
424 void getkey_disable_caches(void);
425
426 /* Return the public key with the key id KEYID and store it in *PK.
427    The resources in *PK should be released using
428    release_public_key_parts().  This function also stores a copy of
429    the public key in the user id cache (see cache_public_key).
430
431    If PK is NULL, this function just stores the public key in the
432    cache and returns the usual return code.
433
434    PK->REQ_USAGE (which is a mask of PUBKEY_USAGE_SIG,
435    PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT) is passed through to the
436    lookup function.  If this is non-zero, only keys with the specified
437    usage will be returned.  As such, it is essential that
438    PK->REQ_USAGE be correctly initialized!
439
440    Returns 0 on success, GPG_ERR_NO_PUBKEY if there is no public key
441    with the specified key id, or another error code if an error
442    occurs.
443
444    If the data was not read from the cache, then the self-signed data
445    has definitely been merged into the public key using
446    merge_selfsigs.  */
447 int get_pubkey( PKT_public_key *pk, u32 *keyid );
448
449 /* Similar to get_pubkey, but it does not take PK->REQ_USAGE into
450    account nor does it merge in the self-signed data.  This function
451    also only considers primary keys.  It is intended to be used as a
452    quick check of the key to avoid recursion.  It should only be used
453    in very certain cases.  Like get_pubkey and unlike any of the other
454    lookup functions, this function also consults the user id cache
455    (see cache_public_key).
456
457    Return the public key in *PK.  The resources in *PK should be
458    released using release_public_key_parts().  */
459 int get_pubkey_fast ( PKT_public_key *pk, u32 *keyid );
460
461 /* Return the key block for the key with key id KEYID or NULL, if an
462    error occurs.  Use release_kbnode() to release the key block.
463
464    The self-signed data has already been merged into the public key
465    using merge_selfsigs.  */
466 KBNODE get_pubkeyblock( u32 *keyid );
467
468 /* Find a public key identified by the name NAME.
469
470    If name appears to be a valid valid RFC822 mailbox (i.e., email
471    address) and auto key lookup is enabled (no_akl == 0), then the
472    specified auto key lookup methods (--auto-key-lookup) are used to
473    import the key into the local keyring.  Otherwise, just the local
474    keyring is consulted.
475
476
477    If RETCTX is not NULL, then the constructed context is returned in
478    *RETCTX so that getpubkey_next can be used to get subsequent
479    results.  In this case, getkey_end() must be used to free the
480    search context.  If RETCTX is not NULL, then RET_KDBHD must be
481    NULL.
482
483    If PK is not NULL, the public key of the first result is returned
484    in *PK.  Note: PK->REQ_USAGE must be valid!!!  PK->REQ_USAGE is
485    passed through to the lookup function and is a mask of
486    PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  If this
487    is non-zero, only keys with the specified usage will be returned.
488    Note: The self-signed data has already been merged into the public
489    key using merge_selfsigs.  Free *PK by calling
490    release_public_key_parts (or, if PK was allocated using xfree, you
491    can use free_public_key, which calls release_public_key_parts(PK)
492    and then xfree(PK)).
493
494    NAME is a string, which is turned into a search query using
495    classify_user_id.
496
497    If RET_KEYBLOCK is not NULL, the keyblock is returned in
498    *RET_KEYBLOCK.  This should be freed using release_kbnode().
499
500    If RET_KDBHD is not NULL, then the new database handle used to
501    conduct the search is returned in *RET_KDBHD.  This can be used to
502    get subsequent results using keydb_search_next or to modify the
503    returned record.  Note: in this case, no advanced filtering is done
504    for subsequent results (e.g., PK->REQ_USAGE is not respected).
505    Unlike RETCTX, this is always returned.
506
507    If INCLUDE_UNUSABLE is set, then unusable keys (see the
508    documentation for skip_unusable for an exact definition) are
509    skipped unless they are looked up by key id or by fingerprint.
510
511    If NO_AKL is set, then the auto key locate functionality is
512    disabled and only the local key ring is considered.  Note: the
513    local key ring is consulted even if local is not in the
514    --auto-key-locate option list!
515
516    This function returns 0 on success.  Otherwise, an error code is
517    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
518    (if want_secret is set) is returned if the key is not found.  */
519 int get_pubkey_byname (ctrl_t ctrl,
520                        GETKEY_CTX *retctx, PKT_public_key *pk,
521                        const char *name,
522                        KBNODE *ret_keyblock, KEYDB_HANDLE *ret_kdbhd,
523                        int include_unusable, int no_akl );
524
525 /* Return the public key with the key id KEYID and store it in *PK.
526    The resources should be released using release_public_key_parts().
527
528    Unlike other lookup functions, PK may not be NULL.  PK->REQ_USAGE
529    is passed through to the lookup function and is a mask of
530    PUBKEY_USAGE_SIG, PUBKEY_USAGE_ENC and PUBKEY_USAGE_CERT.  Thus, it
531    must be valid!  If this is non-zero, only keys with the specified
532    usage will be returned.
533
534    Returns 0 on success.  If a public key with the specified key id is
535    not found or a secret key is not available for that public key, an
536    error code is returned.  Note: this function ignores legacy keys.
537    An error code is also return if an error occurs.
538
539    The self-signed data has already been merged into the public key
540    using merge_selfsigs.  */
541 gpg_error_t get_seckey (PKT_public_key *pk, u32 *keyid);
542
543 /* Lookup a key with the specified fingerprint.
544
545    If PK is not NULL, the public key of the first result is returned
546    in *PK.  Note: this function does an exact search and thus the
547    returned public key may be a subkey rather than the primary key.
548    Note: The self-signed data has already been merged into the public
549    key using merge_selfsigs.  Free *PK by calling
550    release_public_key_parts (or, if PK was allocated using xfree, you
551    can use free_public_key, which calls release_public_key_parts(PK)
552    and then xfree(PK)).
553
554    If PK->REQ_USAGE is set, it is used to filter the search results.
555    (Thus, if PK is not NULL, PK->REQ_USAGE must be valid!!!)  See the
556    documentation for finish_lookup to understand exactly how this is
557    used.
558
559    If R_KEYBLOCK is not NULL, then the first result's keyblock is
560    returned in *R_KEYBLOCK.  This should be freed using
561    release_kbnode().
562
563    FPRINT is a byte array whose contents is the fingerprint to use as
564    the search term.  FPRINT_LEN specifies the length of the
565    fingerprint (in bytes).  Currently, only 16 and 20-byte
566    fingerprints are supported.  */
567 int get_pubkey_byfprint (PKT_public_key *pk,  kbnode_t *r_keyblock,
568                          const byte *fprint, size_t fprint_len);
569
570 /* This function is similar to get_pubkey_byfprint, but it doesn't
571    merge the self-signed data into the public key and subkeys or into
572    the user ids.  It also doesn't add the key to the user id cache.
573    Further, this function ignores PK->REQ_USAGE.
574
575    This function is intended to avoid recursion and, as such, should
576    only be used in very specific situations.
577
578    Like get_pubkey_byfprint, PK may be NULL.  In that case, this
579    function effectively just checks for the existence of the key.  */
580 int get_pubkey_byfprint_fast (PKT_public_key *pk,
581                               const byte *fprint, size_t fprint_len);
582
583 /* Return whether a secret key is available for the public key with
584    key id KEYID.  This function ignores legacy keys.  Note: this is
585    just a fast check and does not tell us whether the secret key is
586    valid; this check merely indicates whether there is some secret key
587    with the specified key id.  */
588 int have_secret_key_with_kid (u32 *keyid);
589
590 /* Parse the --default-key parameter.  Returns the last key (in terms
591    of when the option is given) that is available.  */
592 const char *parse_def_secret_key (ctrl_t ctrl);
593
594 /* Look up a secret key.
595
596    If PK is not NULL, the public key of the first result is returned
597    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
598    set, it is used to filter the search results.  See the
599    documentation for finish_lookup to understand exactly how this is
600    used.  Note: The self-signed data has already been merged into the
601    public key using merge_selfsigs.  Free *PK by calling
602    release_public_key_parts (or, if PK was allocated using xfree, you
603    can use free_public_key, which calls release_public_key_parts(PK)
604    and then xfree(PK)).
605
606    If --default-key was set, then the specified key is looked up.  (In
607    this case, the default key is returned even if it is considered
608    unusable.  See the documentation for skip_unusable for exactly what
609    this means.)
610
611    Otherwise, this initiates a DB scan that returns all keys that are
612    usable (see previous paragraph for exactly what usable means) and
613    for which a secret key is available.
614
615    This function returns the first match.  Additional results can be
616    returned using getkey_next.  */
617 gpg_error_t get_seckey_default (ctrl_t ctrl, PKT_public_key *pk);
618
619 /* Search for keys matching some criteria.
620
621    If RETCTX is not NULL, then the constructed context is returned in
622    *RETCTX so that getpubkey_next can be used to get subsequent
623    results.  In this case, getkey_end() must be used to free the
624    search context.  If RETCTX is not NULL, then RET_KDBHD must be
625    NULL.
626
627    If PK is not NULL, the public key of the first result is returned
628    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
629    set, it is used to filter the search results.  See the
630    documentation for finish_lookup to understand exactly how this is
631    used.  Note: The self-signed data has already been merged into the
632    public key using merge_selfsigs.  Free *PK by calling
633    release_public_key_parts (or, if PK was allocated using xfree, you
634    can use free_public_key, which calls release_public_key_parts(PK)
635    and then xfree(PK)).
636
637    If NAMES is not NULL, then a search query is constructed using
638    classify_user_id on each of the strings in the list.  (Recall: the
639    database does an OR of the terms, not an AND.)  If NAMES is
640    NULL, then all results are returned.
641
642    If WANT_SECRET is set, then only keys with an available secret key
643    (either locally or via key registered on a smartcard) are returned.
644
645    This function does not skip unusable keys (see the documentation
646    for skip_unusable for an exact definition).
647
648    If RET_KEYBLOCK is not NULL, the keyblock is returned in
649    *RET_KEYBLOCK.  This should be freed using release_kbnode().
650
651    This function returns 0 on success.  Otherwise, an error code is
652    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
653    (if want_secret is set) is returned if the key is not found.  */
654 gpg_error_t getkey_bynames (getkey_ctx_t *retctx, PKT_public_key *pk,
655                             strlist_t names, int want_secret,
656                             kbnode_t *ret_keyblock);
657
658 /* Search for keys matching some criteria.
659
660    If RETCTX is not NULL, then the constructed context is returned in
661    *RETCTX so that getpubkey_next can be used to get subsequent
662    results.  In this case, getkey_end() must be used to free the
663    search context.  If RETCTX is not NULL, then RET_KDBHD must be
664    NULL.
665
666    If PK is not NULL, the public key of the first result is returned
667    in *PK.  Note: PK->REQ_USAGE must be valid!!!  If PK->REQ_USAGE is
668    set, it is used to filter the search results.  See the
669    documentation for finish_lookup to understand exactly how this is
670    used.  Note: The self-signed data has already been merged into the
671    public key using merge_selfsigs.  Free *PK by calling
672    release_public_key_parts (or, if PK was allocated using xfree, you
673    can use free_public_key, which calls release_public_key_parts(PK)
674    and then xfree(PK)).
675
676    If NAME is not NULL, then a search query is constructed using
677    classify_user_id on the string.  In this case, even unusable keys
678    (see the documentation for skip_unusable for an exact definition of
679    unusable) are returned.  Otherwise, if --default-key was set, then
680    that key is returned (even if it is unusable).  If neither of these
681    conditions holds, then the first usable key is returned.
682
683    If WANT_SECRET is set, then only keys with an available secret key
684    (either locally or via key registered on a smartcard) are returned.
685
686    This function does not skip unusable keys (see the documentation
687    for skip_unusable for an exact definition).
688
689    If RET_KEYBLOCK is not NULL, the keyblock is returned in
690    *RET_KEYBLOCK.  This should be freed using release_kbnode().
691
692    This function returns 0 on success.  Otherwise, an error code is
693    returned.  In particular, GPG_ERR_NO_PUBKEY or GPG_ERR_NO_SECKEY
694    (if want_secret is set) is returned if the key is not found.
695
696    FIXME: We also have the get_pubkey_byname function which has a
697    different semantic.  Should be merged with this one.  */
698 gpg_error_t getkey_byname (ctrl_t ctrl,
699                            getkey_ctx_t *retctx, PKT_public_key *pk,
700                            const char *name, int want_secret,
701                            kbnode_t *ret_keyblock);
702
703 /* Return the next search result.
704
705    If PK is not NULL, the public key of the next result is returned in
706    *PK.  Note: The self-signed data has already been merged into the
707    public key using merge_selfsigs.  Free *PK by calling
708    release_public_key_parts (or, if PK was allocated using xfree, you
709    can use free_public_key, which calls release_public_key_parts(PK)
710    and then xfree(PK)).
711
712    The self-signed data has already been merged into the public key
713    using merge_selfsigs.  */
714 gpg_error_t getkey_next (getkey_ctx_t ctx, PKT_public_key *pk,
715                          kbnode_t *ret_keyblock);
716
717 /* Release any resources used by a key listing content.  This must be
718    called on the context returned by, e.g., getkey_byname.  */
719 void getkey_end (getkey_ctx_t ctx);
720
721 /* Return the database handle used by this context.  The context still
722    owns the handle.  */
723 KEYDB_HANDLE get_ctx_handle(GETKEY_CTX ctx);
724
725 /* Enumerate some secret keys (specifically, those specified with
726    --default-key and --try-secret-key).  Use the following procedure:
727
728     1) Initialize a void pointer to NULL
729     2) Pass a reference to this pointer to this function (content)
730        and provide space for the secret key (sk)
731     3) Call this function as long as it does not return an error (or
732        until you are done).  The error code GPG_ERR_EOF indicates the
733        end of the listing.
734     4) Call this function a last time with SK set to NULL,
735        so that can free it's context.
736
737    In pseudo-code:
738
739      void *ctx = NULL;
740      PKT_public_key *sk = xmalloc_clear (sizeof (*sk));
741      gpg_error_t err;
742
743      while ((err = enum_secret_keys (&ctx, sk)))
744        {
745          // Process SK.
746
747          if (done)
748            break;
749
750          free_public_key (sk);
751          sk = xmalloc_clear (sizeof (*sk));
752        }
753
754      // Release any resources used by CTX.
755      enum_secret_keys (&ctx, NULL);
756      free_public_key (sk);
757
758      if (gpg_err_code (err) != GPG_ERR_EOF)
759        ; // An error occurred.
760  */
761 gpg_error_t enum_secret_keys (ctrl_t ctrl, void **context, PKT_public_key *pk);
762
763 /* Set the mainkey_id fields for all keys in KEYBLOCK.  This is
764    usually done by merge_selfsigs but at some places we only need the
765    main_kid not a full merge.  The function also guarantees that all
766    pk->keyids are computed. */
767 void setup_main_keyids (kbnode_t keyblock);
768
769 /* KEYBLOCK corresponds to a public key block.  This function merges
770    much of the information from the self-signed data into the public
771    key, public subkey and user id data structures.  If you use the
772    high-level search API (e.g., get_pubkey) for looking up key blocks,
773    then you don't need to call this function.  This function is
774    useful, however, if you change the keyblock, e.g., by adding or
775    removing a self-signed data packet.  */
776 void merge_keys_and_selfsig( KBNODE keyblock );
777
778 char*get_user_id_string_native( u32 *keyid );
779 char*get_long_user_id_string( u32 *keyid );
780 char*get_user_id( u32 *keyid, size_t *rn );
781 char*get_user_id_native( u32 *keyid );
782 char *get_user_id_byfpr (const byte *fpr, size_t *rn);
783 char *get_user_id_byfpr_native (const byte *fpr);
784
785 void release_akl(void);
786 int parse_auto_key_locate(char *options);
787
788 /*-- keyid.c --*/
789 int pubkey_letter( int algo );
790 char *pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize);
791 #define PUBKEY_STRING_SIZE 32
792 u32 v3_keyid (gcry_mpi_t a, u32 *ki);
793 void hash_public_key( gcry_md_hd_t md, PKT_public_key *pk );
794 const char *format_keyid (u32 *keyid, int format, char *buffer, int len);
795 size_t keystrlen(void);
796 const char *keystr(u32 *keyid);
797 const char *keystr_with_sub (u32 *main_kid, u32 *sub_kid);
798 const char *keystr_from_pk(PKT_public_key *pk);
799 const char *keystr_from_pk_with_sub (PKT_public_key *main_pk,
800                                      PKT_public_key *sub_pk);
801 const char *keystr_from_desc(KEYDB_SEARCH_DESC *desc);
802 u32 keyid_from_pk( PKT_public_key *pk, u32 *keyid );
803 u32 keyid_from_sig( PKT_signature *sig, u32 *keyid );
804 u32 keyid_from_fingerprint(const byte *fprint, size_t fprint_len, u32 *keyid);
805 byte *namehash_from_uid(PKT_user_id *uid);
806 unsigned nbits_from_pk( PKT_public_key *pk );
807 const char *datestr_from_pk( PKT_public_key *pk );
808 const char *datestr_from_sig( PKT_signature *sig );
809 const char *expirestr_from_pk( PKT_public_key *pk );
810 const char *expirestr_from_sig( PKT_signature *sig );
811 const char *revokestr_from_pk( PKT_public_key *pk );
812 const char *usagestr_from_pk (PKT_public_key *pk, int fill);
813 const char *colon_strtime (u32 t);
814 const char *colon_datestr_from_pk (PKT_public_key *pk);
815 const char *colon_datestr_from_sig (PKT_signature *sig);
816 const char *colon_expirestr_from_sig (PKT_signature *sig);
817 byte *fingerprint_from_pk( PKT_public_key *pk, byte *buf, size_t *ret_len );
818 char *hexfingerprint (PKT_public_key *pk, char *buffer, size_t buflen);
819 char *format_hexfingerprint (const char *fingerprint,
820                              char *buffer, size_t buflen);
821 gpg_error_t keygrip_from_pk (PKT_public_key *pk, unsigned char *array);
822 gpg_error_t hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip);
823
824
825 /*-- kbnode.c --*/
826 KBNODE new_kbnode( PACKET *pkt );
827 KBNODE clone_kbnode( KBNODE node );
828 void release_kbnode( KBNODE n );
829 void delete_kbnode( KBNODE node );
830 void add_kbnode( KBNODE root, KBNODE node );
831 void insert_kbnode( KBNODE root, KBNODE node, int pkttype );
832 void move_kbnode( KBNODE *root, KBNODE node, KBNODE where );
833 void remove_kbnode( KBNODE *root, KBNODE node );
834 KBNODE find_prev_kbnode( KBNODE root, KBNODE node, int pkttype );
835 KBNODE find_next_kbnode( KBNODE node, int pkttype );
836 KBNODE find_kbnode( KBNODE node, int pkttype );
837 KBNODE walk_kbnode( KBNODE root, KBNODE *context, int all );
838 void clear_kbnode_flags( KBNODE n );
839 int  commit_kbnode( KBNODE *root );
840 void dump_kbnode( KBNODE node );
841
842 #endif /*G10_KEYDB_H*/