gpg: Remove unused arg from a function.
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - Edit properties of a key
2  * Copyright (C) 1998-2010 Free Software Foundation, Inc.
3  * Copyright (C) 1998-2017 Werner Koch
4  * Copyright (C) 2015, 2016 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 <https://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27 #include <ctype.h>
28 #ifdef HAVE_LIBREADLINE
29 # define GNUPG_LIBREADLINE_H_INCLUDED
30 # include <readline/readline.h>
31 #endif
32
33 #include "gpg.h"
34 #include "options.h"
35 #include "packet.h"
36 #include "../common/status.h"
37 #include "../common/iobuf.h"
38 #include "keydb.h"
39 #include "photoid.h"
40 #include "../common/util.h"
41 #include "main.h"
42 #include "trustdb.h"
43 #include "filter.h"
44 #include "../common/ttyio.h"
45 #include "../common/status.h"
46 #include "../common/i18n.h"
47 #include "keyserver-internal.h"
48 #include "call-agent.h"
49 #include "../common/host2net.h"
50 #include "tofu.h"
51 #include "key-check.h"
52 #include "key-clean.h"
53 #include "keyedit.h"
54
55 static void show_prefs (PKT_user_id * uid, PKT_signature * selfsig,
56                         int verbose);
57 static void show_names (ctrl_t ctrl, estream_t fp,
58                         kbnode_t keyblock, PKT_public_key * pk,
59                         unsigned int flag, int with_prefs);
60 static void show_key_with_all_names (ctrl_t ctrl, estream_t fp,
61                                      KBNODE keyblock, int only_marked,
62                                      int with_revoker, int with_fpr,
63                                      int with_subkeys, int with_prefs,
64                                      int nowarn);
65 static void show_key_and_fingerprint (ctrl_t ctrl,
66                                       kbnode_t keyblock, int with_subkeys);
67 static void show_key_and_grip (kbnode_t keyblock);
68 static void subkey_expire_warning (kbnode_t keyblock);
69 static int menu_adduid (ctrl_t ctrl, kbnode_t keyblock,
70                         int photo, const char *photo_name, const char *uidstr);
71 static void menu_deluid (KBNODE pub_keyblock);
72 static int menu_delsig (ctrl_t ctrl, kbnode_t pub_keyblock);
73 static int menu_clean (ctrl_t ctrl, kbnode_t keyblock, int self_only);
74 static void menu_delkey (KBNODE pub_keyblock);
75 static int menu_addrevoker (ctrl_t ctrl, kbnode_t pub_keyblock, int sensitive);
76 static gpg_error_t menu_expire (ctrl_t ctrl, kbnode_t pub_keyblock,
77                                 int unattended, u32 newexpiration);
78 static int menu_changeusage (ctrl_t ctrl, kbnode_t keyblock);
79 static int menu_backsign (ctrl_t ctrl, kbnode_t pub_keyblock);
80 static int menu_set_primary_uid (ctrl_t ctrl, kbnode_t pub_keyblock);
81 static int menu_set_preferences (ctrl_t ctrl, kbnode_t pub_keyblock);
82 static int menu_set_keyserver_url (ctrl_t ctrl,
83                                    const char *url, kbnode_t pub_keyblock);
84 static int menu_set_notation (ctrl_t ctrl,
85                               const char *string, kbnode_t pub_keyblock);
86 static int menu_select_uid (KBNODE keyblock, int idx);
87 static int menu_select_uid_namehash (KBNODE keyblock, const char *namehash);
88 static int menu_select_key (KBNODE keyblock, int idx, char *p);
89 static int count_uids (KBNODE keyblock);
90 static int count_uids_with_flag (KBNODE keyblock, unsigned flag);
91 static int count_keys_with_flag (KBNODE keyblock, unsigned flag);
92 static int count_selected_uids (KBNODE keyblock);
93 static int real_uids_left (KBNODE keyblock);
94 static int count_selected_keys (KBNODE keyblock);
95 static int menu_revsig (ctrl_t ctrl, kbnode_t keyblock);
96 static int menu_revuid (ctrl_t ctrl, kbnode_t keyblock);
97 static int core_revuid (ctrl_t ctrl, kbnode_t keyblock, KBNODE node,
98                         const struct revocation_reason_info *reason,
99                         int *modified);
100 static int menu_revkey (ctrl_t ctrl, kbnode_t pub_keyblock);
101 static int menu_revsubkey (ctrl_t ctrl, kbnode_t pub_keyblock);
102 #ifndef NO_TRUST_MODELS
103 static int enable_disable_key (ctrl_t ctrl, kbnode_t keyblock, int disable);
104 #endif /*!NO_TRUST_MODELS*/
105 static void menu_showphoto (ctrl_t ctrl, kbnode_t keyblock);
106
107 static int update_trust = 0;
108
109 #define CONTROL_D ('D' - 'A' + 1)
110
111 struct sign_attrib
112 {
113   int non_exportable, non_revocable;
114   struct revocation_reason_info *reason;
115   byte trust_depth, trust_value;
116   char *trust_regexp;
117 };
118
119
120
121 /* TODO: Fix duplicated code between here and the check-sigs/list-sigs
122    code in keylist.c. */
123 static int
124 print_and_check_one_sig_colon (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
125                                int *inv_sigs, int *no_key, int *oth_err,
126                                int *is_selfsig, int print_without_key)
127 {
128   PKT_signature *sig = node->pkt->pkt.signature;
129   int rc, sigrc;
130
131   /* TODO: Make sure a cached sig record here still has the pk that
132      issued it.  See also keylist.c:list_keyblock_print */
133
134   rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
135   switch (gpg_err_code (rc))
136     {
137     case 0:
138       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
139       sigrc = '!';
140       break;
141     case GPG_ERR_BAD_SIGNATURE:
142       node->flag = NODFLG_BADSIG;
143       sigrc = '-';
144       if (inv_sigs)
145         ++ * inv_sigs;
146       break;
147     case GPG_ERR_NO_PUBKEY:
148     case GPG_ERR_UNUSABLE_PUBKEY:
149       node->flag = NODFLG_NOKEY;
150       sigrc = '?';
151       if (no_key)
152         ++ * no_key;
153       break;
154     default:
155       node->flag = NODFLG_SIGERR;
156       sigrc = '%';
157       if (oth_err)
158         ++ * oth_err;
159       break;
160     }
161
162   if (sigrc != '?' || print_without_key)
163     {
164       es_printf ("sig:%c::%d:%08lX%08lX:%lu:%lu:",
165                  sigrc, sig->pubkey_algo, (ulong) sig->keyid[0],
166                  (ulong) sig->keyid[1], (ulong) sig->timestamp,
167                  (ulong) sig->expiredate);
168
169       if (sig->trust_depth || sig->trust_value)
170         es_printf ("%d %d", sig->trust_depth, sig->trust_value);
171
172       es_printf (":");
173
174       if (sig->trust_regexp)
175         es_write_sanitized (es_stdout,
176                             sig->trust_regexp, strlen (sig->trust_regexp),
177                             ":", NULL);
178
179       es_printf ("::%02x%c\n", sig->sig_class,
180                  sig->flags.exportable ? 'x' : 'l');
181
182       if (opt.show_subpackets)
183         print_subpackets_colon (sig);
184     }
185
186   return (sigrc == '!');
187 }
188
189
190 /*
191  * Print information about a signature (rc is its status), check it
192  * and return true if the signature is okay.  NODE must be a signature
193  * packet.  With EXTENDED set all possible signature list options will
194  * always be printed.
195  */
196 int
197 keyedit_print_one_sig (ctrl_t ctrl, estream_t fp,
198                        int rc, kbnode_t keyblock, kbnode_t node,
199                        int *inv_sigs, int *no_key, int *oth_err,
200                        int is_selfsig, int print_without_key, int extended)
201 {
202   PKT_signature *sig = node->pkt->pkt.signature;
203   int sigrc;
204   int is_rev = sig->sig_class == 0x30;
205
206   /* TODO: Make sure a cached sig record here still has the pk that
207      issued it.  See also keylist.c:list_keyblock_print */
208
209   switch (gpg_err_code (rc))
210     {
211     case 0:
212       node->flag &= ~(NODFLG_BADSIG | NODFLG_NOKEY | NODFLG_SIGERR);
213       sigrc = '!';
214       break;
215     case GPG_ERR_BAD_SIGNATURE:
216       node->flag = NODFLG_BADSIG;
217       sigrc = '-';
218       if (inv_sigs)
219         ++ * inv_sigs;
220       break;
221     case GPG_ERR_NO_PUBKEY:
222     case GPG_ERR_UNUSABLE_PUBKEY:
223       node->flag = NODFLG_NOKEY;
224       sigrc = '?';
225       if (no_key)
226         ++ * no_key;
227       break;
228     default:
229       node->flag = NODFLG_SIGERR;
230       sigrc = '%';
231       if (oth_err)
232         ++ * oth_err;
233       break;
234     }
235   if (sigrc != '?' || print_without_key)
236     {
237       tty_fprintf (fp, "%s%c%c %c%c%c%c%c%c %s %s",
238                   is_rev ? "rev" : "sig", sigrc,
239                   (sig->sig_class - 0x10 > 0 &&
240                    sig->sig_class - 0x10 <
241                    4) ? '0' + sig->sig_class - 0x10 : ' ',
242                   sig->flags.exportable ? ' ' : 'L',
243                   sig->flags.revocable ? ' ' : 'R',
244                   sig->flags.policy_url ? 'P' : ' ',
245                   sig->flags.notation ? 'N' : ' ',
246                   sig->flags.expired ? 'X' : ' ',
247                   (sig->trust_depth > 9) ? 'T' : (sig->trust_depth >
248                                                   0) ? '0' +
249                   sig->trust_depth : ' ',
250                   keystr (sig->keyid),
251                   datestr_from_sig (sig));
252       if ((opt.list_options & LIST_SHOW_SIG_EXPIRE) || extended )
253         tty_fprintf (fp, " %s", expirestr_from_sig (sig));
254       tty_fprintf (fp, "  ");
255       if (sigrc == '%')
256         tty_fprintf (fp, "[%s] ", gpg_strerror (rc));
257       else if (sigrc == '?')
258         ;
259       else if (is_selfsig)
260         {
261           tty_fprintf (fp, is_rev ? _("[revocation]") : _("[self-signature]"));
262           if (extended && sig->flags.chosen_selfsig)
263             tty_fprintf (fp, "*");
264         }
265       else
266         {
267           size_t n;
268           char *p = get_user_id (ctrl, sig->keyid, &n, NULL);
269           tty_print_utf8_string2 (fp, p, n,
270                                   opt.screen_columns - keystrlen () - 26 -
271                                   ((opt.
272                                     list_options & LIST_SHOW_SIG_EXPIRE) ? 11
273                                    : 0));
274           xfree (p);
275         }
276       if (fp == log_get_stream ())
277         log_printf ("\n");
278       else
279         tty_fprintf (fp, "\n");
280
281       if (sig->flags.policy_url
282           && ((opt.list_options & LIST_SHOW_POLICY_URLS) || extended))
283         show_policy_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));
284
285       if (sig->flags.notation
286           && ((opt.list_options & LIST_SHOW_NOTATIONS) || extended))
287         show_notation (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0),
288                        ((opt.
289                          list_options & LIST_SHOW_STD_NOTATIONS) ? 1 : 0) +
290                        ((opt.
291                          list_options & LIST_SHOW_USER_NOTATIONS) ? 2 : 0));
292
293       if (sig->flags.pref_ks
294           && ((opt.list_options & LIST_SHOW_KEYSERVER_URLS) || extended))
295         show_keyserver_url (sig, 3, (!fp? -1 : fp == log_get_stream ()? 1 : 0));
296
297       if (extended)
298         {
299           PKT_public_key *pk = keyblock->pkt->pkt.public_key;
300           const unsigned char *s;
301
302           s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_PRIMARY_UID, NULL);
303           if (s && *s)
304             tty_fprintf (fp, "             [primary]\n");
305
306           s = parse_sig_subpkt (sig->hashed, SIGSUBPKT_KEY_EXPIRE, NULL);
307           if (s && buf32_to_u32 (s))
308             tty_fprintf (fp, "             [expires: %s]\n",
309                          isotimestamp (pk->timestamp + buf32_to_u32 (s)));
310         }
311     }
312
313   return (sigrc == '!');
314 }
315
316
317 static int
318 print_and_check_one_sig (ctrl_t ctrl, kbnode_t keyblock, kbnode_t node,
319                          int *inv_sigs, int *no_key, int *oth_err,
320                          int *is_selfsig, int print_without_key, int extended)
321 {
322   int rc;
323
324   rc = check_key_signature (ctrl, keyblock, node, is_selfsig);
325   return keyedit_print_one_sig (ctrl, NULL, rc,
326                                 keyblock, node, inv_sigs, no_key, oth_err,
327                                 *is_selfsig, print_without_key, extended);
328 }
329
330
331 static int
332 sign_mk_attrib (PKT_signature * sig, void *opaque)
333 {
334   struct sign_attrib *attrib = opaque;
335   byte buf[8];
336
337   if (attrib->non_exportable)
338     {
339       buf[0] = 0;               /* not exportable */
340       build_sig_subpkt (sig, SIGSUBPKT_EXPORTABLE, buf, 1);
341     }
342
343   if (attrib->non_revocable)
344     {
345       buf[0] = 0;               /* not revocable */
346       build_sig_subpkt (sig, SIGSUBPKT_REVOCABLE, buf, 1);
347     }
348
349   if (attrib->reason)
350     revocation_reason_build_cb (sig, attrib->reason);
351
352   if (attrib->trust_depth)
353     {
354       /* Not critical.  If someone doesn't understand trust sigs,
355          this can still be a valid regular signature. */
356       buf[0] = attrib->trust_depth;
357       buf[1] = attrib->trust_value;
358       build_sig_subpkt (sig, SIGSUBPKT_TRUST, buf, 2);
359
360       /* Critical.  If someone doesn't understands regexps, this
361          whole sig should be invalid.  Note the +1 for the length -
362          regexps are null terminated. */
363       if (attrib->trust_regexp)
364         build_sig_subpkt (sig, SIGSUBPKT_FLAG_CRITICAL | SIGSUBPKT_REGEXP,
365                           attrib->trust_regexp,
366                           strlen (attrib->trust_regexp) + 1);
367     }
368
369   return 0;
370 }
371
372
373 static void
374 trustsig_prompt (byte * trust_value, byte * trust_depth, char **regexp)
375 {
376   char *p;
377
378   *trust_value = 0;
379   *trust_depth = 0;
380   *regexp = NULL;
381
382   /* Same string as pkclist.c:do_edit_ownertrust */
383   tty_printf (_
384               ("Please decide how far you trust this user to correctly verify"
385                " other users' keys\n(by looking at passports, checking"
386                " fingerprints from different sources, etc.)\n"));
387   tty_printf ("\n");
388   tty_printf (_("  %d = I trust marginally\n"), 1);
389   tty_printf (_("  %d = I trust fully\n"), 2);
390   tty_printf ("\n");
391
392   while (*trust_value == 0)
393     {
394       p = cpr_get ("trustsig_prompt.trust_value", _("Your selection? "));
395       trim_spaces (p);
396       cpr_kill_prompt ();
397       /* 60 and 120 are as per RFC2440 */
398       if (p[0] == '1' && !p[1])
399         *trust_value = 60;
400       else if (p[0] == '2' && !p[1])
401         *trust_value = 120;
402       xfree (p);
403     }
404
405   tty_printf ("\n");
406
407   tty_printf (_("Please enter the depth of this trust signature.\n"
408                 "A depth greater than 1 allows the key you are"
409                 " signing to make\n"
410                 "trust signatures on your behalf.\n"));
411   tty_printf ("\n");
412
413   while (*trust_depth == 0)
414     {
415       p = cpr_get ("trustsig_prompt.trust_depth", _("Your selection? "));
416       trim_spaces (p);
417       cpr_kill_prompt ();
418       *trust_depth = atoi (p);
419       xfree (p);
420     }
421
422   tty_printf ("\n");
423
424   tty_printf (_("Please enter a domain to restrict this signature, "
425                 "or enter for none.\n"));
426
427   tty_printf ("\n");
428
429   p = cpr_get ("trustsig_prompt.trust_regexp", _("Your selection? "));
430   trim_spaces (p);
431   cpr_kill_prompt ();
432
433   if (strlen (p) > 0)
434     {
435       char *q = p;
436       int regexplen = 100, ind;
437
438       *regexp = xmalloc (regexplen);
439
440       /* Now mangle the domain the user entered into a regexp.  To do
441          this, \-escape everything that isn't alphanumeric, and attach
442          "<[^>]+[@.]" to the front, and ">$" to the end. */
443
444       strcpy (*regexp, "<[^>]+[@.]");
445       ind = strlen (*regexp);
446
447       while (*q)
448         {
449           if (!((*q >= 'A' && *q <= 'Z')
450                 || (*q >= 'a' && *q <= 'z') || (*q >= '0' && *q <= '9')))
451             (*regexp)[ind++] = '\\';
452
453           (*regexp)[ind++] = *q;
454
455           if ((regexplen - ind) < 3)
456             {
457               regexplen += 100;
458               *regexp = xrealloc (*regexp, regexplen);
459             }
460
461           q++;
462         }
463
464       (*regexp)[ind] = '\0';
465       strcat (*regexp, ">$");
466     }
467
468   xfree (p);
469   tty_printf ("\n");
470 }
471
472
473 /*
474  * Loop over all LOCUSR and sign the uids after asking.  If no
475  * user id is marked, all user ids will be signed; if some user_ids
476  * are marked only those will be signed.  If QUICK is true the
477  * function won't ask the user and use sensible defaults.
478  */
479 static int
480 sign_uids (ctrl_t ctrl, estream_t fp,
481            kbnode_t keyblock, strlist_t locusr, int *ret_modified,
482            int local, int nonrevocable, int trust, int interactive,
483            int quick)
484 {
485   int rc = 0;
486   SK_LIST sk_list = NULL;
487   SK_LIST sk_rover = NULL;
488   PKT_public_key *pk = NULL;
489   KBNODE node, uidnode;
490   PKT_public_key *primary_pk = NULL;
491   int select_all = !count_selected_uids (keyblock) || interactive;
492
493   /* Build a list of all signators.
494    *
495    * We use the CERT flag to request the primary which must always
496    * be one which is capable of signing keys.  I can't see a reason
497    * why to sign keys using a subkey.  Implementation of USAGE_CERT
498    * is just a hack in getkey.c and does not mean that a subkey
499    * marked as certification capable will be used. */
500   rc = build_sk_list (ctrl, locusr, &sk_list, PUBKEY_USAGE_CERT);
501   if (rc)
502     goto leave;
503
504   /* Loop over all signators.  */
505   for (sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next)
506     {
507       u32 sk_keyid[2], pk_keyid[2];
508       char *p, *trust_regexp = NULL;
509       int class = 0, selfsig = 0;
510       u32 duration = 0, timestamp = 0;
511       byte trust_depth = 0, trust_value = 0;
512
513       pk = sk_rover->pk;
514       keyid_from_pk (pk, sk_keyid);
515
516       /* Set mark A for all selected user ids.  */
517       for (node = keyblock; node; node = node->next)
518         {
519           if (select_all || (node->flag & NODFLG_SELUID))
520             node->flag |= NODFLG_MARK_A;
521           else
522             node->flag &= ~NODFLG_MARK_A;
523         }
524
525       /* Reset mark for uids which are already signed.  */
526       uidnode = NULL;
527       for (node = keyblock; node; node = node->next)
528         {
529           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
530             {
531               primary_pk = node->pkt->pkt.public_key;
532               keyid_from_pk (primary_pk, pk_keyid);
533
534               /* Is this a self-sig? */
535               if (pk_keyid[0] == sk_keyid[0] && pk_keyid[1] == sk_keyid[1])
536                 selfsig = 1;
537             }
538           else if (node->pkt->pkttype == PKT_USER_ID)
539             {
540               uidnode = (node->flag & NODFLG_MARK_A) ? node : NULL;
541               if (uidnode)
542                 {
543                   int yesreally = 0;
544                   char *user;
545
546                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
547                                          uidnode->pkt->pkt.user_id->len, 0);
548
549                   if (opt.only_sign_text_ids
550                       && uidnode->pkt->pkt.user_id->attribs)
551                     {
552                       tty_fprintf (fp, _("Skipping user ID \"%s\","
553                                          " which is not a text ID.\n"),
554                                    user);
555                       uidnode->flag &= ~NODFLG_MARK_A;
556                       uidnode = NULL;
557                     }
558                   else if (uidnode->pkt->pkt.user_id->flags.revoked)
559                     {
560                       tty_fprintf (fp, _("User ID \"%s\" is revoked."), user);
561
562                       if (selfsig)
563                         tty_fprintf (fp, "\n");
564                       else if (opt.expert && !quick)
565                         {
566                           tty_fprintf (fp, "\n");
567                           /* No, so remove the mark and continue */
568                           if (!cpr_get_answer_is_yes ("sign_uid.revoke_okay",
569                                                       _("Are you sure you "
570                                                         "still want to sign "
571                                                         "it? (y/N) ")))
572                             {
573                               uidnode->flag &= ~NODFLG_MARK_A;
574                               uidnode = NULL;
575                             }
576                           else if (interactive)
577                             yesreally = 1;
578                         }
579                       else
580                         {
581                           uidnode->flag &= ~NODFLG_MARK_A;
582                           uidnode = NULL;
583                           tty_fprintf (fp, _("  Unable to sign.\n"));
584                         }
585                     }
586                   else if (uidnode->pkt->pkt.user_id->flags.expired)
587                     {
588                       tty_fprintf (fp, _("User ID \"%s\" is expired."), user);
589
590                       if (selfsig)
591                         tty_fprintf (fp, "\n");
592                       else if (opt.expert && !quick)
593                         {
594                           tty_fprintf (fp, "\n");
595                           /* No, so remove the mark and continue */
596                           if (!cpr_get_answer_is_yes ("sign_uid.expire_okay",
597                                                       _("Are you sure you "
598                                                         "still want to sign "
599                                                         "it? (y/N) ")))
600                             {
601                               uidnode->flag &= ~NODFLG_MARK_A;
602                               uidnode = NULL;
603                             }
604                           else if (interactive)
605                             yesreally = 1;
606                         }
607                       else
608                         {
609                           uidnode->flag &= ~NODFLG_MARK_A;
610                           uidnode = NULL;
611                           tty_fprintf (fp, _("  Unable to sign.\n"));
612                         }
613                     }
614                   else if (!uidnode->pkt->pkt.user_id->created && !selfsig)
615                     {
616                       tty_fprintf (fp, _("User ID \"%s\" is not self-signed."),
617                                    user);
618
619                       if (opt.expert && !quick)
620                         {
621                           tty_fprintf (fp, "\n");
622                           /* No, so remove the mark and continue */
623                           if (!cpr_get_answer_is_yes ("sign_uid.nosig_okay",
624                                                       _("Are you sure you "
625                                                         "still want to sign "
626                                                         "it? (y/N) ")))
627                             {
628                               uidnode->flag &= ~NODFLG_MARK_A;
629                               uidnode = NULL;
630                             }
631                           else if (interactive)
632                             yesreally = 1;
633                         }
634                       else
635                         {
636                           uidnode->flag &= ~NODFLG_MARK_A;
637                           uidnode = NULL;
638                           tty_fprintf (fp, _("  Unable to sign.\n"));
639                         }
640                     }
641
642                   if (uidnode && interactive && !yesreally && !quick)
643                     {
644                       tty_fprintf (fp,
645                                    _("User ID \"%s\" is signable.  "), user);
646                       if (!cpr_get_answer_is_yes ("sign_uid.sign_okay",
647                                                   _("Sign it? (y/N) ")))
648                         {
649                           uidnode->flag &= ~NODFLG_MARK_A;
650                           uidnode = NULL;
651                         }
652                     }
653
654                   xfree (user);
655                 }
656             }
657           else if (uidnode && node->pkt->pkttype == PKT_SIGNATURE
658                    && (node->pkt->pkt.signature->sig_class & ~3) == 0x10)
659             {
660               if (sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
661                   && sk_keyid[1] == node->pkt->pkt.signature->keyid[1])
662                 {
663                   char buf[50];
664                   char *user;
665
666                   user = utf8_to_native (uidnode->pkt->pkt.user_id->name,
667                                          uidnode->pkt->pkt.user_id->len, 0);
668
669                   /* It's a v3 self-sig.  Make it into a v4 self-sig? */
670                   if (node->pkt->pkt.signature->version < 4
671                       && selfsig && !quick)
672                     {
673                       tty_fprintf (fp,
674                                    _("The self-signature on \"%s\"\n"
675                                      "is a PGP 2.x-style signature.\n"), user);
676
677                       /* Note that the regular PGP2 warning below
678                          still applies if there are no v4 sigs on
679                          this key at all. */
680
681                       if (opt.expert)
682                         if (cpr_get_answer_is_yes ("sign_uid.v4_promote_okay",
683                                                    _("Do you want to promote "
684                                                      "it to an OpenPGP self-"
685                                                      "signature? (y/N) ")))
686                           {
687                             node->flag |= NODFLG_DELSIG;
688                             xfree (user);
689                             continue;
690                           }
691                     }
692
693                   /* Is the current signature expired? */
694                   if (node->pkt->pkt.signature->flags.expired)
695                     {
696                       tty_fprintf (fp, _("Your current signature on \"%s\"\n"
697                                          "has expired.\n"), user);
698
699                       if (quick || cpr_get_answer_is_yes
700                           ("sign_uid.replace_expired_okay",
701                            _("Do you want to issue a "
702                              "new signature to replace "
703                              "the expired one? (y/N) ")))
704                         {
705                           /* Mark these for later deletion.  We
706                              don't want to delete them here, just in
707                              case the replacement signature doesn't
708                              happen for some reason.  We only delete
709                              these after the replacement is already
710                              in place. */
711
712                           node->flag |= NODFLG_DELSIG;
713                           xfree (user);
714                           continue;
715                         }
716                     }
717
718                   if (!node->pkt->pkt.signature->flags.exportable && !local)
719                     {
720                       /* It's a local sig, and we want to make a
721                          exportable sig. */
722                       tty_fprintf (fp, _("Your current signature on \"%s\"\n"
723                                          "is a local signature.\n"), user);
724
725                       if (quick || cpr_get_answer_is_yes
726                           ("sign_uid.local_promote_okay",
727                            _("Do you want to promote "
728                              "it to a full exportable " "signature? (y/N) ")))
729                         {
730                           /* Mark these for later deletion.  We
731                              don't want to delete them here, just in
732                              case the replacement signature doesn't
733                              happen for some reason.  We only delete
734                              these after the replacement is already
735                              in place. */
736
737                           node->flag |= NODFLG_DELSIG;
738                           xfree (user);
739                           continue;
740                         }
741                     }
742
743                   /* Fixme: see whether there is a revocation in which
744                    * case we should allow signing it again. */
745                   if (!node->pkt->pkt.signature->flags.exportable && local)
746                     tty_fprintf ( fp,
747                        _("\"%s\" was already locally signed by key %s\n"),
748                        user, keystr_from_pk (pk));
749                   else
750                     tty_fprintf (fp,
751                                 _("\"%s\" was already signed by key %s\n"),
752                                 user, keystr_from_pk (pk));
753
754                   if (opt.expert && !quick
755                       && cpr_get_answer_is_yes ("sign_uid.dupe_okay",
756                                                 _("Do you want to sign it "
757                                                   "again anyway? (y/N) ")))
758                     {
759                       /* Don't delete the old sig here since this is
760                          an --expert thing. */
761                       xfree (user);
762                       continue;
763                     }
764
765                   snprintf (buf, sizeof buf, "%08lX%08lX",
766                             (ulong) pk->keyid[0], (ulong) pk->keyid[1]);
767                   write_status_text (STATUS_ALREADY_SIGNED, buf);
768                   uidnode->flag &= ~NODFLG_MARK_A;      /* remove mark */
769
770                   xfree (user);
771                 }
772             }
773         }
774
775       /* Check whether any uids are left for signing.  */
776       if (!count_uids_with_flag (keyblock, NODFLG_MARK_A))
777         {
778           tty_fprintf (fp, _("Nothing to sign with key %s\n"),
779                       keystr_from_pk (pk));
780           continue;
781         }
782
783       /* Ask whether we really should sign these user id(s). */
784       tty_fprintf (fp, "\n");
785       show_key_with_all_names (ctrl, fp, keyblock, 1, 0, 1, 0, 0, 0);
786       tty_fprintf (fp, "\n");
787
788       if (primary_pk->expiredate && !selfsig)
789         {
790           /* Static analyzer note: A claim that PRIMARY_PK might be
791              NULL is not correct because it set from the public key
792              packet which is always the first packet in a keyblock and
793              parsed in the above loop over the keyblock.  In case the
794              keyblock has no packets at all and thus the loop was not
795              entered the above count_uids_with_flag would have
796              detected this case.  */
797
798           u32 now = make_timestamp ();
799
800           if (primary_pk->expiredate <= now)
801             {
802               tty_fprintf (fp, _("This key has expired!"));
803
804               if (opt.expert && !quick)
805                 {
806                   tty_fprintf (fp, "  ");
807                   if (!cpr_get_answer_is_yes ("sign_uid.expired_okay",
808                                               _("Are you sure you still "
809                                                 "want to sign it? (y/N) ")))
810                     continue;
811                 }
812               else
813                 {
814                   tty_fprintf (fp, _("  Unable to sign.\n"));
815                   continue;
816                 }
817             }
818           else
819             {
820               tty_fprintf (fp, _("This key is due to expire on %s.\n"),
821                            expirestr_from_pk (primary_pk));
822
823               if (opt.ask_cert_expire && !quick)
824                 {
825                   char *answer = cpr_get ("sign_uid.expire",
826                                           _("Do you want your signature to "
827                                             "expire at the same time? (Y/n) "));
828                   if (answer_is_yes_no_default (answer, 1))
829                     {
830                       /* This fixes the signature timestamp we're
831                          going to make as now.  This is so the
832                          expiration date is exactly correct, and not
833                          a few seconds off (due to the time it takes
834                          to answer the questions, enter the
835                          passphrase, etc). */
836                       timestamp = now;
837                       duration = primary_pk->expiredate - now;
838                     }
839
840                   cpr_kill_prompt ();
841                   xfree (answer);
842                 }
843             }
844         }
845
846       /* Only ask for duration if we haven't already set it to match
847          the expiration of the pk */
848       if (!duration && !selfsig)
849         {
850           if (opt.ask_cert_expire && !quick)
851             duration = ask_expire_interval (1, opt.def_cert_expire);
852           else
853             duration = parse_expire_string (opt.def_cert_expire);
854         }
855
856       if (selfsig)
857         ;
858       else
859         {
860           if (opt.batch || !opt.ask_cert_level || quick)
861             class = 0x10 + opt.def_cert_level;
862           else
863             {
864               char *answer;
865
866               tty_fprintf (fp,
867                            _("How carefully have you verified the key you are "
868                             "about to sign actually belongs\nto the person "
869                             "named above?  If you don't know what to "
870                             "answer, enter \"0\".\n"));
871               tty_fprintf (fp, "\n");
872               tty_fprintf (fp, _("   (0) I will not answer.%s\n"),
873                           opt.def_cert_level == 0 ? " (default)" : "");
874               tty_fprintf (fp, _("   (1) I have not checked at all.%s\n"),
875                           opt.def_cert_level == 1 ? " (default)" : "");
876               tty_fprintf (fp, _("   (2) I have done casual checking.%s\n"),
877                           opt.def_cert_level == 2 ? " (default)" : "");
878               tty_fprintf (fp,
879                            _("   (3) I have done very careful checking.%s\n"),
880                           opt.def_cert_level == 3 ? " (default)" : "");
881               tty_fprintf (fp, "\n");
882
883               while (class == 0)
884                 {
885                   answer = cpr_get ("sign_uid.class",
886                                     _("Your selection? "
887                                       "(enter '?' for more information): "));
888                   if (answer[0] == '\0')
889                     class = 0x10 + opt.def_cert_level;  /* Default */
890                   else if (ascii_strcasecmp (answer, "0") == 0)
891                     class = 0x10;       /* Generic */
892                   else if (ascii_strcasecmp (answer, "1") == 0)
893                     class = 0x11;       /* Persona */
894                   else if (ascii_strcasecmp (answer, "2") == 0)
895                     class = 0x12;       /* Casual */
896                   else if (ascii_strcasecmp (answer, "3") == 0)
897                     class = 0x13;       /* Positive */
898                   else
899                     tty_fprintf (fp, _("Invalid selection.\n"));
900
901                   xfree (answer);
902                 }
903             }
904
905           if (trust && !quick)
906             trustsig_prompt (&trust_value, &trust_depth, &trust_regexp);
907         }
908
909       if (!quick)
910         {
911           p = get_user_id_native (ctrl, sk_keyid);
912           tty_fprintf (fp,
913                    _("Are you sure that you want to sign this key with your\n"
914                      "key \"%s\" (%s)\n"), p, keystr_from_pk (pk));
915           xfree (p);
916         }
917
918       if (selfsig)
919         {
920           tty_fprintf (fp, "\n");
921           tty_fprintf (fp, _("This will be a self-signature.\n"));
922
923           if (local)
924             {
925               tty_fprintf (fp, "\n");
926               tty_fprintf (fp, _("WARNING: the signature will not be marked "
927                                  "as non-exportable.\n"));
928             }
929
930           if (nonrevocable)
931             {
932               tty_fprintf (fp, "\n");
933               tty_fprintf (fp, _("WARNING: the signature will not be marked "
934                                  "as non-revocable.\n"));
935             }
936         }
937       else
938         {
939           if (local)
940             {
941               tty_fprintf (fp, "\n");
942               tty_fprintf (fp,
943                  _("The signature will be marked as non-exportable.\n"));
944             }
945
946           if (nonrevocable)
947             {
948               tty_fprintf (fp, "\n");
949               tty_fprintf (fp,
950                  _("The signature will be marked as non-revocable.\n"));
951             }
952
953           switch (class)
954             {
955             case 0x11:
956               tty_fprintf (fp, "\n");
957               tty_fprintf (fp, _("I have not checked this key at all.\n"));
958               break;
959
960             case 0x12:
961               tty_fprintf (fp, "\n");
962               tty_fprintf (fp, _("I have checked this key casually.\n"));
963               break;
964
965             case 0x13:
966               tty_fprintf (fp, "\n");
967               tty_fprintf (fp, _("I have checked this key very carefully.\n"));
968               break;
969             }
970         }
971
972       tty_fprintf (fp, "\n");
973
974       if (opt.batch && opt.answer_yes)
975         ;
976       else if (quick)
977         ;
978       else if (!cpr_get_answer_is_yes ("sign_uid.okay",
979                                        _("Really sign? (y/N) ")))
980         continue;
981
982       /* Now we can sign the user ids.  */
983     reloop:  /* (Must use this, because we are modifying the list.)  */
984       primary_pk = NULL;
985       for (node = keyblock; node; node = node->next)
986         {
987           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
988             primary_pk = node->pkt->pkt.public_key;
989           else if (node->pkt->pkttype == PKT_USER_ID
990                    && (node->flag & NODFLG_MARK_A))
991             {
992               PACKET *pkt;
993               PKT_signature *sig;
994               struct sign_attrib attrib;
995
996               log_assert (primary_pk);
997               memset (&attrib, 0, sizeof attrib);
998               attrib.non_exportable = local;
999               attrib.non_revocable = nonrevocable;
1000               attrib.trust_depth = trust_depth;
1001               attrib.trust_value = trust_value;
1002               attrib.trust_regexp = trust_regexp;
1003               node->flag &= ~NODFLG_MARK_A;
1004
1005               /* We force creation of a v4 signature for local
1006                * signatures, otherwise we would not generate the
1007                * subpacket with v3 keys and the signature becomes
1008                * exportable.  */
1009
1010               if (selfsig)
1011                 rc = make_keysig_packet (ctrl, &sig, primary_pk,
1012                                          node->pkt->pkt.user_id,
1013                                          NULL,
1014                                          pk,
1015                                          0x13, 0, 0, 0,
1016                                          keygen_add_std_prefs, primary_pk,
1017                                          NULL);
1018               else
1019                 rc = make_keysig_packet (ctrl, &sig, primary_pk,
1020                                          node->pkt->pkt.user_id,
1021                                          NULL,
1022                                          pk,
1023                                          class, 0,
1024                                          timestamp, duration,
1025                                          sign_mk_attrib, &attrib,
1026                                          NULL);
1027               if (rc)
1028                 {
1029                   write_status_error ("keysig", rc);
1030                   log_error (_("signing failed: %s\n"), gpg_strerror (rc));
1031                   goto leave;
1032                 }
1033
1034               *ret_modified = 1;        /* We changed the keyblock. */
1035               update_trust = 1;
1036
1037               pkt = xmalloc_clear (sizeof *pkt);
1038               pkt->pkttype = PKT_SIGNATURE;
1039               pkt->pkt.signature = sig;
1040               insert_kbnode (node, new_kbnode (pkt), PKT_SIGNATURE);
1041               goto reloop;
1042             }
1043         }
1044
1045       /* Delete any sigs that got promoted */
1046       for (node = keyblock; node; node = node->next)
1047         if (node->flag & NODFLG_DELSIG)
1048           delete_kbnode (node);
1049     } /* End loop over signators.  */
1050
1051  leave:
1052   release_sk_list (sk_list);
1053   return rc;
1054 }
1055
1056
1057 /*
1058  * Change the passphrase of the primary and all secondary keys.  Note
1059  * that it is common to use only one passphrase for the primary and
1060  * all subkeys.  However, this is now (since GnuPG 2.1) all up to the
1061  * gpg-agent.  Returns 0 on success or an error code.
1062  */
1063 static gpg_error_t
1064 change_passphrase (ctrl_t ctrl, kbnode_t keyblock)
1065 {
1066   gpg_error_t err;
1067   kbnode_t node;
1068   PKT_public_key *pk;
1069   int any;
1070   u32 keyid[2], subid[2];
1071   char *hexgrip = NULL;
1072   char *cache_nonce = NULL;
1073   char *passwd_nonce = NULL;
1074
1075   node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
1076   if (!node)
1077     {
1078       log_error ("Oops; public key missing!\n");
1079       err = gpg_error (GPG_ERR_INTERNAL);
1080       goto leave;
1081     }
1082   pk = node->pkt->pkt.public_key;
1083   keyid_from_pk (pk, keyid);
1084
1085   /* Check whether it is likely that we will be able to change the
1086      passphrase for any subkey.  */
1087   for (any = 0, node = keyblock; node; node = node->next)
1088     {
1089       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1090           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1091         {
1092           char *serialno;
1093
1094           pk = node->pkt->pkt.public_key;
1095           keyid_from_pk (pk, subid);
1096
1097           xfree (hexgrip);
1098           err = hexkeygrip_from_pk (pk, &hexgrip);
1099           if (err)
1100             goto leave;
1101           err = agent_get_keyinfo (ctrl, hexgrip, &serialno, NULL);
1102           if (!err && serialno)
1103             ; /* Key on card.  */
1104           else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
1105             ; /* Maybe stub key. */
1106           else if (!err)
1107             any = 1; /* Key is known.  */
1108           else
1109             log_error ("key %s: error getting keyinfo from agent: %s\n",
1110                        keystr_with_sub (keyid, subid), gpg_strerror (err));
1111           xfree (serialno);
1112         }
1113     }
1114   err = 0;
1115   if (!any)
1116     {
1117       tty_printf (_("Key has only stub or on-card key items - "
1118                     "no passphrase to change.\n"));
1119       goto leave;
1120     }
1121
1122   /* Change the passphrase for all keys.  */
1123   for (node = keyblock; node; node = node->next)
1124     {
1125       if (node->pkt->pkttype == PKT_PUBLIC_KEY
1126           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
1127         {
1128           char *desc;
1129
1130           pk = node->pkt->pkt.public_key;
1131           keyid_from_pk (pk, subid);
1132
1133           xfree (hexgrip);
1134           err = hexkeygrip_from_pk (pk, &hexgrip);
1135           if (err)
1136             goto leave;
1137
1138           /* Note that when using --dry-run we don't change the
1139            * passphrase but merely verify the current passphrase.  */
1140           desc = gpg_format_keydesc (ctrl, pk, FORMAT_KEYDESC_NORMAL, 1);
1141           err = agent_passwd (ctrl, hexgrip, desc, !!opt.dry_run,
1142                               &cache_nonce, &passwd_nonce);
1143           xfree (desc);
1144
1145           if (err)
1146             log_log ((gpg_err_code (err) == GPG_ERR_CANCELED
1147                       || gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1148                      ? GPGRT_LOGLVL_INFO : GPGRT_LOGLVL_ERROR,
1149                      _("key %s: error changing passphrase: %s\n"),
1150                        keystr_with_sub (keyid, subid),
1151                        gpg_strerror (err));
1152           if (gpg_err_code (err) == GPG_ERR_FULLY_CANCELED)
1153             break;
1154         }
1155     }
1156
1157  leave:
1158   xfree (hexgrip);
1159   xfree (cache_nonce);
1160   xfree (passwd_nonce);
1161   return err;
1162 }
1163
1164
1165 \f
1166 /* Fix various problems in the keyblock.  Returns true if the keyblock
1167    was changed.  Note that a pointer to the keyblock must be given and
1168    the function may change it (i.e. replacing the first node).  */
1169 static int
1170 fix_keyblock (ctrl_t ctrl, kbnode_t *keyblockp)
1171 {
1172   int changed = 0;
1173
1174   if (collapse_uids (keyblockp))
1175     changed++;
1176   if (key_check_all_keysigs (ctrl, 1, *keyblockp, 0, 1))
1177     changed++;
1178   reorder_keyblock (*keyblockp);
1179   /* If we modified the keyblock, make sure the flags are right. */
1180   if (changed)
1181     merge_keys_and_selfsig (ctrl, *keyblockp);
1182
1183   return changed;
1184 }
1185
1186
1187 static int
1188 parse_sign_type (const char *str, int *localsig, int *nonrevokesig,
1189                  int *trustsig)
1190 {
1191   const char *p = str;
1192
1193   while (*p)
1194     {
1195       if (ascii_strncasecmp (p, "l", 1) == 0)
1196         {
1197           *localsig = 1;
1198           p++;
1199         }
1200       else if (ascii_strncasecmp (p, "nr", 2) == 0)
1201         {
1202           *nonrevokesig = 1;
1203           p += 2;
1204         }
1205       else if (ascii_strncasecmp (p, "t", 1) == 0)
1206         {
1207           *trustsig = 1;
1208           p++;
1209         }
1210       else
1211         return 0;
1212     }
1213
1214   return 1;
1215 }
1216
1217
1218 \f
1219 /*
1220  * Menu driven key editor.  If seckey_check is true, then a secret key
1221  * that matches username will be looked for.  If it is false, not all
1222  * commands will be available.
1223  *
1224  * Note: to keep track of certain selections we use node->mark MARKBIT_xxxx.
1225  */
1226
1227 /* Need an SK for this command */
1228 #define KEYEDIT_NEED_SK 1
1229 /* Need an SUB KEY for this command */
1230 #define KEYEDIT_NEED_SUBSK 2
1231 /* Match the tail of the string */
1232 #define KEYEDIT_TAIL_MATCH 8
1233
1234 enum cmdids
1235 {
1236   cmdNONE = 0,
1237   cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
1238   cmdREVSIG, cmdREVKEY, cmdREVUID, cmdDELSIG, cmdPRIMARY, cmdDEBUG,
1239   cmdSAVE, cmdADDUID, cmdADDPHOTO, cmdDELUID, cmdADDKEY, cmdDELKEY,
1240   cmdADDREVOKER, cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF,
1241   cmdEXPIRE, cmdCHANGEUSAGE, cmdBACKSIGN,
1242 #ifndef NO_TRUST_MODELS
1243   cmdENABLEKEY, cmdDISABLEKEY,
1244 #endif /*!NO_TRUST_MODELS*/
1245   cmdSHOWPREF,
1246   cmdSETPREF, cmdPREFKS, cmdNOTATION, cmdINVCMD, cmdSHOWPHOTO, cmdUPDTRUST,
1247   cmdCHKTRUST, cmdADDCARDKEY, cmdKEYTOCARD, cmdBKUPTOCARD,
1248   cmdCLEAN, cmdMINIMIZE, cmdGRIP, cmdNOP
1249 };
1250
1251 static struct
1252 {
1253   const char *name;
1254   enum cmdids id;
1255   int flags;
1256   const char *desc;
1257 } cmds[] =
1258 {
1259   { "quit", cmdQUIT, 0, N_("quit this menu")},
1260   { "q", cmdQUIT, 0, NULL},
1261   { "save", cmdSAVE, 0, N_("save and quit")},
1262   { "help", cmdHELP, 0, N_("show this help")},
1263   { "?", cmdHELP, 0, NULL},
1264   { "fpr", cmdFPR, 0, N_("show key fingerprint")},
1265   { "grip", cmdGRIP, 0, N_("show the keygrip")},
1266   { "list", cmdLIST, 0, N_("list key and user IDs")},
1267   { "l", cmdLIST, 0, NULL},
1268   { "uid", cmdSELUID, 0, N_("select user ID N")},
1269   { "key", cmdSELKEY, 0, N_("select subkey N")},
1270   { "check", cmdCHECK, 0, N_("check signatures")},
1271   { "c", cmdCHECK, 0, NULL},
1272   { "change-usage", cmdCHANGEUSAGE, KEYEDIT_NEED_SK, NULL},
1273   { "cross-certify", cmdBACKSIGN, KEYEDIT_NEED_SK, NULL},
1274   { "backsign", cmdBACKSIGN,  KEYEDIT_NEED_SK, NULL},
1275   { "sign", cmdSIGN,  KEYEDIT_TAIL_MATCH,
1276     N_("sign selected user IDs [* see below for related commands]")},
1277   { "s", cmdSIGN, 0, NULL},
1278     /* "lsign" and friends will never match since "sign" comes first
1279        and it is a tail match.  They are just here so they show up in
1280        the help menu. */
1281   { "lsign", cmdNOP, 0, N_("sign selected user IDs locally")},
1282   { "tsign", cmdNOP, 0, N_("sign selected user IDs with a trust signature")},
1283   { "nrsign", cmdNOP, 0,
1284     N_("sign selected user IDs with a non-revocable signature")},
1285   { "debug", cmdDEBUG, 0, NULL},
1286   { "adduid", cmdADDUID,  KEYEDIT_NEED_SK, N_("add a user ID")},
1287   { "addphoto", cmdADDPHOTO,  KEYEDIT_NEED_SK,
1288     N_("add a photo ID")},
1289   { "deluid", cmdDELUID, 0, N_("delete selected user IDs")},
1290     /* delphoto is really deluid in disguise */
1291   { "delphoto", cmdDELUID, 0, NULL},
1292   { "addkey", cmdADDKEY,  KEYEDIT_NEED_SK, N_("add a subkey")},
1293 #ifdef ENABLE_CARD_SUPPORT
1294   { "addcardkey", cmdADDCARDKEY,  KEYEDIT_NEED_SK,
1295     N_("add a key to a smartcard")},
1296   { "keytocard", cmdKEYTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1297     N_("move a key to a smartcard")},
1298   { "bkuptocard", cmdBKUPTOCARD, KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1299     N_("move a backup key to a smartcard")},
1300 #endif /*ENABLE_CARD_SUPPORT */
1301   { "delkey", cmdDELKEY, 0, N_("delete selected subkeys")},
1302   { "addrevoker", cmdADDREVOKER,  KEYEDIT_NEED_SK,
1303     N_("add a revocation key")},
1304   { "delsig", cmdDELSIG, 0,
1305     N_("delete signatures from the selected user IDs")},
1306   { "expire", cmdEXPIRE,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1307     N_("change the expiration date for the key or selected subkeys")},
1308   { "primary", cmdPRIMARY,  KEYEDIT_NEED_SK,
1309     N_("flag the selected user ID as primary")},
1310   { "toggle", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},  /* Dummy command.  */
1311   { "t", cmdTOGGLE, KEYEDIT_NEED_SK, NULL},
1312   { "pref", cmdPREF, 0, N_("list preferences (expert)")},
1313   { "showpref", cmdSHOWPREF, 0, N_("list preferences (verbose)")},
1314   { "setpref", cmdSETPREF,  KEYEDIT_NEED_SK,
1315     N_("set preference list for the selected user IDs")},
1316   { "updpref", cmdSETPREF,  KEYEDIT_NEED_SK, NULL},
1317   { "keyserver", cmdPREFKS,  KEYEDIT_NEED_SK,
1318     N_("set the preferred keyserver URL for the selected user IDs")},
1319   { "notation", cmdNOTATION,  KEYEDIT_NEED_SK,
1320     N_("set a notation for the selected user IDs")},
1321   { "passwd", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK,
1322     N_("change the passphrase")},
1323   { "password", cmdPASSWD,  KEYEDIT_NEED_SK | KEYEDIT_NEED_SUBSK, NULL},
1324 #ifndef NO_TRUST_MODELS
1325   { "trust", cmdTRUST, 0, N_("change the ownertrust")},
1326 #endif /*!NO_TRUST_MODELS*/
1327   { "revsig", cmdREVSIG, 0,
1328     N_("revoke signatures on the selected user IDs")},
1329   { "revuid", cmdREVUID,  KEYEDIT_NEED_SK,
1330     N_("revoke selected user IDs")},
1331   { "revphoto", cmdREVUID,  KEYEDIT_NEED_SK, NULL},
1332   { "revkey", cmdREVKEY,  KEYEDIT_NEED_SK,
1333     N_("revoke key or selected subkeys")},
1334 #ifndef NO_TRUST_MODELS
1335   { "enable", cmdENABLEKEY, 0, N_("enable key")},
1336   { "disable", cmdDISABLEKEY, 0, N_("disable key")},
1337 #endif /*!NO_TRUST_MODELS*/
1338   { "showphoto", cmdSHOWPHOTO, 0, N_("show selected photo IDs")},
1339   { "clean", cmdCLEAN, 0,
1340     N_("compact unusable user IDs and remove unusable signatures from key")},
1341   { "minimize", cmdMINIMIZE, 0,
1342     N_("compact unusable user IDs and remove all signatures from key")},
1343
1344   { NULL, cmdNONE, 0, NULL}
1345 };
1346
1347
1348 \f
1349 #ifdef HAVE_LIBREADLINE
1350
1351 /*
1352    These two functions are used by readline for command completion.
1353  */
1354
1355 static char *
1356 command_generator (const char *text, int state)
1357 {
1358   static int list_index, len;
1359   const char *name;
1360
1361   /* If this is a new word to complete, initialize now.  This includes
1362      saving the length of TEXT for efficiency, and initializing the
1363      index variable to 0. */
1364   if (!state)
1365     {
1366       list_index = 0;
1367       len = strlen (text);
1368     }
1369
1370   /* Return the next partial match */
1371   while ((name = cmds[list_index].name))
1372     {
1373       /* Only complete commands that have help text */
1374       if (cmds[list_index++].desc && strncmp (name, text, len) == 0)
1375         return strdup (name);
1376     }
1377
1378   return NULL;
1379 }
1380
1381 static char **
1382 keyedit_completion (const char *text, int start, int end)
1383 {
1384   /* If we are at the start of a line, we try and command-complete.
1385      If not, just do nothing for now. */
1386
1387   (void) end;
1388
1389   if (start == 0)
1390     return rl_completion_matches (text, command_generator);
1391
1392   rl_attempted_completion_over = 1;
1393
1394   return NULL;
1395 }
1396 #endif /* HAVE_LIBREADLINE */
1397
1398
1399 \f
1400 /* Main function of the menu driven key editor.  */
1401 void
1402 keyedit_menu (ctrl_t ctrl, const char *username, strlist_t locusr,
1403               strlist_t commands, int quiet, int seckey_check)
1404 {
1405   enum cmdids cmd = 0;
1406   gpg_error_t err = 0;
1407   KBNODE keyblock = NULL;
1408   KEYDB_HANDLE kdbhd = NULL;
1409   int have_seckey = 0;
1410   int have_anyseckey = 0;
1411   char *answer = NULL;
1412   int redisplay = 1;
1413   int modified = 0;
1414   int sec_shadowing = 0;
1415   int run_subkey_warnings = 0;
1416   int have_commands = !!commands;
1417
1418   if (opt.command_fd != -1)
1419     ;
1420   else if (opt.batch && !have_commands)
1421     {
1422       log_error (_("can't do this in batch mode\n"));
1423       goto leave;
1424     }
1425
1426 #ifdef HAVE_W32_SYSTEM
1427   /* Due to Windows peculiarities we need to make sure that the
1428      trustdb stale check is done before we open another file
1429      (i.e. by searching for a key).  In theory we could make sure
1430      that the files are closed after use but the open/close caches
1431      inhibits that and flushing the cache right before the stale
1432      check is not easy to implement.  Thus we take the easy way out
1433      and run the stale check as early as possible.  Note, that for
1434      non- W32 platforms it is run indirectly trough a call to
1435      get_validity ().  */
1436   check_trustdb_stale (ctrl);
1437 #endif
1438
1439   /* Get the public key */
1440   err = get_pubkey_byname (ctrl, NULL, NULL, username, &keyblock, &kdbhd, 1, 1);
1441   if (err)
1442     {
1443       log_error (_("key \"%s\" not found: %s\n"), username, gpg_strerror (err));
1444       goto leave;
1445     }
1446
1447   if (fix_keyblock (ctrl, &keyblock))
1448     modified++;
1449
1450   /* See whether we have a matching secret key.  */
1451   if (seckey_check)
1452     {
1453       have_anyseckey = !agent_probe_any_secret_key (ctrl, keyblock);
1454       if (have_anyseckey
1455           && !agent_probe_secret_key (ctrl, keyblock->pkt->pkt.public_key))
1456         {
1457           /* The primary key is also available.   */
1458           have_seckey = 1;
1459         }
1460
1461       if (have_seckey && !quiet)
1462         tty_printf (_("Secret key is available.\n"));
1463       else if (have_anyseckey && !quiet)
1464         tty_printf (_("Secret subkeys are available.\n"));
1465     }
1466
1467   /* Main command loop.  */
1468   for (;;)
1469     {
1470       int i, arg_number, photo;
1471       const char *arg_string = "";
1472       char *p;
1473       PKT_public_key *pk = keyblock->pkt->pkt.public_key;
1474
1475       tty_printf ("\n");
1476
1477       if (redisplay && !quiet)
1478         {
1479           /* Show using flags: with_revoker, with_subkeys.  */
1480           show_key_with_all_names (ctrl, NULL, keyblock, 0, 1, 0, 1, 0, 0);
1481           tty_printf ("\n");
1482           redisplay = 0;
1483         }
1484
1485       if (run_subkey_warnings)
1486         {
1487           run_subkey_warnings = 0;
1488           if (!count_selected_keys (keyblock))
1489             subkey_expire_warning (keyblock);
1490         }
1491
1492       do
1493         {
1494           xfree (answer);
1495           if (have_commands)
1496             {
1497               if (commands)
1498                 {
1499                   answer = xstrdup (commands->d);
1500                   commands = commands->next;
1501                 }
1502               else if (opt.batch)
1503                 {
1504                   answer = xstrdup ("quit");
1505                 }
1506               else
1507                 have_commands = 0;
1508             }
1509           if (!have_commands)
1510             {
1511 #ifdef HAVE_LIBREADLINE
1512               tty_enable_completion (keyedit_completion);
1513 #endif
1514               answer = cpr_get_no_help ("keyedit.prompt", GPG_NAME "> ");
1515               cpr_kill_prompt ();
1516               tty_disable_completion ();
1517             }
1518           trim_spaces (answer);
1519         }
1520       while (*answer == '#');
1521
1522       arg_number = 0; /* Here is the init which egcc complains about.  */
1523       photo = 0;      /* Same here. */
1524       if (!*answer)
1525         cmd = cmdLIST;
1526       else if (*answer == CONTROL_D)
1527         cmd = cmdQUIT;
1528       else if (digitp (answer))
1529         {
1530           cmd = cmdSELUID;
1531           arg_number = atoi (answer);
1532         }
1533       else
1534         {
1535           if ((p = strchr (answer, ' ')))
1536             {
1537               *p++ = 0;
1538               trim_spaces (answer);
1539               trim_spaces (p);
1540               arg_number = atoi (p);
1541               arg_string = p;
1542             }
1543
1544           for (i = 0; cmds[i].name; i++)
1545             {
1546               if (cmds[i].flags & KEYEDIT_TAIL_MATCH)
1547                 {
1548                   size_t l = strlen (cmds[i].name);
1549                   size_t a = strlen (answer);
1550                   if (a >= l)
1551                     {
1552                       if (!ascii_strcasecmp (&answer[a - l], cmds[i].name))
1553                         {
1554                           answer[a - l] = '\0';
1555                           break;
1556                         }
1557                     }
1558                 }
1559               else if (!ascii_strcasecmp (answer, cmds[i].name))
1560                 break;
1561             }
1562           if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
1563               && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
1564                    || ((cmds[i].flags & KEYEDIT_NEED_SUBSK) && have_anyseckey)))
1565             {
1566               tty_printf (_("Need the secret key to do this.\n"));
1567               cmd = cmdNOP;
1568             }
1569           else
1570             cmd = cmds[i].id;
1571         }
1572
1573       /* Dispatch the command.  */
1574       switch (cmd)
1575         {
1576         case cmdHELP:
1577           for (i = 0; cmds[i].name; i++)
1578             {
1579               if ((cmds[i].flags & (KEYEDIT_NEED_SK|KEYEDIT_NEED_SUBSK))
1580                   && !(((cmds[i].flags & KEYEDIT_NEED_SK) && have_seckey)
1581                        ||((cmds[i].flags&KEYEDIT_NEED_SUBSK)&&have_anyseckey)))
1582                 ; /* Skip those item if we do not have the secret key.  */
1583               else if (cmds[i].desc)
1584                 tty_printf ("%-11s %s\n", cmds[i].name, _(cmds[i].desc));
1585             }
1586
1587           tty_printf ("\n");
1588           tty_printf
1589             (_("* The 'sign' command may be prefixed with an 'l' for local "
1590                "signatures (lsign),\n"
1591                "  a 't' for trust signatures (tsign), an 'nr' for "
1592                "non-revocable signatures\n"
1593                "  (nrsign), or any combination thereof (ltsign, "
1594                "tnrsign, etc.).\n"));
1595           break;
1596
1597         case cmdLIST:
1598           redisplay = 1;
1599           break;
1600
1601         case cmdFPR:
1602           show_key_and_fingerprint
1603             (ctrl,
1604              keyblock, (*arg_string == '*'
1605                         && (!arg_string[1] || spacep (arg_string + 1))));
1606           break;
1607
1608         case cmdGRIP:
1609           show_key_and_grip (keyblock);
1610           break;
1611
1612         case cmdSELUID:
1613           if (strlen (arg_string) == NAMEHASH_LEN * 2)
1614             redisplay = menu_select_uid_namehash (keyblock, arg_string);
1615           else
1616             {
1617               if (*arg_string == '*'
1618                   && (!arg_string[1] || spacep (arg_string + 1)))
1619                 arg_number = -1;        /* Select all. */
1620               redisplay = menu_select_uid (keyblock, arg_number);
1621             }
1622           break;
1623
1624         case cmdSELKEY:
1625           {
1626             if (*arg_string == '*'
1627                 && (!arg_string[1] || spacep (arg_string + 1)))
1628               arg_number = -1;  /* Select all. */
1629             if (menu_select_key (keyblock, arg_number, p))
1630               redisplay = 1;
1631           }
1632           break;
1633
1634         case cmdCHECK:
1635           if (key_check_all_keysigs (ctrl, -1, keyblock,
1636                                      count_selected_uids (keyblock),
1637                                      !strcmp (arg_string, "selfsig")))
1638             modified = 1;
1639           break;
1640
1641         case cmdSIGN:
1642           {
1643             int localsig = 0, nonrevokesig = 0, trustsig = 0, interactive = 0;
1644
1645             if (pk->flags.revoked)
1646               {
1647                 tty_printf (_("Key is revoked."));
1648
1649                 if (opt.expert)
1650                   {
1651                     tty_printf ("  ");
1652                     if (!cpr_get_answer_is_yes
1653                         ("keyedit.sign_revoked.okay",
1654                          _("Are you sure you still want to sign it? (y/N) ")))
1655                       break;
1656                   }
1657                 else
1658                   {
1659                     tty_printf (_("  Unable to sign.\n"));
1660                     break;
1661                   }
1662               }
1663
1664             if (count_uids (keyblock) > 1 && !count_selected_uids (keyblock))
1665               {
1666                 int result;
1667                 if (opt.only_sign_text_ids)
1668                   result = cpr_get_answer_is_yes
1669                     ("keyedit.sign_all.okay",
1670                      _("Really sign all text user IDs? (y/N) "));
1671                 else
1672                   result = cpr_get_answer_is_yes
1673                     ("keyedit.sign_all.okay",
1674                      _("Really sign all user IDs? (y/N) "));
1675
1676                 if (! result)
1677                   {
1678                     if (opt.interactive)
1679                       interactive = 1;
1680                     else
1681                       {
1682                         tty_printf (_("Hint: Select the user IDs to sign\n"));
1683                         have_commands = 0;
1684                         break;
1685                       }
1686
1687                   }
1688               }
1689             /* What sort of signing are we doing? */
1690             if (!parse_sign_type
1691                 (answer, &localsig, &nonrevokesig, &trustsig))
1692               {
1693                 tty_printf (_("Unknown signature type '%s'\n"), answer);
1694                 break;
1695               }
1696
1697             sign_uids (ctrl, NULL, keyblock, locusr, &modified,
1698                        localsig, nonrevokesig, trustsig, interactive, 0);
1699           }
1700           break;
1701
1702         case cmdDEBUG:
1703           dump_kbnode (keyblock);
1704           break;
1705
1706         case cmdTOGGLE:
1707           /* The toggle command is a leftover from old gpg versions
1708              where we worked with a secret and a public keyring.  It
1709              is not necessary anymore but we keep this command for the
1710              sake of scripts using it.  */
1711           redisplay = 1;
1712           break;
1713
1714         case cmdADDPHOTO:
1715           if (RFC2440)
1716             {
1717               tty_printf (_("This command is not allowed while in %s mode.\n"),
1718                           gnupg_compliance_option_string (opt.compliance));
1719               break;
1720             }
1721           photo = 1;
1722           /* fall through */
1723         case cmdADDUID:
1724           if (menu_adduid (ctrl, keyblock, photo, arg_string, NULL))
1725             {
1726               update_trust = 1;
1727               redisplay = 1;
1728               modified = 1;
1729               merge_keys_and_selfsig (ctrl, keyblock);
1730             }
1731           break;
1732
1733         case cmdDELUID:
1734           {
1735             int n1;
1736
1737             if (!(n1 = count_selected_uids (keyblock)))
1738               {
1739                 tty_printf (_("You must select at least one user ID.\n"));
1740                 if (!opt.expert)
1741                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1742               }
1743             else if (real_uids_left (keyblock) < 1)
1744               tty_printf (_("You can't delete the last user ID!\n"));
1745             else if (cpr_get_answer_is_yes
1746                      ("keyedit.remove.uid.okay",
1747                       n1 > 1 ? _("Really remove all selected user IDs? (y/N) ")
1748                       :        _("Really remove this user ID? (y/N) ")))
1749               {
1750                 menu_deluid (keyblock);
1751                 redisplay = 1;
1752                 modified = 1;
1753               }
1754           }
1755           break;
1756
1757         case cmdDELSIG:
1758           {
1759             int n1;
1760
1761             if (!(n1 = count_selected_uids (keyblock)))
1762               {
1763                 tty_printf (_("You must select at least one user ID.\n"));
1764                 if (!opt.expert)
1765                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1766               }
1767             else if (menu_delsig (ctrl, keyblock))
1768               {
1769                 /* No redisplay here, because it may scroll away some
1770                  * of the status output of this command.  */
1771                 modified = 1;
1772               }
1773           }
1774           break;
1775
1776         case cmdADDKEY:
1777           if (!generate_subkeypair (ctrl, keyblock, NULL, NULL, NULL))
1778             {
1779               redisplay = 1;
1780               modified = 1;
1781               merge_keys_and_selfsig (ctrl, keyblock);
1782             }
1783           break;
1784
1785 #ifdef ENABLE_CARD_SUPPORT
1786         case cmdADDCARDKEY:
1787           if (!card_generate_subkey (ctrl, keyblock))
1788             {
1789               redisplay = 1;
1790               modified = 1;
1791               merge_keys_and_selfsig (ctrl, keyblock);
1792             }
1793           break;
1794
1795         case cmdKEYTOCARD:
1796           {
1797             KBNODE node = NULL;
1798             switch (count_selected_keys (keyblock))
1799               {
1800               case 0:
1801                 if (cpr_get_answer_is_yes
1802                     ("keyedit.keytocard.use_primary",
1803                      /* TRANSLATORS: Please take care: This is about
1804                         moving the key and not about removing it.  */
1805                      _("Really move the primary key? (y/N) ")))
1806                   node = keyblock;
1807                 break;
1808               case 1:
1809                 for (node = keyblock; node; node = node->next)
1810                   {
1811                     if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1812                         && node->flag & NODFLG_SELKEY)
1813                       break;
1814                   }
1815                 break;
1816               default:
1817                 tty_printf (_("You must select exactly one key.\n"));
1818                 break;
1819               }
1820             if (node)
1821               {
1822                 PKT_public_key *xxpk = node->pkt->pkt.public_key;
1823                 if (card_store_subkey (node, xxpk ? xxpk->pubkey_usage : 0))
1824                   {
1825                     redisplay = 1;
1826                     sec_shadowing = 1;
1827                   }
1828               }
1829           }
1830           break;
1831
1832         case cmdBKUPTOCARD:
1833           {
1834             /* Ask for a filename, check whether this is really a
1835                backup key as generated by the card generation, parse
1836                that key and store it on card. */
1837             KBNODE node;
1838             char *fname;
1839             PACKET *pkt;
1840             IOBUF a;
1841             struct parse_packet_ctx_s parsectx;
1842
1843             if (!*arg_string)
1844               {
1845                 tty_printf (_("Command expects a filename argument\n"));
1846                 break;
1847               }
1848
1849             if (*arg_string == DIRSEP_C)
1850               fname = xstrdup (arg_string);
1851             else if (*arg_string == '~')
1852               fname = make_filename (arg_string, NULL);
1853             else
1854               fname = make_filename (gnupg_homedir (), arg_string, NULL);
1855
1856             /* Open that file.  */
1857             a = iobuf_open (fname);
1858             if (a && is_secured_file (iobuf_get_fd (a)))
1859               {
1860                 iobuf_close (a);
1861                 a = NULL;
1862                 gpg_err_set_errno (EPERM);
1863               }
1864             if (!a)
1865               {
1866                 tty_printf (_("Can't open '%s': %s\n"),
1867                             fname, strerror (errno));
1868                 xfree (fname);
1869                 break;
1870               }
1871
1872             /* Parse and check that file.  */
1873             pkt = xmalloc (sizeof *pkt);
1874             init_packet (pkt);
1875             init_parse_packet (&parsectx, a);
1876             err = parse_packet (&parsectx, pkt);
1877             deinit_parse_packet (&parsectx);
1878             iobuf_close (a);
1879             iobuf_ioctl (NULL, IOBUF_IOCTL_INVALIDATE_CACHE, 0, (char *) fname);
1880             if (!err && pkt->pkttype != PKT_SECRET_KEY
1881                 && pkt->pkttype != PKT_SECRET_SUBKEY)
1882               err = GPG_ERR_NO_SECKEY;
1883             if (err)
1884               {
1885                 tty_printf (_("Error reading backup key from '%s': %s\n"),
1886                             fname, gpg_strerror (err));
1887                 xfree (fname);
1888                 free_packet (pkt, NULL);
1889                 xfree (pkt);
1890                 break;
1891               }
1892
1893             xfree (fname);
1894             node = new_kbnode (pkt);
1895
1896             /* Transfer it to gpg-agent which handles secret keys.  */
1897             err = transfer_secret_keys (ctrl, NULL, node, 1, 1);
1898
1899             /* Treat the pkt as a public key.  */
1900             pkt->pkttype = PKT_PUBLIC_KEY;
1901
1902             /* Ask gpg-agent to store the secret key to card.  */
1903             if (card_store_subkey (node, 0))
1904               {
1905                 redisplay = 1;
1906                 sec_shadowing = 1;
1907               }
1908             release_kbnode (node);
1909           }
1910           break;
1911
1912 #endif /* ENABLE_CARD_SUPPORT */
1913
1914         case cmdDELKEY:
1915           {
1916             int n1;
1917
1918             if (!(n1 = count_selected_keys (keyblock)))
1919               {
1920                 tty_printf (_("You must select at least one key.\n"));
1921                 if (!opt.expert)
1922                   tty_printf (_("(Use the '%s' command.)\n"), "key");
1923               }
1924             else if (!cpr_get_answer_is_yes
1925                      ("keyedit.remove.subkey.okay",
1926                       n1 > 1 ? _("Do you really want to delete the "
1927                                  "selected keys? (y/N) ")
1928                       :  _("Do you really want to delete this key? (y/N) ")))
1929               ;
1930             else
1931               {
1932                 menu_delkey (keyblock);
1933                 redisplay = 1;
1934                 modified = 1;
1935               }
1936           }
1937           break;
1938
1939         case cmdADDREVOKER:
1940           {
1941             int sensitive = 0;
1942
1943             if (ascii_strcasecmp (arg_string, "sensitive") == 0)
1944               sensitive = 1;
1945             if (menu_addrevoker (ctrl, keyblock, sensitive))
1946               {
1947                 redisplay = 1;
1948                 modified = 1;
1949                 merge_keys_and_selfsig (ctrl, keyblock);
1950               }
1951           }
1952           break;
1953
1954         case cmdREVUID:
1955           {
1956             int n1;
1957
1958             if (!(n1 = count_selected_uids (keyblock)))
1959               {
1960                 tty_printf (_("You must select at least one user ID.\n"));
1961                 if (!opt.expert)
1962                   tty_printf (_("(Use the '%s' command.)\n"), "uid");
1963               }
1964             else if (cpr_get_answer_is_yes
1965                      ("keyedit.revoke.uid.okay",
1966                       n1 > 1 ? _("Really revoke all selected user IDs? (y/N) ")
1967                       :        _("Really revoke this user ID? (y/N) ")))
1968               {
1969                 if (menu_revuid (ctrl, keyblock))
1970                   {
1971                     modified = 1;
1972                     redisplay = 1;
1973                   }
1974               }
1975           }
1976           break;
1977
1978         case cmdREVKEY:
1979           {
1980             int n1;
1981
1982             if (!(n1 = count_selected_keys (keyblock)))
1983               {
1984                 if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
1985                                            _("Do you really want to revoke"
1986                                              " the entire key? (y/N) ")))
1987                   {
1988                     if (menu_revkey (ctrl, keyblock))
1989                       modified = 1;
1990
1991                     redisplay = 1;
1992                   }
1993               }
1994             else if (cpr_get_answer_is_yes ("keyedit.revoke.subkey.okay",
1995                                             n1 > 1 ?
1996                                             _("Do you really want to revoke"
1997                                               " the selected subkeys? (y/N) ")
1998                                             : _("Do you really want to revoke"
1999                                                 " this subkey? (y/N) ")))
2000               {
2001                 if (menu_revsubkey (ctrl, keyblock))
2002                   modified = 1;
2003
2004                 redisplay = 1;
2005               }
2006
2007             if (modified)
2008               merge_keys_and_selfsig (ctrl, keyblock);
2009           }
2010           break;
2011
2012         case cmdEXPIRE:
2013           if (gpg_err_code (menu_expire (ctrl, keyblock, 0, 0)) == GPG_ERR_TRUE)
2014             {
2015               merge_keys_and_selfsig (ctrl, keyblock);
2016               run_subkey_warnings = 1;
2017               modified = 1;
2018               redisplay = 1;
2019             }
2020           break;
2021
2022         case cmdCHANGEUSAGE:
2023           if (menu_changeusage (ctrl, keyblock))
2024             {
2025               merge_keys_and_selfsig (ctrl, keyblock);
2026               modified = 1;
2027               redisplay = 1;
2028             }
2029           break;
2030
2031         case cmdBACKSIGN:
2032           if (menu_backsign (ctrl, keyblock))
2033             {
2034               modified = 1;
2035               redisplay = 1;
2036             }
2037           break;
2038
2039         case cmdPRIMARY:
2040           if (menu_set_primary_uid (ctrl, keyblock))
2041             {
2042               merge_keys_and_selfsig (ctrl, keyblock);
2043               modified = 1;
2044               redisplay = 1;
2045             }
2046           break;
2047
2048         case cmdPASSWD:
2049           change_passphrase (ctrl, keyblock);
2050           break;
2051
2052 #ifndef NO_TRUST_MODELS
2053         case cmdTRUST:
2054           if (opt.trust_model == TM_EXTERNAL)
2055             {
2056               tty_printf (_("Owner trust may not be set while "
2057                             "using a user provided trust database\n"));
2058               break;
2059             }
2060
2061           show_key_with_all_names (ctrl, NULL, keyblock, 0, 0, 0, 1, 0, 0);
2062           tty_printf ("\n");
2063           if (edit_ownertrust (ctrl, find_kbnode (keyblock,
2064                                             PKT_PUBLIC_KEY)->pkt->pkt.
2065                                public_key, 1))
2066             {
2067               redisplay = 1;
2068               /* No real need to set update_trust here as
2069                  edit_ownertrust() calls revalidation_mark()
2070                  anyway. */
2071               update_trust = 1;
2072             }
2073           break;
2074 #endif /*!NO_TRUST_MODELS*/
2075
2076         case cmdPREF:
2077           {
2078             int count = count_selected_uids (keyblock);
2079             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2080             show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
2081                         count ? NODFLG_SELUID : 0, 1);
2082           }
2083           break;
2084
2085         case cmdSHOWPREF:
2086           {
2087             int count = count_selected_uids (keyblock);
2088             log_assert (keyblock->pkt->pkttype == PKT_PUBLIC_KEY);
2089             show_names (ctrl, NULL, keyblock, keyblock->pkt->pkt.public_key,
2090                         count ? NODFLG_SELUID : 0, 2);
2091           }
2092           break;
2093
2094         case cmdSETPREF:
2095           {
2096             PKT_user_id *tempuid;
2097
2098             keygen_set_std_prefs (!*arg_string ? "default" : arg_string, 0);
2099
2100             tempuid = keygen_get_std_prefs ();
2101             tty_printf (_("Set preference list to:\n"));
2102             show_prefs (tempuid, NULL, 1);
2103             free_user_id (tempuid);
2104
2105             if (cpr_get_answer_is_yes
2106                 ("keyedit.setpref.okay",
2107                  count_selected_uids (keyblock) ?
2108                  _("Really update the preferences"
2109                    " for the selected user IDs? (y/N) ")
2110                  : _("Really update the preferences? (y/N) ")))
2111               {
2112                 if (menu_set_preferences (ctrl, keyblock))
2113                   {
2114                     merge_keys_and_selfsig (ctrl, keyblock);
2115                     modified = 1;
2116                     redisplay = 1;
2117                   }
2118               }
2119           }
2120           break;
2121
2122         case cmdPREFKS:
2123           if (menu_set_keyserver_url (ctrl, *arg_string ? arg_string : NULL,
2124                                       keyblock))
2125             {
2126               merge_keys_and_selfsig (ctrl, keyblock);
2127               modified = 1;
2128               redisplay = 1;
2129             }
2130           break;
2131
2132         case cmdNOTATION:
2133           if (menu_set_notation (ctrl, *arg_string ? arg_string : NULL,
2134                                  keyblock))
2135             {
2136               merge_keys_and_selfsig (ctrl, keyblock);
2137               modified = 1;
2138               redisplay = 1;
2139             }
2140           break;
2141
2142         case cmdNOP:
2143           break;
2144
2145         case cmdREVSIG:
2146           if (menu_revsig (ctrl, keyblock))
2147             {
2148               redisplay = 1;
2149               modified = 1;
2150             }
2151           break;
2152
2153 #ifndef NO_TRUST_MODELS
2154         case cmdENABLEKEY:
2155         case cmdDISABLEKEY:
2156           if (enable_disable_key (ctrl, keyblock, cmd == cmdDISABLEKEY))
2157             {
2158               redisplay = 1;
2159               modified = 1;
2160             }
2161           break;
2162 #endif /*!NO_TRUST_MODELS*/
2163
2164         case cmdSHOWPHOTO:
2165           menu_showphoto (ctrl, keyblock);
2166           break;
2167
2168         case cmdCLEAN:
2169           if (menu_clean (ctrl, keyblock, 0))
2170             redisplay = modified = 1;
2171           break;
2172
2173         case cmdMINIMIZE:
2174           if (menu_clean (ctrl, keyblock, 1))
2175             redisplay = modified = 1;
2176           break;
2177
2178         case cmdQUIT:
2179           if (have_commands)
2180             goto leave;
2181           if (!modified && !sec_shadowing)
2182             goto leave;
2183           if (!cpr_get_answer_is_yes ("keyedit.save.okay",
2184                                       _("Save changes? (y/N) ")))
2185             {
2186               if (cpr_enabled ()
2187                   || cpr_get_answer_is_yes ("keyedit.cancel.okay",
2188                                             _("Quit without saving? (y/N) ")))
2189                 goto leave;
2190               break;
2191             }
2192           /* fall through */
2193         case cmdSAVE:
2194           if (modified)
2195             {
2196               err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2197               if (err)
2198                 {
2199                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2200                   break;
2201                 }
2202             }
2203
2204           if (sec_shadowing)
2205             {
2206               err = agent_scd_learn (NULL, 1);
2207               if (err)
2208                 {
2209                   log_error (_("update failed: %s\n"), gpg_strerror (err));
2210                   break;
2211                 }
2212             }
2213
2214           if (!modified && !sec_shadowing)
2215             tty_printf (_("Key not changed so no update needed.\n"));
2216
2217           if (update_trust)
2218             {
2219               revalidation_mark (ctrl);
2220               update_trust = 0;
2221             }
2222           goto leave;
2223
2224         case cmdINVCMD:
2225         default:
2226           tty_printf ("\n");
2227           tty_printf (_("Invalid command  (try \"help\")\n"));
2228           break;
2229         }
2230     } /* End of the main command loop.  */
2231
2232  leave:
2233   release_kbnode (keyblock);
2234   keydb_release (kdbhd);
2235   xfree (answer);
2236 }
2237
2238
2239 /* Change the passphrase of the secret key identified by USERNAME.  */
2240 void
2241 keyedit_passwd (ctrl_t ctrl, const char *username)
2242 {
2243   gpg_error_t err;
2244   PKT_public_key *pk;
2245   kbnode_t keyblock = NULL;
2246
2247   pk = xtrycalloc (1, sizeof *pk);
2248   if (!pk)
2249     {
2250       err = gpg_error_from_syserror ();
2251       goto leave;
2252     }
2253   err = getkey_byname (ctrl, NULL, pk, username, 1, &keyblock);
2254   if (err)
2255     goto leave;
2256
2257   err = change_passphrase (ctrl, keyblock);
2258
2259 leave:
2260   release_kbnode (keyblock);
2261   free_public_key (pk);
2262   if (err)
2263     {
2264       log_info ("error changing the passphrase for '%s': %s\n",
2265                 username, gpg_strerror (err));
2266       write_status_error ("keyedit.passwd", err);
2267     }
2268   else
2269     write_status_text (STATUS_SUCCESS, "keyedit.passwd");
2270 }
2271
2272
2273 /* Helper for quick commands to find the keyblock for USERNAME.
2274  * Returns on success the key database handle at R_KDBHD and the
2275  * keyblock at R_KEYBLOCK.  */
2276 static gpg_error_t
2277 quick_find_keyblock (ctrl_t ctrl, const char *username,
2278                      KEYDB_HANDLE *r_kdbhd, kbnode_t *r_keyblock)
2279 {
2280   gpg_error_t err;
2281   KEYDB_HANDLE kdbhd = NULL;
2282   kbnode_t keyblock = NULL;
2283   KEYDB_SEARCH_DESC desc;
2284   kbnode_t node;
2285
2286   *r_kdbhd = NULL;
2287   *r_keyblock = NULL;
2288
2289   /* Search the key; we don't want the whole getkey stuff here.  */
2290   kdbhd = keydb_new ();
2291   if (!kdbhd)
2292     {
2293       /* Note that keydb_new has already used log_error.  */
2294       err = gpg_error_from_syserror ();
2295       goto leave;
2296     }
2297
2298   err = classify_user_id (username, &desc, 1);
2299   if (!err)
2300     err = keydb_search (kdbhd, &desc, 1, NULL);
2301   if (!err)
2302     {
2303       err = keydb_get_keyblock (kdbhd, &keyblock);
2304       if (err)
2305         {
2306           log_error (_("error reading keyblock: %s\n"), gpg_strerror (err));
2307           goto leave;
2308         }
2309       /* Now with the keyblock retrieved, search again to detect an
2310          ambiguous specification.  We need to save the found state so
2311          that we can do an update later.  */
2312       keydb_push_found_state (kdbhd);
2313       err = keydb_search (kdbhd, &desc, 1, NULL);
2314       if (!err)
2315         err = gpg_error (GPG_ERR_AMBIGUOUS_NAME);
2316       else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2317         err = 0;
2318       keydb_pop_found_state (kdbhd);
2319
2320       if (!err)
2321         {
2322           /* We require the secret primary key to set the primary UID.  */
2323           node = find_kbnode (keyblock, PKT_PUBLIC_KEY);
2324           log_assert (node);
2325           err = agent_probe_secret_key (ctrl, node->pkt->pkt.public_key);
2326         }
2327     }
2328   else if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
2329     err = gpg_error (GPG_ERR_NO_PUBKEY);
2330
2331   if (err)
2332     {
2333       log_error (_("key \"%s\" not found: %s\n"),
2334                  username, gpg_strerror (err));
2335       goto leave;
2336     }
2337
2338   fix_keyblock (ctrl, &keyblock);
2339   merge_keys_and_selfsig (ctrl, keyblock);
2340
2341   *r_keyblock = keyblock;
2342   keyblock = NULL;
2343   *r_kdbhd = kdbhd;
2344   kdbhd = NULL;
2345
2346  leave:
2347   release_kbnode (keyblock);
2348   keydb_release (kdbhd);
2349   return err;
2350 }
2351
2352
2353 /* Unattended adding of a new keyid.  USERNAME specifies the
2354    key. NEWUID is the new user id to add to the key.  */
2355 void
2356 keyedit_quick_adduid (ctrl_t ctrl, const char *username, const char *newuid)
2357 {
2358   gpg_error_t err;
2359   KEYDB_HANDLE kdbhd = NULL;
2360   kbnode_t keyblock = NULL;
2361   char *uidstring = NULL;
2362
2363   uidstring = xstrdup (newuid);
2364   trim_spaces (uidstring);
2365   if (!*uidstring)
2366     {
2367       log_error ("%s\n", gpg_strerror (GPG_ERR_INV_USER_ID));
2368       goto leave;
2369     }
2370
2371 #ifdef HAVE_W32_SYSTEM
2372   /* See keyedit_menu for why we need this.  */
2373   check_trustdb_stale (ctrl);
2374 #endif
2375
2376   /* Search the key; we don't want the whole getkey stuff here.  */
2377   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2378   if (err)
2379     goto leave;
2380
2381   if (menu_adduid (ctrl, keyblock, 0, NULL, uidstring))
2382     {
2383       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2384       if (err)
2385         {
2386           log_error (_("update failed: %s\n"), gpg_strerror (err));
2387           goto leave;
2388         }
2389
2390       if (update_trust)
2391         revalidation_mark (ctrl);
2392     }
2393
2394  leave:
2395   xfree (uidstring);
2396   release_kbnode (keyblock);
2397   keydb_release (kdbhd);
2398 }
2399
2400
2401 /* Unattended revocation of a keyid.  USERNAME specifies the
2402    key. UIDTOREV is the user id revoke from the key.  */
2403 void
2404 keyedit_quick_revuid (ctrl_t ctrl, const char *username, const char *uidtorev)
2405 {
2406   gpg_error_t err;
2407   KEYDB_HANDLE kdbhd = NULL;
2408   kbnode_t keyblock = NULL;
2409   kbnode_t node;
2410   int modified = 0;
2411   size_t revlen;
2412   size_t valid_uids;
2413
2414 #ifdef HAVE_W32_SYSTEM
2415   /* See keyedit_menu for why we need this.  */
2416   check_trustdb_stale (ctrl);
2417 #endif
2418
2419   /* Search the key; we don't want the whole getkey stuff here.  */
2420   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2421   if (err)
2422     goto leave;
2423
2424   /* Too make sure that we do not revoke the last valid UID, we first
2425      count how many valid UIDs there are.  */
2426   valid_uids = 0;
2427   for (node = keyblock; node; node = node->next)
2428     valid_uids += (node->pkt->pkttype == PKT_USER_ID
2429                    && !node->pkt->pkt.user_id->flags.revoked
2430                    && !node->pkt->pkt.user_id->flags.expired);
2431
2432   /* Find the right UID. */
2433   revlen = strlen (uidtorev);
2434   for (node = keyblock; node; node = node->next)
2435     {
2436       if (node->pkt->pkttype == PKT_USER_ID
2437           && revlen == node->pkt->pkt.user_id->len
2438           && !memcmp (node->pkt->pkt.user_id->name, uidtorev, revlen))
2439         {
2440           struct revocation_reason_info *reason;
2441
2442           /* Make sure that we do not revoke the last valid UID.  */
2443           if (valid_uids == 1
2444               && ! node->pkt->pkt.user_id->flags.revoked
2445               && ! node->pkt->pkt.user_id->flags.expired)
2446             {
2447               log_error (_("cannot revoke the last valid user ID.\n"));
2448               err = gpg_error (GPG_ERR_INV_USER_ID);
2449               goto leave;
2450             }
2451
2452           reason = get_default_uid_revocation_reason ();
2453           err = core_revuid (ctrl, keyblock, node, reason, &modified);
2454           release_revocation_reason_info (reason);
2455           if (err)
2456             goto leave;
2457           err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2458           if (err)
2459             {
2460               log_error (_("update failed: %s\n"), gpg_strerror (err));
2461               goto leave;
2462             }
2463
2464           revalidation_mark (ctrl);
2465           goto leave;
2466         }
2467     }
2468   err = gpg_error (GPG_ERR_NO_USER_ID);
2469
2470
2471  leave:
2472   if (err)
2473     {
2474       log_error (_("revoking the user ID failed: %s\n"), gpg_strerror (err));
2475       write_status_error ("keyedit.revoke.uid", err);
2476     }
2477   release_kbnode (keyblock);
2478   keydb_release (kdbhd);
2479 }
2480
2481
2482 /* Unattended setting of the primary uid.  USERNAME specifies the key.
2483    PRIMARYUID is the user id which shall be primary.  */
2484 void
2485 keyedit_quick_set_primary (ctrl_t ctrl, const char *username,
2486                            const char *primaryuid)
2487 {
2488   gpg_error_t err;
2489   KEYDB_HANDLE kdbhd = NULL;
2490   kbnode_t keyblock = NULL;
2491   kbnode_t node;
2492   size_t primaryuidlen;
2493   int any;
2494
2495 #ifdef HAVE_W32_SYSTEM
2496   /* See keyedit_menu for why we need this.  */
2497   check_trustdb_stale (ctrl);
2498 #endif
2499
2500   err = quick_find_keyblock (ctrl, username, &kdbhd, &keyblock);
2501   if (err)
2502     goto leave;
2503
2504   /* Find and mark the UID - we mark only the first valid one. */
2505   primaryuidlen = strlen (primaryuid);
2506   any = 0;
2507   for (node = keyblock; node; node = node->next)
2508     {
2509       if (node->pkt->pkttype == PKT_USER_ID
2510           && !any
2511           && !node->pkt->pkt.user_id->flags.revoked
2512           && !node->pkt->pkt.user_id->flags.expired
2513           && primaryuidlen == node->pkt->pkt.user_id->len
2514           && !memcmp (node->pkt->pkt.user_id->name, primaryuid, primaryuidlen))
2515         {
2516           node->flag |= NODFLG_SELUID;
2517           any = 1;
2518         }
2519       else
2520         node->flag &= ~NODFLG_SELUID;
2521     }
2522
2523   if (!any)
2524     err = gpg_error (GPG_ERR_NO_USER_ID);
2525   else if (menu_set_primary_uid (ctrl, keyblock))
2526     {
2527       merge_keys_and_selfsig (ctrl, keyblock);
2528       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2529       if (err)
2530         {
2531           log_error (_("update failed: %s\n"), gpg_strerror (err));
2532           goto leave;
2533         }
2534       revalidation_mark (ctrl);
2535     }
2536   else
2537     err = gpg_error (GPG_ERR_GENERAL);
2538
2539   if (err)
2540     log_error (_("setting the primary user ID failed: %s\n"),
2541                gpg_strerror (err));
2542
2543  leave:
2544   release_kbnode (keyblock);
2545   keydb_release (kdbhd);
2546 }
2547
2548
2549 /* Find a keyblock by fingerprint because only this uniquely
2550  * identifies a key and may thus be used to select a key for
2551  * unattended subkey creation os key signing.  */
2552 static gpg_error_t
2553 find_by_primary_fpr (ctrl_t ctrl, const char *fpr,
2554                      kbnode_t *r_keyblock, KEYDB_HANDLE *r_kdbhd)
2555 {
2556   gpg_error_t err;
2557   kbnode_t keyblock = NULL;
2558   KEYDB_HANDLE kdbhd = NULL;
2559   KEYDB_SEARCH_DESC desc;
2560   byte fprbin[MAX_FINGERPRINT_LEN];
2561   size_t fprlen;
2562
2563   *r_keyblock = NULL;
2564   *r_kdbhd = NULL;
2565
2566   if (classify_user_id (fpr, &desc, 1)
2567       || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2568            || desc.mode == KEYDB_SEARCH_MODE_FPR16
2569            || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2570     {
2571       log_error (_("\"%s\" is not a fingerprint\n"), fpr);
2572       err = gpg_error (GPG_ERR_INV_NAME);
2573       goto leave;
2574     }
2575   err = get_pubkey_byname (ctrl, NULL, NULL, fpr, &keyblock, &kdbhd, 1, 1);
2576   if (err)
2577     {
2578       log_error (_("key \"%s\" not found: %s\n"), fpr, gpg_strerror (err));
2579       goto leave;
2580     }
2581
2582   /* Check that the primary fingerprint has been given. */
2583   fingerprint_from_pk (keyblock->pkt->pkt.public_key, fprbin, &fprlen);
2584   if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR16
2585       && !memcmp (fprbin, desc.u.fpr, 16))
2586     ;
2587   else if (fprlen == 16 && desc.mode == KEYDB_SEARCH_MODE_FPR
2588            && !memcmp (fprbin, desc.u.fpr, 16)
2589            && !desc.u.fpr[16]
2590            && !desc.u.fpr[17]
2591            && !desc.u.fpr[18]
2592            && !desc.u.fpr[19])
2593     ;
2594   else if (fprlen == 20 && (desc.mode == KEYDB_SEARCH_MODE_FPR20
2595                             || desc.mode == KEYDB_SEARCH_MODE_FPR)
2596            && !memcmp (fprbin, desc.u.fpr, 20))
2597     ;
2598   else
2599     {
2600       log_error (_("\"%s\" is not the primary fingerprint\n"), fpr);
2601       err = gpg_error (GPG_ERR_INV_NAME);
2602       goto leave;
2603     }
2604
2605   *r_keyblock = keyblock;
2606   keyblock = NULL;
2607   *r_kdbhd = kdbhd;
2608   kdbhd = NULL;
2609   err = 0;
2610
2611  leave:
2612   release_kbnode (keyblock);
2613   keydb_release (kdbhd);
2614   return err;
2615 }
2616
2617
2618 /* Unattended key signing function.  If the key specifified by FPR is
2619    available and FPR is the primary fingerprint all user ids of the
2620    key are signed using the default signing key.  If UIDS is an empty
2621    list all usable UIDs are signed, if it is not empty, only those
2622    user ids matching one of the entries of the list are signed.  With
2623    LOCAL being true the signatures are marked as non-exportable.  */
2624 void
2625 keyedit_quick_sign (ctrl_t ctrl, const char *fpr, strlist_t uids,
2626                     strlist_t locusr, int local)
2627 {
2628   gpg_error_t err;
2629   kbnode_t keyblock = NULL;
2630   KEYDB_HANDLE kdbhd = NULL;
2631   int modified = 0;
2632   PKT_public_key *pk;
2633   kbnode_t node;
2634   strlist_t sl;
2635   int any;
2636
2637 #ifdef HAVE_W32_SYSTEM
2638   /* See keyedit_menu for why we need this.  */
2639   check_trustdb_stale (ctrl);
2640 #endif
2641
2642   /* We require a fingerprint because only this uniquely identifies a
2643      key and may thus be used to select a key for unattended key
2644      signing.  */
2645   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
2646     goto leave;
2647
2648   if (fix_keyblock (ctrl, &keyblock))
2649     modified++;
2650
2651   /* Give some info in verbose.  */
2652   if (opt.verbose)
2653     {
2654       show_key_with_all_names (ctrl, es_stdout, keyblock, 0,
2655                                1/*with_revoker*/, 1/*with_fingerprint*/,
2656                                0, 0, 1);
2657       es_fflush (es_stdout);
2658     }
2659
2660   pk = keyblock->pkt->pkt.public_key;
2661   if (pk->flags.revoked)
2662     {
2663       if (!opt.verbose)
2664         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2665       log_error ("%s%s", _("Key is revoked."), _("  Unable to sign.\n"));
2666       goto leave;
2667     }
2668
2669   /* Set the flags according to the UIDS list.  Fixme: We may want to
2670      use classify_user_id along with dedicated compare functions so
2671      that we match the same way as in the key lookup. */
2672   any = 0;
2673   menu_select_uid (keyblock, 0);   /* Better clear the flags first. */
2674   for (sl=uids; sl; sl = sl->next)
2675     {
2676       const char *name = sl->d;
2677       int count = 0;
2678
2679       sl->flags &= ~(1|2);  /* Clear flags used for error reporting.  */
2680
2681       for (node = keyblock; node; node = node->next)
2682         {
2683           if (node->pkt->pkttype == PKT_USER_ID)
2684             {
2685               PKT_user_id *uid = node->pkt->pkt.user_id;
2686
2687               if (uid->attrib_data)
2688                 ;
2689               else if (*name == '='
2690                        && strlen (name+1) == uid->len
2691                        && !memcmp (uid->name, name + 1, uid->len))
2692                 { /* Exact match - we don't do a check for ambiguity
2693                    * in this case.  */
2694                   node->flag |= NODFLG_SELUID;
2695                   if (any != -1)
2696                     {
2697                       sl->flags |= 1;  /* Report as found.  */
2698                       any = 1;
2699                     }
2700                 }
2701               else if (ascii_memistr (uid->name, uid->len,
2702                                       *name == '*'? name+1:name))
2703                 {
2704                   node->flag |= NODFLG_SELUID;
2705                   if (any != -1)
2706                     {
2707                       sl->flags |= 1;  /* Report as found.  */
2708                       any = 1;
2709                     }
2710                   count++;
2711                 }
2712             }
2713         }
2714
2715       if (count > 1)
2716         {
2717           any = -1;        /* Force failure at end.  */
2718           sl->flags |= 2;  /* Report as ambiguous.  */
2719         }
2720     }
2721
2722   /* Check whether all given user ids were found.  */
2723   for (sl=uids; sl; sl = sl->next)
2724     if (!(sl->flags & 1))
2725       any = -1;  /* That user id was not found.  */
2726
2727   /* Print an error if there was a problem with the user ids.  */
2728   if (uids && any < 1)
2729     {
2730       if (!opt.verbose)
2731         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2732       es_fflush (es_stdout);
2733       for (sl=uids; sl; sl = sl->next)
2734         {
2735           if ((sl->flags & 2))
2736             log_info (_("Invalid user ID '%s': %s\n"),
2737                       sl->d, gpg_strerror (GPG_ERR_AMBIGUOUS_NAME));
2738           else if (!(sl->flags & 1))
2739             log_info (_("Invalid user ID '%s': %s\n"),
2740                       sl->d, gpg_strerror (GPG_ERR_NOT_FOUND));
2741         }
2742       log_error ("%s  %s", _("No matching user IDs."), _("Nothing to sign.\n"));
2743       goto leave;
2744     }
2745
2746   /* Sign. */
2747   sign_uids (ctrl, es_stdout, keyblock, locusr, &modified, local, 0, 0, 0, 1);
2748   es_fflush (es_stdout);
2749
2750   if (modified)
2751     {
2752       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2753       if (err)
2754         {
2755           log_error (_("update failed: %s\n"), gpg_strerror (err));
2756           goto leave;
2757         }
2758     }
2759   else
2760     log_info (_("Key not changed so no update needed.\n"));
2761
2762   if (update_trust)
2763     revalidation_mark (ctrl);
2764
2765
2766  leave:
2767   release_kbnode (keyblock);
2768   keydb_release (kdbhd);
2769 }
2770
2771
2772 /* Unattended subkey creation function.
2773  *
2774  */
2775 void
2776 keyedit_quick_addkey (ctrl_t ctrl, const char *fpr, const char *algostr,
2777                       const char *usagestr, const char *expirestr)
2778 {
2779   gpg_error_t err;
2780   kbnode_t keyblock;
2781   KEYDB_HANDLE kdbhd;
2782   int modified = 0;
2783   PKT_public_key *pk;
2784
2785 #ifdef HAVE_W32_SYSTEM
2786   /* See keyedit_menu for why we need this.  */
2787   check_trustdb_stale (ctrl);
2788 #endif
2789
2790   /* We require a fingerprint because only this uniquely identifies a
2791    * key and may thus be used to select a key for unattended subkey
2792    * creation.  */
2793   if (find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd))
2794     goto leave;
2795
2796   if (fix_keyblock (ctrl, &keyblock))
2797     modified++;
2798
2799   pk = keyblock->pkt->pkt.public_key;
2800   if (pk->flags.revoked)
2801     {
2802       if (!opt.verbose)
2803         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2804       log_error ("%s%s", _("Key is revoked."), "\n");
2805       goto leave;
2806     }
2807
2808   /* Create the subkey.  Note that the called function already prints
2809    * an error message. */
2810   if (!generate_subkeypair (ctrl, keyblock, algostr, usagestr, expirestr))
2811     modified = 1;
2812   es_fflush (es_stdout);
2813
2814   /* Store.  */
2815   if (modified)
2816     {
2817       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2818       if (err)
2819         {
2820           log_error (_("update failed: %s\n"), gpg_strerror (err));
2821           goto leave;
2822         }
2823     }
2824   else
2825     log_info (_("Key not changed so no update needed.\n"));
2826
2827  leave:
2828   release_kbnode (keyblock);
2829   keydb_release (kdbhd);
2830 }
2831
2832
2833 /* Unattended expiration setting function for the main key.  If
2834  * SUBKEYFPRS is not NULL and SUBKEYSFPRS[0] is neither NULL, it is
2835  * expected to be an array of fingerprints for subkeys to change. It
2836  * may also be an array which just one item "*" to indicate that all
2837  * keys shall be set to that expiration date.
2838  */
2839 void
2840 keyedit_quick_set_expire (ctrl_t ctrl, const char *fpr, const char *expirestr,
2841                           char **subkeyfprs)
2842 {
2843   gpg_error_t err;
2844   kbnode_t keyblock, node;
2845   KEYDB_HANDLE kdbhd;
2846   int modified = 0;
2847   PKT_public_key *pk;
2848   u32 expire;
2849   int primary_only = 0;
2850   int idx;
2851
2852 #ifdef HAVE_W32_SYSTEM
2853   /* See keyedit_menu for why we need this.  */
2854   check_trustdb_stale (ctrl);
2855 #endif
2856
2857   /* We require a fingerprint because only this uniquely identifies a
2858    * key and may thus be used to select a key for unattended
2859    * expiration setting.  */
2860   err = find_by_primary_fpr (ctrl, fpr, &keyblock, &kdbhd);
2861   if (err)
2862     goto leave;
2863
2864   if (fix_keyblock (ctrl, &keyblock))
2865     modified++;
2866
2867   pk = keyblock->pkt->pkt.public_key;
2868   if (pk->flags.revoked)
2869     {
2870       if (!opt.verbose)
2871         show_key_with_all_names (ctrl, es_stdout, keyblock, 0, 0, 0, 0, 0, 1);
2872       log_error ("%s%s", _("Key is revoked."), "\n");
2873       err = gpg_error (GPG_ERR_CERT_REVOKED);
2874       goto leave;
2875     }
2876
2877   expire = parse_expire_string (expirestr);
2878   if (expire == (u32)-1 )
2879     {
2880       log_error (_("'%s' is not a valid expiration time\n"), expirestr);
2881       err = gpg_error (GPG_ERR_INV_VALUE);
2882       goto leave;
2883     }
2884   if (expire)
2885     expire += make_timestamp ();
2886
2887   /* Check whether a subkey's expiration time shall be changed or the
2888    * expiration time of all keys.  */
2889   if (!subkeyfprs || !subkeyfprs[0])
2890     primary_only = 1;
2891   else if ( !strcmp (subkeyfprs[0], "*") && !subkeyfprs[1])
2892     {
2893       /* Change all subkeys keys which have not been revoked and are
2894        * not yet expired.  */
2895       merge_keys_and_selfsig (ctrl, keyblock);
2896       for (node = keyblock; node; node = node->next)
2897         {
2898           if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2899               && (pk = node->pkt->pkt.public_key)
2900               && !pk->flags.revoked
2901               && !pk->has_expired)
2902             node->flag |= NODFLG_SELKEY;
2903         }
2904     }
2905   else
2906     {
2907       /* Change specified subkeys.  */
2908       KEYDB_SEARCH_DESC desc;
2909       byte fprbin[MAX_FINGERPRINT_LEN];
2910       size_t fprlen;
2911
2912       err = 0;
2913       merge_keys_and_selfsig (ctrl, keyblock);
2914       for (idx=0; subkeyfprs[idx]; idx++)
2915         {
2916           int any = 0;
2917
2918           /* Parse the fingerprint.  */
2919           if (classify_user_id (subkeyfprs[idx], &desc, 1)
2920               || !(desc.mode == KEYDB_SEARCH_MODE_FPR
2921                    || desc.mode == KEYDB_SEARCH_MODE_FPR20))
2922             {
2923               log_error (_("\"%s\" is not a proper fingerprint\n"),
2924                          subkeyfprs[idx] );
2925               if (!err)
2926                 err = gpg_error (GPG_ERR_INV_NAME);
2927               continue;
2928             }
2929
2930           /* Set the flag for the matching non revoked subkey.  */
2931           for (node = keyblock; node; node = node->next)
2932             {
2933               if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY
2934                   && (pk = node->pkt->pkt.public_key)
2935                   && !pk->flags.revoked )
2936                 {
2937                   fingerprint_from_pk (pk, fprbin, &fprlen);
2938                   if (fprlen == 20 && !memcmp (fprbin, desc.u.fpr, 20))
2939                     {
2940                       node->flag |= NODFLG_SELKEY;
2941                       any = 1;
2942                     }
2943                 }
2944             }
2945           if (!any)
2946             {
2947               log_error (_("subkey \"%s\" not found\n"), subkeyfprs[idx]);
2948               if (!err)
2949                 err = gpg_error (GPG_ERR_NOT_FOUND);
2950             }
2951         }
2952
2953       if (err)
2954         goto leave;
2955     }
2956
2957   /* Set the new expiration date.  */
2958   err = menu_expire (ctrl, keyblock, primary_only? 1 : 2, expire);
2959   if (gpg_err_code (err) == GPG_ERR_TRUE)
2960     modified = 1;
2961   else if (err)
2962     goto leave;
2963   es_fflush (es_stdout);
2964
2965   /* Store.  */
2966   if (modified)
2967     {
2968       err = keydb_update_keyblock (ctrl, kdbhd, keyblock);
2969       if (err)
2970         {
2971           log_error (_("update failed: %s\n"), gpg_strerror (err));
2972           goto leave;
2973         }
2974       if (update_trust)
2975         revalidation_mark (ctrl);
2976     }
2977   else
2978     log_info (_("Key not changed so no update needed.\n"));
2979
2980  leave:
2981   release_kbnode (keyblock);
2982   keydb_release (kdbhd);
2983   if (err)
2984     write_status_error ("set_expire", err);
2985 }
2986
2987
2988 \f
2989 static void
2990 tty_print_notations (int indent, PKT_signature * sig)
2991 {
2992   int first = 1;
2993   struct notation *notation, *nd;
2994
2995   if (indent < 0)
2996     {
2997       first = 0;
2998       indent = -indent;
2999     }
3000
3001   notation = sig_to_notation (sig);
3002
3003   for (nd = notation; nd; nd = nd->next)
3004     {
3005       if (!first)
3006         tty_printf ("%*s", indent, "");
3007       else
3008         first = 0;
3009
3010       tty_print_utf8_string (nd->name, strlen (nd->name));
3011       tty_printf ("=");
3012       tty_print_utf8_string (nd->value, strlen (nd->value));
3013       tty_printf ("\n");
3014     }
3015
3016   free_notation (notation);
3017 }
3018
3019
3020 /*
3021  * Show preferences of a public keyblock.
3022  */
3023 static void
3024 show_prefs (PKT_user_id * uid, PKT_signature * selfsig, int verbose)
3025 {
3026   const prefitem_t fake = { 0, 0 };
3027   const prefitem_t *prefs;
3028   int i;
3029
3030   if (!uid)
3031     return;
3032
3033   if (uid->prefs)
3034     prefs = uid->prefs;
3035   else if (verbose)
3036     prefs = &fake;
3037   else
3038     return;
3039
3040   if (verbose)
3041     {
3042       int any, des_seen = 0, sha1_seen = 0, uncomp_seen = 0;
3043
3044       tty_printf ("     ");
3045       tty_printf (_("Cipher: "));
3046       for (i = any = 0; prefs[i].type; i++)
3047         {
3048           if (prefs[i].type == PREFTYPE_SYM)
3049             {
3050               if (any)
3051                 tty_printf (", ");
3052               any = 1;
3053               /* We don't want to display strings for experimental algos */
3054               if (!openpgp_cipher_test_algo (prefs[i].value)
3055                   && prefs[i].value < 100)
3056                 tty_printf ("%s", openpgp_cipher_algo_name (prefs[i].value));
3057               else
3058                 tty_printf ("[%d]", prefs[i].value);
3059               if (prefs[i].value == CIPHER_ALGO_3DES)
3060                 des_seen = 1;
3061             }
3062         }
3063       if (!des_seen)
3064         {
3065           if (any)
3066             tty_printf (", ");
3067           tty_printf ("%s", openpgp_cipher_algo_name (CIPHER_ALGO_3DES));
3068         }
3069       tty_printf ("\n     ");
3070       tty_printf (_("AEAD: "));
3071       for (i = any = 0; prefs[i].type; i++)
3072         {
3073           if (prefs[i].type == PREFTYPE_AEAD)
3074             {
3075               if (any)
3076                 tty_printf (", ");
3077               any = 1;
3078               /* We don't want to display strings for experimental algos */
3079               if (!openpgp_aead_test_algo (prefs[i].value)
3080                   && prefs[i].value < 100)
3081                 tty_printf ("%s", openpgp_aead_algo_name (prefs[i].value));
3082               else
3083                 tty_printf ("[%d]", prefs[i].value);
3084             }
3085         }
3086       tty_printf ("\n     ");
3087       tty_printf (_("Digest: "));
3088       for (i = any = 0; prefs[i].type; i++)
3089         {
3090           if (prefs[i].type == PREFTYPE_HASH)
3091             {
3092               if (any)
3093                 tty_printf (", ");
3094               any = 1;
3095               /* We don't want to display strings for experimental algos */
3096               if (!gcry_md_test_algo (prefs[i].value) && prefs[i].value < 100)
3097                 tty_printf ("%s", gcry_md_algo_name (prefs[i].value));
3098               else
3099                 tty_printf ("[%d]", prefs[i].value);
3100               if (prefs[i].value == DIGEST_ALGO_SHA1)
3101                 sha1_seen = 1;
3102             }
3103         }
3104       if (!sha1_seen)
3105         {
3106           if (any)
3107             tty_printf (", ");
3108           tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
3109         }
3110       tty_printf ("\n     ");
3111       tty_printf (_("Compression: "));
3112       for (i = any = 0; prefs[i].type; i++)
3113         {
3114           if (prefs[i].type == PREFTYPE_ZIP)
3115             {
3116               const char *s = compress_algo_to_string (prefs[i].value);
3117
3118               if (any)
3119                 tty_printf (", ");
3120               any = 1;
3121               /* We don't want to display strings for experimental algos */
3122               if (s && prefs[i].value < 100)
3123                 tty_printf ("%s", s);
3124               else
3125                 tty_printf ("[%d]", prefs[i].value);
3126               if (prefs[i].value == COMPRESS_ALGO_NONE)
3127                 uncomp_seen = 1;
3128             }
3129         }
3130       if (!uncomp_seen)
3131         {
3132           if (any)
3133             tty_printf (", ");
3134           else
3135             {
3136               tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_ZIP));
3137               tty_printf (", ");
3138             }
3139           tty_printf ("%s", compress_algo_to_string (COMPRESS_ALGO_NONE));
3140         }
3141       if (uid->flags.mdc || uid->flags.aead || !uid->flags.ks_modify)
3142         {
3143           tty_printf ("\n     ");
3144           tty_printf (_("Features: "));
3145           any = 0;
3146           if (uid->flags.mdc)
3147             {
3148               tty_printf ("MDC");
3149               any = 1;
3150             }
3151           if (!uid->flags.aead)
3152             {
3153               if (any)
3154                 tty_printf (", ");
3155               tty_printf ("AEAD");
3156             }
3157           if (!uid->flags.ks_modify)
3158             {
3159               if (any)
3160                 tty_printf (", ");
3161               tty_printf (_("Keyserver no-modify"));
3162             }
3163         }
3164       tty_printf ("\n");
3165
3166       if (selfsig)
3167         {
3168           const byte *pref_ks;
3169           size_t pref_ks_len;
3170
3171           pref_ks = parse_sig_subpkt (selfsig->hashed,
3172                                       SIGSUBPKT_PREF_KS, &pref_ks_len);
3173           if (pref_ks && pref_ks_len)
3174             {
3175               tty_printf ("     ");
3176               tty_printf (_("Preferred keyserver: "));
3177               tty_print_utf8_string (pref_ks, pref_ks_len);
3178               tty_printf ("\n");
3179             }
3180
3181           if (selfsig->flags.notation)
3182             {
3183               tty_printf ("     ");
3184               tty_printf (_("Notations: "));
3185               tty_print_notations (5 + strlen (_("Notations: ")), selfsig);
3186             }
3187         }
3188     }
3189   else
3190     {
3191       tty_printf ("    ");
3192       for (i = 0; prefs[i].type; i++)
3193         {
3194           tty_printf (" %c%d", prefs[i].type == PREFTYPE_SYM ? 'S' :
3195                       prefs[i].type == PREFTYPE_AEAD ? 'A' :
3196                       prefs[i].type == PREFTYPE_HASH ? 'H' :
3197                       prefs[i].type == PREFTYPE_ZIP ? 'Z' : '?',
3198                       prefs[i].value);
3199         }
3200       if (uid->flags.mdc)
3201         tty_printf (" [mdc]");
3202       if (uid->flags.aead)
3203         tty_printf (" [aead]");
3204       if (!uid->flags.ks_modify)
3205         tty_printf (" [no-ks-modify]");
3206       tty_printf ("\n");
3207     }
3208 }
3209
3210
3211 /* This is the version of show_key_with_all_names used when
3212    opt.with_colons is used.  It prints all available data in a easy to
3213    parse format and does not translate utf8 */
3214 static void
3215 show_key_with_all_names_colon (ctrl_t ctrl, estream_t fp, kbnode_t keyblock)
3216 {
3217   KBNODE node;
3218   int i, j, ulti_hack = 0;
3219   byte pk_version = 0;
3220   PKT_public_key *primary = NULL;
3221   int have_seckey;
3222
3223   if (!fp)
3224     fp = es_stdout;
3225
3226   /* the keys */
3227   for (node = keyblock; node; node = node->next)
3228     {
3229       if (node->pkt->pkttype == PKT_PUBLIC_KEY
3230           || (node->pkt->pkttype == PKT_PUBLIC_SUBKEY))
3231         {
3232           PKT_public_key *pk = node->pkt->pkt.public_key;
3233           u32 keyid[2];
3234
3235           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3236             {
3237               pk_version = pk->version;
3238               primary = pk;
3239             }
3240
3241           keyid_from_pk (pk, keyid);
3242           have_seckey = !agent_probe_secret_key (ctrl, pk);
3243
3244           if (node->pkt->pkttype == PKT_PUBLIC_KEY)
3245             es_fputs (have_seckey? "sec:" : "pub:", fp);
3246           else
3247             es_fputs (have_seckey? "ssb:" : "sub:", fp);
3248
3249           if (!pk->flags.valid)
3250             es_putc ('i', fp);
3251           else if (pk->flags.revoked)
3252             es_putc ('r', fp);
3253           else if (pk->has_expired)
3254             es_putc ('e', fp);
3255           else if (!(opt.fast_list_mode || opt.no_expensive_trust_checks))
3256             {
3257               int trust = get_validity_info (ctrl, keyblock, pk, NULL);
3258               if (trust == 'u')
3259                 ulti_hack = 1;
3260               es_putc (trust, fp);
3261             }
3262
3263           es_fprintf (fp, ":%u:%d:%08lX%08lX:%lu:%lu::",
3264                       nbits_from_pk (pk),
3265                       pk->pubkey_algo,
3266                       (ulong) keyid[0], (ulong) keyid[1],
3267                       (ulong) pk->timestamp, (ulong) pk->expiredate);
3268           if (node->pkt->pkttype == PKT_PUBLIC_KEY
3269               && !(opt.fast_list_mode || opt.no_expensive_trust_checks))
3270             es_putc (get_ownertrust_info (ctrl, pk, 0), fp);
3271           es_putc (':', fp);
3272           es_putc (':', fp);
3273           es_putc (':', fp);
3274           /* Print capabilities.  */
3275           if ((pk->pubkey_usage & PUBKEY_USAGE_ENC))
3276             es_putc ('e', fp);
3277           if ((pk->pubkey_usage & PUBKEY_USAGE_SIG))
3278             es_putc ('s', fp);
3279           if ((pk->pubkey_usage & PUBKEY_USAGE_CERT))
3280             es_putc ('c', fp);
3281           if ((pk->pubkey_usage & PUBKEY_USAGE_AUTH))
3282             es_putc ('a', fp);
3283           es_putc ('\n', fp);
3284
3285           print_fingerprint (ctrl, fp, pk, 0);
3286           print_revokers (fp, pk);
3287         }
3288     }
3289
3290   /* the user ids */
3291   i = 0;
3292   for (node = keyblock; node; node = node->next)
3293     {
3294       if (node->pkt->pkttype == PKT_USER_ID)
3295         {
3296           PKT_user_id *uid = node->pkt->pkt.user_id;
3297
3298           ++i;
3299
3300           if (uid->attrib_data)
3301             es_fputs ("uat:", fp);
3302           else
3303             es_fputs ("uid:", fp);
3304
3305           if (uid->flags.revoked)
3306             es_fputs ("r::::::::", fp);
3307           else if (uid->flags.expired)
3308             es_fputs ("e::::::::", fp);
3309           else if (opt.fast_list_mode || opt.no_expensive_trust_checks)
3310             es_fputs ("::::::::", fp);
3311           else
3312             {
3313               int uid_validity;
3314
3315               if (primary && !ulti_hack)
3316                 uid_validity = get_validity_info (ctrl, keyblock, primary, uid);
3317               else
3318                 uid_validity = 'u';
3319               es_fprintf (fp, "%c::::::::", uid_validity);
3320             }
3321
3322           if (uid->attrib_data)
3323             es_fprintf (fp, "%u %lu", uid->numattribs, uid->attrib_len);
3324           else
3325             es_write_sanitized (fp, uid->name, uid->len, ":", NULL);
3326
3327           es_putc (':', fp);
3328           /* signature class */
3329           es_putc (':', fp);
3330           /* capabilities */
3331           es_putc (':', fp);
3332           /* preferences */
3333           if (pk_version > 3 || uid->selfsigversion > 3)
3334             {
3335               const prefitem_t *prefs = uid->prefs;
3336
3337               for (j = 0; prefs && prefs[j].type; j++)
3338                 {
3339                   if (j)
3340                     es_putc (' ', fp);
3341                   es_fprintf (fp,
3342                               "%c%d", prefs[j].type == PREFTYPE_SYM ? 'S' :
3343                               prefs[j].type == PREFTYPE_HASH ? 'H' :
3344                               prefs[j].type == PREFTYPE_ZIP ? 'Z' : '?',
3345                               prefs[j].value);
3346                 }
3347               if (uid->flags.mdc)
3348                 es_fputs (",mdc", fp);
3349               if (uid->flags.aead)
3350                 es_fputs (",aead", fp);
3351               if (!uid->flags.ks_modify)
3352                 es_fputs (",no-ks-modify", fp);
3353             }
3354           es_putc (':', fp);
3355           /* flags */
3356           es_fprintf (fp, "%d,", i);
3357           if (uid->flags.primary)
3358             es_putc ('p', fp);
3359           if (uid->flags.revoked)
3360             es_putc ('r', fp);
3361           if (uid->flags.expired)
3362             es_putc ('e', fp);
3363           if ((node->flag & NODFLG_SELUID))
3364             es_putc ('s', fp);
3365           if ((node->flag & NODFLG_MARK_A))
3366             es_putc ('m', fp);
3367           es_putc (':', fp);
3368           if (opt.trust_model == TM_TOFU || opt.trust_model == TM_TOFU_PGP)
3369             {
3370 #ifdef USE_TOFU
3371               enum tofu_policy policy;
3372               if (! tofu_get_policy (ctrl, primary, uid, &policy)
3373                   && policy != TOFU_POLICY_NONE)
3374                 es_fprintf (fp, "%s", tofu_policy_str (policy));
3375 #endif /*USE_TOFU*/
3376             }
3377           es_putc (':', fp);
3378           es_putc ('\n', fp);
3379         }
3380     }
3381 }
3382
3383
3384 static void
3385 show_names (ctrl_t ctrl, estream_t fp,
3386             kbnode_t keyblock, PKT_public_key * pk, unsigned int flag,