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