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