ready to release 0.4.3
[gnupg.git] / g10 / keyedit.c
1 /* keyedit.c - keyedit stuff
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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
29 #include "options.h"
30 #include "packet.h"
31 #include "errors.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "memory.h"
35 #include "util.h"
36 #include "main.h"
37 #include "trustdb.h"
38 #include "filter.h"
39 #include "ttyio.h"
40 #include "status.h"
41 #include "i18n.h"
42
43 static void show_prefs( KBNODE keyblock, PKT_user_id *uid );
44 static void show_key_with_all_names( KBNODE keyblock,
45             int only_marked, int with_fpr, int with_subkeys, int with_prefs );
46 static void show_key_and_fingerprint( KBNODE keyblock );
47 static void show_fingerprint( PKT_public_key *pk );
48 static int menu_adduid( KBNODE keyblock, KBNODE sec_keyblock );
49 static void menu_deluid( KBNODE pub_keyblock, KBNODE sec_keyblock );
50 static void menu_delkey( KBNODE pub_keyblock, KBNODE sec_keyblock );
51 static int menu_expire( KBNODE pub_keyblock, KBNODE sec_keyblock );
52 static int menu_select_uid( KBNODE keyblock, int index );
53 static int menu_select_key( KBNODE keyblock, int index );
54 static int count_uids( KBNODE keyblock );
55 static int count_uids_with_flag( KBNODE keyblock, unsigned flag );
56 static int count_keys_with_flag( KBNODE keyblock, unsigned flag );
57 static int count_selected_uids( KBNODE keyblock );
58 static int count_selected_keys( KBNODE keyblock );
59
60 #define CONTROL_D ('D' - 'A' + 1)
61
62 #define NODFLG_BADSIG (1<<0)  /* bad signature */
63 #define NODFLG_NOKEY  (1<<1)  /* no public key */
64 #define NODFLG_SIGERR (1<<2)  /* other sig error */
65
66 #define NODFLG_MARK_A (1<<4)  /* temporary mark */
67
68 #define NODFLG_SELUID (1<<8)  /* indicate the selected userid */
69 #define NODFLG_SELKEY (1<<9)  /* indicate the selected key */
70
71
72 static int
73 get_keyblock_byname( KBNODE *keyblock, KBPOS *kbpos, const char *username )
74 {
75     int rc;
76
77     *keyblock = NULL;
78     /* search the userid */
79     rc = find_keyblock_byname( kbpos, username );
80     if( rc ) {
81         log_error(_("%s: user not found\n"), username );
82         return rc;
83     }
84
85     /* read the keyblock */
86     rc = read_keyblock( kbpos, keyblock );
87     if( rc )
88         log_error("%s: keyblock read problem: %s\n", username, g10_errstr(rc));
89     else
90         merge_keys_and_selfsig( *keyblock );
91
92     return rc;
93 }
94
95
96 /****************
97  * Check the keysigs and set the flags to indicate errors.
98  * Returns true if error found.
99  */
100 static int
101 check_all_keysigs( KBNODE keyblock, int only_selected )
102 {
103     KBNODE kbctx;
104     KBNODE node;
105     int rc;
106     int inv_sigs = 0;
107     int no_key = 0;
108     int oth_err = 0;
109     int has_selfsig = 0;
110     int mis_selfsig = 0;
111     int selected = !only_selected;
112     int anyuid = 0;
113
114     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
115         if( node->pkt->pkttype == PKT_USER_ID ) {
116             PKT_user_id *uid = node->pkt->pkt.user_id;
117
118             if( only_selected )
119                 selected = (node->flag & NODFLG_SELUID);
120             if( selected ) {
121                 tty_printf("uid  ");
122                 tty_print_string( uid->name, uid->len );
123                 tty_printf("\n");
124                 if( anyuid && !has_selfsig )
125                     mis_selfsig++;
126                 has_selfsig = 0;
127                 anyuid = 1;
128             }
129         }
130         else if( selected && node->pkt->pkttype == PKT_SIGNATURE
131                  && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
132             PKT_signature *sig = node->pkt->pkt.signature;
133             int sigrc, selfsig;
134
135             switch( (rc = check_key_signature( keyblock, node, &selfsig)) ) {
136               case 0:
137                 node->flag &= ~(NODFLG_BADSIG|NODFLG_NOKEY|NODFLG_SIGERR);
138                 sigrc = '!';
139                 break;
140               case G10ERR_BAD_SIGN:
141                 node->flag = NODFLG_BADSIG;
142                 sigrc = '-';
143                 inv_sigs++;
144                 break;
145               case G10ERR_NO_PUBKEY:
146                 node->flag = NODFLG_NOKEY;
147                 sigrc = '?';
148                 no_key++;
149                 break;
150               default:
151                 node->flag = NODFLG_SIGERR;
152                 sigrc = '%';
153                 oth_err++;
154                 break;
155             }
156             if( sigrc != '?' ) {
157                 tty_printf("sig%c       %08lX %s   ",
158                         sigrc, sig->keyid[1], datestr_from_sig(sig));
159                 if( sigrc == '%' )
160                     tty_printf("[%s] ", g10_errstr(rc) );
161                 else if( sigrc == '?' )
162                     ;
163                 else if( selfsig ) {
164                     tty_printf( _("[self-signature]") );
165                     if( sigrc == '!' )
166                         has_selfsig = 1;
167                 }
168                 else {
169                     size_t n;
170                     char *p = get_user_id( sig->keyid, &n );
171                     tty_print_string( p, n > 40? 40 : n );
172                     m_free(p);
173                 }
174                 tty_printf("\n");
175                 /* fixme: Should we update the trustdb here */
176             }
177         }
178     }
179     if( !has_selfsig )
180         mis_selfsig++;
181     if( inv_sigs == 1 )
182         tty_printf(_("1 bad signature\n"), inv_sigs );
183     else if( inv_sigs )
184         tty_printf(_("%d bad signatures\n"), inv_sigs );
185     if( no_key == 1 )
186         tty_printf(_("1 signature not checked due to a missing key\n") );
187     else if( no_key )
188         tty_printf(_("%d signatures not checked due to missing keys\n"), no_key );
189     if( oth_err == 1 )
190         tty_printf(_("1 signature not checked due to an error\n") );
191     else if( oth_err )
192         tty_printf(_("%d signatures not checked due to errors\n"), oth_err );
193     if( mis_selfsig == 1 )
194         tty_printf(_("1 user id without valid self-signature detected\n"));
195     else if( mis_selfsig  )
196         tty_printf(_("%d user ids without valid self-signatures detected\n"),
197                                                                     mis_selfsig);
198
199     return inv_sigs || no_key || oth_err || mis_selfsig;
200 }
201
202
203 /****************
204  * Loop over all locusr and and sign the uids after asking.
205  * If no user id is marked, all user ids will be signed;
206  * if some user_ids are marked those will be signed.
207  *
208  * fixme: Add support for our proposed sign-all scheme
209  */
210 static int
211 sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified )
212 {
213     int rc = 0;
214     SK_LIST sk_list = NULL;
215     SK_LIST sk_rover = NULL;
216     PKT_secret_key *sk = NULL;
217     KBNODE node, uidnode;
218     PKT_public_key *primary_pk=NULL;
219     int select_all = !count_selected_uids(keyblock);
220     int upd_trust = 0;
221
222     /* build a list of all signators */
223     rc=build_sk_list( locusr, &sk_list, 0, 1 );
224     if( rc )
225         goto leave;
226
227     /* loop over all signaturs */
228     for( sk_rover = sk_list; sk_rover; sk_rover = sk_rover->next ) {
229         u32 sk_keyid[2];
230         size_t n;
231         char *p;
232
233         /* we have to use a copy of the sk, because make_keysig_packet
234          * may remove the protection from sk and if we did other
235          * changes to the secret key, we would save the unprotected
236          * version */
237         if( sk )
238             free_secret_key(sk);
239         sk = copy_secret_key( NULL, sk_rover->sk );
240         keyid_from_sk( sk, sk_keyid );
241         /* set mark A for all selected user ids */
242         for( node=keyblock; node; node = node->next ) {
243             if( select_all || (node->flag & NODFLG_SELUID) )
244                 node->flag |= NODFLG_MARK_A;
245             else
246                 node->flag &= ~NODFLG_MARK_A;
247         }
248         /* reset mark for uids which are already signed */
249         uidnode = NULL;
250         for( node=keyblock; node; node = node->next ) {
251             if( node->pkt->pkttype == PKT_USER_ID ) {
252                 uidnode = (node->flag & NODFLG_MARK_A)? node : NULL;
253             }
254             else if( uidnode && node->pkt->pkttype == PKT_SIGNATURE
255                 && (node->pkt->pkt.signature->sig_class&~3) == 0x10 ) {
256                 if( sk_keyid[0] == node->pkt->pkt.signature->keyid[0]
257                     && sk_keyid[1] == node->pkt->pkt.signature->keyid[1] ) {
258                     tty_printf(_("Already signed by key %08lX\n"),
259                                                         (ulong)sk_keyid[1] );
260                     uidnode->flag &= ~NODFLG_MARK_A; /* remove mark */
261                 }
262             }
263         }
264         /* check whether any uids are left for signing */
265         if( !count_uids_with_flag(keyblock, NODFLG_MARK_A) ) {
266             tty_printf(_("Nothing to sign with key %08lX\n"),
267                                                   (ulong)sk_keyid[1] );
268             continue;
269         }
270         /* Ask whether we really should sign these user id(s) */
271         tty_printf("\n");
272         show_key_with_all_names( keyblock, 1, 1, 0, 0 );
273         tty_printf("\n");
274         tty_printf(_(
275              "Are you really sure that you want to sign this key\n"
276              "with your key: \""));
277         p = get_user_id( sk_keyid, &n );
278         tty_print_string( p, n );
279         m_free(p); p = NULL;
280         tty_printf("\"\n\n");
281
282         if( !cpr_get_answer_is_yes(N_("sign_uid.okay"), _("Really sign? ")) )
283             continue;;
284         /* now we can sign the user ids */
285       reloop: /* (must use this, because we are modifing the list) */
286         primary_pk = NULL;
287         for( node=keyblock; node; node = node->next ) {
288             if( node->pkt->pkttype == PKT_PUBLIC_KEY )
289                 primary_pk = node->pkt->pkt.public_key;
290             else if( node->pkt->pkttype == PKT_USER_ID
291                      && (node->flag & NODFLG_MARK_A) ) {
292                 PACKET *pkt;
293                 PKT_signature *sig;
294
295                 assert( primary_pk );
296                 node->flag &= ~NODFLG_MARK_A;
297                 rc = make_keysig_packet( &sig, primary_pk,
298                                                node->pkt->pkt.user_id,
299                                                NULL,
300                                                sk,
301                                                0x10, 0, NULL, NULL );
302                 if( rc ) {
303                     log_error(_("signing failed: %s\n"), g10_errstr(rc));
304                     goto leave;
305                 }
306                 *ret_modified = 1; /* we changed the keyblock */
307                 upd_trust = 1;
308
309                 pkt = m_alloc_clear( sizeof *pkt );
310                 pkt->pkttype = PKT_SIGNATURE;
311                 pkt->pkt.signature = sig;
312                 insert_kbnode( node, new_kbnode(pkt), PKT_SIGNATURE );
313                 goto reloop;
314             }
315         }
316     } /* end loop over signators */
317     if( upd_trust && primary_pk ) {
318         rc = clear_trust_checked_flag( primary_pk );
319     }
320
321
322   leave:
323     release_sk_list( sk_list );
324     if( sk )
325         free_secret_key(sk);
326     return rc;
327 }
328
329
330
331 /****************
332  * Change the passphrase of the primary and all secondary keys.
333  * We use only one passphrase for all keys.
334  */
335 static int
336 change_passphrase( KBNODE keyblock )
337 {
338     int rc = 0;
339     int changed=0;
340     KBNODE node;
341     PKT_secret_key *sk;
342     char *passphrase = NULL;
343
344     node = find_kbnode( keyblock, PKT_SECRET_KEY );
345     if( !node ) {
346         log_error("Oops; secret key not found anymore!\n");
347         goto leave;
348     }
349     sk = node->pkt->pkt.secret_key;
350
351     switch( is_secret_key_protected( sk ) ) {
352       case -1:
353         rc = G10ERR_PUBKEY_ALGO;
354         break;
355       case 0:
356         tty_printf(_("This key is not protected.\n"));
357         break;
358       default:
359         tty_printf(_("Key is protected.\n"));
360         rc = check_secret_key( sk, 0 );
361         if( !rc )
362             passphrase = get_last_passphrase();
363         break;
364     }
365
366     /* unprotect all subkeys (use the supplied passphrase or ask)*/
367     for(node=keyblock; !rc && node; node = node->next ) {
368         if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
369             PKT_secret_key *subsk = node->pkt->pkt.secret_key;
370             set_next_passphrase( passphrase );
371             rc = check_secret_key( subsk, 0 );
372         }
373     }
374
375     if( rc )
376         tty_printf(_("Can't edit this key: %s\n"), g10_errstr(rc));
377     else {
378         DEK *dek = NULL;
379         STRING2KEY *s2k = m_alloc_secure( sizeof *s2k );
380
381         tty_printf(_("Enter the new passphrase for this secret key.\n\n") );
382
383         set_next_passphrase( NULL );
384         for(;;) {
385             s2k->mode = opt.s2k_mode;
386             s2k->hash_algo = opt.s2k_digest_algo;
387             dek = passphrase_to_dek( NULL, opt.s2k_cipher_algo, s2k, 2 );
388             if( !dek ) {
389                 tty_printf(_("passphrase not correctly repeated; try again.\n"));
390             }
391             else if( !dek->keylen ) {
392                 rc = 0;
393                 tty_printf(_( "You don't want a passphrase -"
394                             " this is probably a *bad* idea!\n\n"));
395                 if( cpr_get_answer_is_yes(N_("change_passwd.empty.okay"),
396                                _("Do you really want to do this? ")))
397                     changed++;
398                 break;
399             }
400             else { /* okay */
401                 sk->protect.algo = dek->algo;
402                 sk->protect.s2k = *s2k;
403                 rc = protect_secret_key( sk, dek );
404                 for(node=keyblock; !rc && node; node = node->next ) {
405                     if( node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
406                         PKT_secret_key *subsk = node->pkt->pkt.secret_key;
407                         subsk->protect.algo = dek->algo;
408                         subsk->protect.s2k = *s2k;
409                         rc = protect_secret_key( subsk, dek );
410                     }
411                 }
412                 if( rc )
413                     log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
414                 else
415                     changed++;
416                 break;
417             }
418         }
419         m_free(s2k);
420         m_free(dek);
421     }
422
423   leave:
424     m_free( passphrase );
425     set_next_passphrase( NULL );
426     return changed && !rc;
427 }
428
429
430 /****************
431  * There are some keys out (due to a bug in gnupg), where the sequence
432  * of the packets is wrong.  This function fixes that.
433  * Returns: true if the keyblock has fixed.
434  */
435 static int
436 fix_keyblock( KBNODE keyblock )
437 {
438     KBNODE node, last, subkey;
439     int fixed=0;
440
441     /* locate key signatures of class 0x10..0x13 behind sub key packets */
442     for( subkey=last=NULL, node = keyblock; node;
443                                             last=node, node = node->next ) {
444         switch( node->pkt->pkttype ) {
445           case PKT_PUBLIC_SUBKEY:
446           case PKT_SECRET_SUBKEY:
447             if( !subkey )
448                 subkey = last; /* actually it is the one before the subkey */
449             break;
450           case PKT_SIGNATURE:
451             if( subkey ) {
452                 PKT_signature *sig = node->pkt->pkt.signature;
453                 if( sig->sig_class >= 0x10 && sig->sig_class <= 0x13 ) {
454                     log_info("moving a key signature to the correct place\n");
455                     last->next = node->next;
456                     node->next = subkey->next;
457                     subkey->next = node;
458                     node = last;
459                     fixed=1;
460                 }
461             }
462             break;
463           default: break;
464         }
465     }
466
467     return fixed;
468 }
469
470 /****************
471  * Menu driven key editor
472  *
473  * Note: to keep track of some selection we use node->mark MARKBIT_xxxx.
474  */
475
476 void
477 keyedit_menu( const char *username, STRLIST locusr )
478 {
479     enum cmdids { cmdNONE = 0,
480            cmdQUIT, cmdHELP, cmdFPR, cmdLIST, cmdSELUID, cmdCHECK, cmdSIGN,
481            cmdDEBUG, cmdSAVE, cmdADDUID, cmdDELUID, cmdADDKEY, cmdDELKEY,
482            cmdTOGGLE, cmdSELKEY, cmdPASSWD, cmdTRUST, cmdPREF, cmdEXPIRE,
483            cmdNOP };
484     static struct { const char *name;
485                     enum cmdids id;
486                     int need_sk;
487                     const char *desc;
488                   } cmds[] = {
489         { N_("quit")    , cmdQUIT   , 0, N_("quit this menu") },
490         { N_("q")       , cmdQUIT   , 0, NULL   },
491         { N_("save")    , cmdSAVE   , 0, N_("save and quit") },
492         { N_("help")    , cmdHELP   , 0, N_("show this help") },
493         {    "?"        , cmdHELP   , 0, NULL   },
494         { N_("fpr")     , cmdFPR    , 0, N_("show fingerprint") },
495         { N_("list")    , cmdLIST   , 0, N_("list key and user ids") },
496         { N_("l")       , cmdLIST   , 0, NULL   },
497         { N_("uid")     , cmdSELUID , 0, N_("select user id N") },
498         { N_("key")     , cmdSELKEY , 0, N_("select secondary key N") },
499         { N_("check")   , cmdCHECK  , 0, N_("list signatures") },
500         { N_("c")       , cmdCHECK  , 0, NULL },
501         { N_("sign")    , cmdSIGN   , 0, N_("sign the key") },
502         { N_("s")       , cmdSIGN   , 0, NULL },
503         { N_("debug")   , cmdDEBUG  , 0, NULL },
504         { N_("adduid")  , cmdADDUID , 1, N_("add a user id") },
505         { N_("deluid")  , cmdDELUID , 0, N_("delete user id") },
506         { N_("addkey")  , cmdADDKEY , 1, N_("add a secondary key") },
507         { N_("delkey")  , cmdDELKEY , 0, N_("delete a secondary key") },
508         { N_("expire")  , cmdEXPIRE , 1, N_("change the expire date") },
509         { N_("toggle")  , cmdTOGGLE , 1, N_("toggle between secret "
510                                             "and public key listing") },
511         { N_("t"     )  , cmdTOGGLE , 1, NULL },
512         { N_("pref")    , cmdPREF  , 0, N_("list preferences") },
513         { N_("passwd")  , cmdPASSWD , 1, N_("change the passphrase") },
514         { N_("trust")   , cmdTRUST , 0, N_("change the ownertrust") },
515
516     { NULL, cmdNONE } };
517     enum cmdids cmd;
518     int rc = 0;
519     KBNODE keyblock = NULL;
520     KBPOS keyblockpos;
521     KBNODE sec_keyblock = NULL;
522     KBPOS sec_keyblockpos;
523     KBNODE cur_keyblock;
524     char *answer = NULL;
525     int redisplay = 1;
526     int modified = 0;
527     int sec_modified = 0;
528     int toggle;
529
530
531     if( opt.batch ) {
532         log_error(_("can't do that in batchmode\n"));
533         goto leave;
534     }
535
536     /* first try to locate it as secret key */
537     rc = find_secret_keyblock_byname( &sec_keyblockpos, username );
538     if( !rc ) {
539         rc = read_keyblock( &sec_keyblockpos, &sec_keyblock );
540         if( rc ) {
541             log_error("%s: secret keyblock read problem: %s\n",
542                                             username, g10_errstr(rc));
543             goto leave;
544         }
545         merge_keys_and_selfsig( sec_keyblock );
546         if( fix_keyblock( sec_keyblock ) )
547             sec_modified++;
548     }
549
550     /* and now get the public key */
551     rc = get_keyblock_byname( &keyblock, &keyblockpos, username );
552     if( rc )
553         goto leave;
554     if( fix_keyblock( keyblock ) )
555         modified++;
556
557     if( sec_keyblock ) { /* check that they match */
558         /* FIXME: check that they both match */
559         tty_printf(_("Secret key is available.\n"));
560     }
561
562     toggle = 0;
563     cur_keyblock = keyblock;
564     for(;;) { /* main loop */
565         int i, arg_number;
566         char *p;
567
568         tty_printf("\n");
569         if( redisplay ) {
570             show_key_with_all_names( cur_keyblock, 0, 0, 1, 0 );
571             tty_printf("\n");
572             redisplay = 0;
573         }
574         do {
575             m_free(answer);
576             answer = cpr_get(N_("keyedit.cmd"), _("Command> "));
577             cpr_kill_prompt();
578             trim_spaces(answer);
579         } while( *answer == '#' );
580
581         arg_number = 0;
582         if( !*answer )
583             cmd = cmdLIST;
584         else if( *answer == CONTROL_D )
585             cmd = cmdQUIT;
586         else if( isdigit( *answer ) ) {
587             cmd = cmdSELUID;
588             arg_number = atoi(answer);
589         }
590         else {
591             if( (p=strchr(answer,' ')) ) {
592                 *p++ = 0;
593                 trim_spaces(answer);
594                 trim_spaces(p);
595                 arg_number = atoi(p);
596             }
597
598             for(i=0; cmds[i].name; i++ )
599                 if( !stricmp( answer, cmds[i].name ) )
600                     break;
601             if( cmds[i].need_sk && !sec_keyblock ) {
602                 tty_printf(_("Need the secret key to to this.\n"));
603                 cmd = cmdNOP;
604             }
605             else
606                 cmd = cmds[i].id;
607         }
608         switch( cmd )  {
609           case cmdHELP:
610             for(i=0; cmds[i].name; i++ ) {
611                 if( cmds[i].need_sk && !sec_keyblock )
612                     ; /* skip if we do not have the secret key */
613                 else if( cmds[i].desc )
614                     tty_printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
615             }
616             break;
617
618           case cmdQUIT:
619             if( !modified && !sec_modified )
620                 goto leave;
621             if( !cpr_get_answer_is_yes(N_("keyedit.save.okay"),
622                                         _("Save changes? ")) ) {
623                 if( cpr_enabled()
624                     || cpr_get_answer_is_yes(N_("keyedit.cancel.okay"),
625                                              _("Quit without saving? ")) )
626                     goto leave;
627                 break;
628             }
629             /* fall thru */
630           case cmdSAVE:
631             if( modified || sec_modified  ) {
632                 if( modified ) {
633                     rc = update_keyblock( &keyblockpos, keyblock );
634                     if( rc ) {
635                         log_error(_("update failed: %s\n"), g10_errstr(rc) );
636                         break;
637                     }
638                 }
639                 if( sec_modified ) {
640                     rc = update_keyblock( &sec_keyblockpos, sec_keyblock );
641                     if( rc ) {
642                         log_error(_("update secret failed: %s\n"),
643                                                             g10_errstr(rc) );
644                         break;
645                     }
646                 }
647             }
648             else
649                 tty_printf(_("Key not changed so no update needed.\n"));
650             rc = update_trust_record( keyblock, 0, NULL );
651             if( rc )
652                 log_error(_("update of trust db failed: %s\n"),
653                             g10_errstr(rc) );
654             goto leave;
655
656           case cmdLIST:
657             redisplay = 1;
658             break;
659
660           case cmdFPR:
661             show_key_and_fingerprint( keyblock );
662             break;
663
664           case cmdSELUID:
665             if( menu_select_uid( cur_keyblock, arg_number ) )
666                 redisplay = 1;
667             break;
668
669           case cmdSELKEY:
670             if( menu_select_key( cur_keyblock, arg_number ) )
671                 redisplay = 1;
672             break;
673
674           case cmdCHECK:
675             /* we can only do this with the public key becuase the
676              * check functions can't cope with secret keys and it
677              * is questionable whether this would make sense at all */
678             check_all_keysigs( keyblock, count_selected_uids(keyblock) );
679             break;
680
681           case cmdSIGN: /* sign (only the public key) */
682             if( count_uids(keyblock) > 1 && !count_selected_uids(keyblock) ) {
683                 if( !cpr_get_answer_is_yes(N_("keyedit.sign_all.okay"),
684                                            _("Really sign all user ids? ")) ) {
685                     tty_printf(_("Hint: Select the user ids to sign\n"));
686                     break;
687                 }
688             }
689             sign_uids( keyblock, locusr, &modified );
690             break;
691
692           case cmdDEBUG:
693             dump_kbnode( cur_keyblock );
694             break;
695
696           case cmdTOGGLE:
697             toggle = !toggle;
698             cur_keyblock = toggle? sec_keyblock : keyblock;
699             redisplay = 1;
700             break;
701
702           case cmdADDUID:
703             if( menu_adduid( keyblock, sec_keyblock ) ) {
704                 redisplay = 1;
705                 sec_modified = modified = 1;
706                 /* must update the trustdb already here, so that preferences
707                  * get listed correctly */
708                 rc = update_trust_record( keyblock, 0, NULL );
709                 if( rc ) {
710                     log_error(_("update of trust db failed: %s\n"),
711                                 g10_errstr(rc) );
712                     rc = 0;
713                 }
714             }
715             break;
716
717           case cmdDELUID: {
718                 int n1;
719
720                 if( !(n1=count_selected_uids(keyblock)) )
721                     tty_printf(_("You must select at least one user id.\n"));
722                 else if( count_uids(keyblock) - n1 < 1 )
723                     tty_printf(_("You can't delete the last user id!\n"));
724                 else if( cpr_get_answer_is_yes(
725                             N_("keyedit.remove.uid.okay"),
726                         n1 > 1? _("Really remove all selected user ids? ")
727                               : _("Really remove this user id? ")
728                        ) ) {
729                     menu_deluid( keyblock, sec_keyblock );
730                     redisplay = 1;
731                     modified = 1;
732                     if( sec_keyblock )
733                        sec_modified = 1;
734                 }
735             }
736             break;
737
738           case cmdADDKEY:
739             if( generate_subkeypair( keyblock, sec_keyblock ) ) {
740                 redisplay = 1;
741                 sec_modified = modified = 1;
742             }
743             break;
744
745
746           case cmdDELKEY: {
747                 int n1;
748
749                 if( !(n1=count_selected_keys( keyblock )) )
750                     tty_printf(_("You must select at least one key.\n"));
751                 else if( sec_keyblock && !cpr_get_answer_is_yes(
752                             N_("keyedit.remove.subkey.okay"),
753                        n1 > 1?
754                         _("Do you really want to delete the selected keys? "):
755                         _("Do you really want to delete this key? ")
756                        ))
757                     ;
758                 else {
759                     menu_delkey( keyblock, sec_keyblock );
760                     redisplay = 1;
761                     modified = 1;
762                     if( sec_keyblock )
763                        sec_modified = 1;
764                 }
765             }
766             break;
767
768           case cmdEXPIRE:
769             if( menu_expire( keyblock, sec_keyblock ) ) {
770                 merge_keys_and_selfsig( sec_keyblock );
771                 merge_keys_and_selfsig( keyblock );
772                 sec_modified = 1;
773                 modified = 1;
774                 redisplay = 1;
775             }
776             break;
777
778           case cmdPASSWD:
779             if( change_passphrase( sec_keyblock ) )
780                 sec_modified = 1;
781             break;
782
783           case cmdTRUST:
784             show_key_with_all_names( keyblock, 0, 0, 1, 0 );
785             tty_printf("\n");
786             if( edit_ownertrust( find_kbnode( keyblock,
787                       PKT_PUBLIC_KEY )->pkt->pkt.public_key->local_id, 1 ) )
788                 redisplay = 1;
789             /* we don't need to set modified here, as the trustvalues
790              * are updated immediately */
791             break;
792
793           case cmdPREF:
794             show_key_with_all_names( keyblock, 0, 0, 0, 1 );
795             break;
796
797           case cmdNOP:
798             break;
799
800           default:
801             tty_printf("\n");
802             tty_printf(_("Invalid command  (try \"help\")\n"));
803             break;
804         }
805     } /* end main loop */
806
807   leave:
808     release_kbnode( keyblock );
809     release_kbnode( sec_keyblock );
810     m_free(answer);
811 }
812
813
814 /****************
815  * show preferences of a public keyblock.
816  */
817 static void
818 show_prefs( KBNODE keyblock, PKT_user_id *uid )
819 {
820     KBNODE node = find_kbnode( keyblock, PKT_PUBLIC_KEY );
821     PKT_public_key *pk;
822     byte *p;
823     int i;
824     size_t n;
825     byte namehash[20];
826
827     if( !node )
828         return; /* is a secret keyblock */
829     pk = node->pkt->pkt.public_key;
830     if( !pk->local_id ) {
831         log_error("oops: no LID\n");
832         return;
833     }
834
835     rmd160_hash_buffer( namehash, uid->name, uid->len );
836
837     p = get_pref_data( pk->local_id, namehash, &n );
838     if( !p )
839         return;
840
841     tty_printf("    ");
842     for(i=0; i < n; i+=2 ) {
843         if( p[i] )
844             tty_printf( " %c%d", p[i] == PREFTYPE_SYM    ? 'S' :
845                                  p[i] == PREFTYPE_HASH   ? 'H' :
846                                  p[i] == PREFTYPE_COMPR  ? 'Z' : '?', p[i+1]);
847     }
848     tty_printf("\n");
849
850     m_free(p);
851 }
852
853
854 /****************
855  * Display the key a the user ids, if only_marked is true, do only
856  * so for user ids with mark A flag set and dont display the index number
857  */
858 static void
859 show_key_with_all_names( KBNODE keyblock, int only_marked,
860                          int with_fpr, int with_subkeys, int with_prefs )
861 {
862     KBNODE node;
863     int i;
864
865     /* the keys */
866     for( node = keyblock; node; node = node->next ) {
867         if( node->pkt->pkttype == PKT_PUBLIC_KEY
868             || (with_subkeys && node->pkt->pkttype == PKT_PUBLIC_SUBKEY) ) {
869             PKT_public_key *pk = node->pkt->pkt.public_key;
870             int otrust=0, trust=0;
871
872             if( node->pkt->pkttype == PKT_PUBLIC_KEY ) {
873                 /* do it here, so that debug messages don't clutter the
874                  * output */
875                 trust = query_trust_info(pk);
876                 otrust = get_ownertrust_info( pk->local_id );
877             }
878
879             tty_printf("%s%c %4u%c/%08lX  created: %s expires: %s",
880                           node->pkt->pkttype == PKT_PUBLIC_KEY? "pub":"sub",
881                           (node->flag & NODFLG_SELKEY)? '*':' ',
882                           nbits_from_pk( pk ),
883                           pubkey_letter( pk->pubkey_algo ),
884                           (ulong)keyid_from_pk(pk,NULL),
885                           datestr_from_pk(pk),
886                           expirestr_from_pk(pk) );
887             if( node->pkt->pkttype == PKT_PUBLIC_KEY ) {
888                 tty_printf(" trust: %c/%c", otrust, trust );
889                 if( with_fpr  ) {
890                     tty_printf("\n");
891                     show_fingerprint( pk );
892                 }
893             }
894             tty_printf("\n");
895         }
896         else if( node->pkt->pkttype == PKT_SECRET_KEY
897             || (with_subkeys && node->pkt->pkttype == PKT_SECRET_SUBKEY) ) {
898             PKT_secret_key *sk = node->pkt->pkt.secret_key;
899             tty_printf("%s%c %4u%c/%08lX  created: %s expires: %s\n",
900                           node->pkt->pkttype == PKT_SECRET_KEY? "sec":"sbb",
901                           (node->flag & NODFLG_SELKEY)? '*':' ',
902                           nbits_from_sk( sk ),
903                           pubkey_letter( sk->pubkey_algo ),
904                           (ulong)keyid_from_sk(sk,NULL),
905                           datestr_from_sk(sk),
906                           expirestr_from_sk(sk) );
907         }
908     }
909     /* the user ids */
910     i = 0;
911     for( node = keyblock; node; node = node->next ) {
912         if( node->pkt->pkttype == PKT_USER_ID ) {
913             PKT_user_id *uid = node->pkt->pkt.user_id;
914             ++i;
915             if( !only_marked || (only_marked && (node->flag & NODFLG_MARK_A))){
916                 if( only_marked )
917                    tty_printf("     ");
918                 else if( node->flag & NODFLG_SELUID )
919                    tty_printf("(%d)* ", i);
920                 else
921                    tty_printf("(%d)  ", i);
922                 tty_print_string( uid->name, uid->len );
923                 tty_printf("\n");
924                 if( with_prefs )
925                     show_prefs( keyblock, uid );
926             }
927         }
928     }
929 }
930
931 static void
932 show_key_and_fingerprint( KBNODE keyblock )
933 {
934     KBNODE node;
935     PKT_public_key *pk = NULL;
936
937     for( node = keyblock; node; node = node->next ) {
938         if( node->pkt->pkttype == PKT_PUBLIC_KEY ) {
939             pk = node->pkt->pkt.public_key;
940             tty_printf("pub  %4u%c/%08lX %s ",
941                           nbits_from_pk( pk ),
942                           pubkey_letter( pk->pubkey_algo ),
943                           (ulong)keyid_from_pk(pk,NULL),
944                           datestr_from_pk(pk) );
945         }
946         else if( node->pkt->pkttype == PKT_USER_ID ) {
947             PKT_user_id *uid = node->pkt->pkt.user_id;
948             tty_print_string( uid->name, uid->len );
949             break;
950         }
951     }
952     tty_printf("\n");
953     if( pk )
954         show_fingerprint( pk );
955 }
956
957
958 static void
959 show_fingerprint( PKT_public_key *pk )
960 {
961     byte array[MAX_FINGERPRINT_LEN], *p;
962     size_t i, n;
963
964     fingerprint_from_pk( pk, array, &n );
965     p = array;
966     tty_printf("             Fingerprint:");
967     if( n == 20 ) {
968         for(i=0; i < n ; i++, i++, p += 2 ) {
969             if( i == 10 )
970                 tty_printf(" ");
971             tty_printf(" %02X%02X", *p, p[1] );
972         }
973     }
974     else {
975         for(i=0; i < n ; i++, p++ ) {
976             if( i && !(i%8) )
977                 tty_printf(" ");
978             tty_printf(" %02X", *p );
979         }
980     }
981     tty_printf("\n");
982 }
983
984
985 /****************
986  * Ask for a new user id , do the selfsignature and put it into
987  * both keyblocks.
988  * Return true if there is a new user id
989  */
990 static int
991 menu_adduid( KBNODE pub_keyblock, KBNODE sec_keyblock )
992 {
993     PKT_user_id *uid;
994     PKT_public_key *pk=NULL;
995     PKT_secret_key *sk=NULL;
996     PKT_signature *sig=NULL;
997     PACKET *pkt;
998     KBNODE node;
999     KBNODE pub_where=NULL, sec_where=NULL;
1000     int rc;
1001
1002     uid = generate_user_id();
1003     if( !uid )
1004         return 0;
1005
1006     for( node = pub_keyblock; node; pub_where = node, node = node->next ) {
1007         if( node->pkt->pkttype == PKT_PUBLIC_KEY )
1008             pk = node->pkt->pkt.public_key;
1009         else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1010             break;
1011     }
1012     if( !node ) /* no subkey */
1013         pub_where = NULL;
1014     for( node = sec_keyblock; node; sec_where = node, node = node->next ) {
1015         if( node->pkt->pkttype == PKT_SECRET_KEY )
1016             sk = copy_secret_key( NULL, node->pkt->pkt.secret_key);
1017         else if( node->pkt->pkttype == PKT_SECRET_SUBKEY )
1018             break;
1019     }
1020     if( !node ) /* no subkey */
1021         sec_where = NULL;
1022     assert(pk && sk );
1023
1024     rc = make_keysig_packet( &sig, pk, uid, NULL, sk, 0x13, 0,
1025                              keygen_add_std_prefs, sk );
1026     free_secret_key( sk );
1027     if( rc ) {
1028         log_error("signing failed: %s\n", g10_errstr(rc) );
1029         free_user_id(uid);
1030         return 0;
1031     }
1032
1033     /* insert/append to secret keyblock */
1034     pkt = m_alloc_clear( sizeof *pkt );
1035     pkt->pkttype = PKT_USER_ID;
1036     pkt->pkt.user_id = copy_user_id(NULL, uid);
1037     node = new_kbnode(pkt);
1038     if( sec_where )
1039         insert_kbnode( sec_where, node, 0 );
1040     else
1041         add_kbnode( sec_keyblock, node );
1042     pkt = m_alloc_clear( sizeof *pkt );
1043     pkt->pkttype = PKT_SIGNATURE;
1044     pkt->pkt.signature = copy_signature(NULL, sig);
1045     if( sec_where )
1046         insert_kbnode( node, new_kbnode(pkt), 0 );
1047     else
1048         add_kbnode( sec_keyblock, new_kbnode(pkt) );
1049     /* insert/append to public keyblock */
1050     pkt = m_alloc_clear( sizeof *pkt );
1051     pkt->pkttype = PKT_USER_ID;
1052     pkt->pkt.user_id = uid;
1053     node = new_kbnode(pkt);
1054     if( pub_where )
1055         insert_kbnode( pub_where, node, 0 );
1056     else
1057         add_kbnode( pub_keyblock, node );
1058     pkt = m_alloc_clear( sizeof *pkt );
1059     pkt->pkttype = PKT_SIGNATURE;
1060     pkt->pkt.signature = copy_signature(NULL, sig);
1061     if( pub_where )
1062         insert_kbnode( node, new_kbnode(pkt), 0 );
1063     else
1064         add_kbnode( pub_keyblock, new_kbnode(pkt) );
1065     return 1;
1066 }
1067
1068
1069 /****************
1070  * Remove all selceted userids from the keyrings
1071  */
1072 static void
1073 menu_deluid( KBNODE pub_keyblock, KBNODE sec_keyblock )
1074 {
1075     KBNODE node;
1076     int selected=0;
1077
1078     for( node = pub_keyblock; node; node = node->next ) {
1079         if( node->pkt->pkttype == PKT_USER_ID ) {
1080             selected = node->flag & NODFLG_SELUID;
1081             if( selected ) {
1082                 delete_kbnode( node );
1083                 if( sec_keyblock ) {
1084                     KBNODE snode;
1085                     int s_selected = 0;
1086                     PKT_user_id *uid = node->pkt->pkt.user_id;
1087                     for( snode = sec_keyblock; snode; snode = snode->next ) {
1088                         if( snode->pkt->pkttype == PKT_USER_ID ) {
1089                             PKT_user_id *suid = snode->pkt->pkt.user_id;
1090
1091                             s_selected =
1092                                 (uid->len == suid->len
1093                                  && !memcmp( uid->name, suid->name, uid->len));
1094                             if( s_selected )
1095                                 delete_kbnode( snode );
1096                         }
1097                         else if( s_selected
1098                                  && snode->pkt->pkttype == PKT_SIGNATURE )
1099                             delete_kbnode( snode );
1100                         else if( snode->pkt->pkttype == PKT_SECRET_SUBKEY )
1101                             s_selected = 0;
1102                     }
1103                 }
1104             }
1105         }
1106         else if( selected && node->pkt->pkttype == PKT_SIGNATURE )
1107             delete_kbnode( node );
1108         else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY )
1109             selected = 0;
1110     }
1111     commit_kbnode( &pub_keyblock );
1112     if( sec_keyblock )
1113         commit_kbnode( &sec_keyblock );
1114 }
1115
1116
1117 /****************
1118  * Remove some of the secondary keys
1119  */
1120 static void
1121 menu_delkey( KBNODE pub_keyblock, KBNODE sec_keyblock )
1122 {
1123     KBNODE node;
1124     int selected=0;
1125
1126     for( node = pub_keyblock; node; node = node->next ) {
1127         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
1128             selected = node->flag & NODFLG_SELKEY;
1129             if( selected ) {
1130                 delete_kbnode( node );
1131                 if( sec_keyblock ) {
1132                     KBNODE snode;
1133                     int s_selected = 0;
1134                     u32 ki[2];
1135
1136                     keyid_from_pk( node->pkt->pkt.public_key, ki );
1137                     for( snode = sec_keyblock; snode; snode = snode->next ) {
1138                         if( snode->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1139                             u32 ki2[2];
1140
1141                             keyid_from_sk( snode->pkt->pkt.secret_key, ki2 );
1142                             s_selected = (ki[0] == ki2[0] && ki[1] == ki2[1]);
1143                             if( s_selected )
1144                                 delete_kbnode( snode );
1145                         }
1146                         else if( s_selected
1147                                  && snode->pkt->pkttype == PKT_SIGNATURE )
1148                             delete_kbnode( snode );
1149                         else
1150                             s_selected = 0;
1151                     }
1152                 }
1153             }
1154         }
1155         else if( selected && node->pkt->pkttype == PKT_SIGNATURE )
1156             delete_kbnode( node );
1157         else
1158             selected = 0;
1159     }
1160     commit_kbnode( &pub_keyblock );
1161     if( sec_keyblock )
1162         commit_kbnode( &sec_keyblock );
1163 }
1164
1165
1166
1167 static int
1168 menu_expire( KBNODE pub_keyblock, KBNODE sec_keyblock )
1169 {
1170     int n1, rc;
1171     u32 expiredate;
1172     int mainkey=0;
1173     PKT_secret_key *sk;    /* copy of the main sk */
1174     PKT_public_key *main_pk, *sub_pk;
1175     PKT_user_id *uid;
1176     KBNODE node;
1177     u32 keyid[2];
1178
1179     if( count_selected_keys( sec_keyblock ) ) {
1180         tty_printf(_("Please remove selections from the secret keys.\n"));
1181         return 0;
1182     }
1183
1184     n1 = count_selected_keys( pub_keyblock );
1185     if( n1 > 1 ) {
1186         tty_printf(_("Please select at most one secondary key.\n"));
1187         return 0;
1188     }
1189     else if( n1 )
1190         tty_printf(_("Changing exiration time for a secondary key.\n"));
1191     else {
1192         tty_printf(_("Changing exiration time for the primary key.\n"));
1193         mainkey=1;
1194     }
1195
1196     expiredate = ask_expiredate();
1197     /* fixme: check that expiredate is > key creation date */
1198
1199     /* get the secret key , make a copy and set the expiration time into
1200      * that key (because keygen_add-key-expire expects it there)
1201      */
1202     node = find_kbnode( sec_keyblock, PKT_SECRET_KEY );
1203     sk = copy_secret_key( NULL, node->pkt->pkt.secret_key);
1204     sk->expiredate = expiredate;
1205
1206     /* Now we can actually change the self signature(s) */
1207     main_pk = sub_pk = NULL;
1208     uid = NULL;
1209     for( node=pub_keyblock; node; node = node->next ) {
1210         if( node->pkt->pkttype == PKT_PUBLIC_KEY ) {
1211             main_pk = node->pkt->pkt.public_key;
1212             keyid_from_pk( main_pk, keyid );
1213         }
1214         else if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1215                  && (node->flag & NODFLG_SELKEY ) )
1216             sub_pk = node->pkt->pkt.public_key;
1217         else if( node->pkt->pkttype == PKT_USER_ID )
1218             uid = node->pkt->pkt.user_id;
1219         else if( main_pk && node->pkt->pkttype == PKT_SIGNATURE ) {
1220             PKT_signature *sig = node->pkt->pkt.signature;
1221             if( keyid[0] == sig->keyid[0] && keyid[1] == sig->keyid[1]
1222                 && (    (mainkey && uid && (sig->sig_class&~3) == 0x10)
1223                      || (!mainkey && sig->sig_class == 0x18)  ) ) {
1224                 /* this is a selfsignature which should be replaced */
1225                 PKT_signature *newsig;
1226                 PACKET *newpkt;
1227                 KBNODE sn;
1228
1229                 /* find the corresponding secret self-signature */
1230                 for( sn=sec_keyblock; sn; sn = sn->next ) {
1231                     if( sn->pkt->pkttype == PKT_SIGNATURE
1232                         && !cmp_signatures( sn->pkt->pkt.signature, sig ) )
1233                         break;
1234                 }
1235                 if( !sn )
1236                     log_info(_("No corresponding signature in secret ring\n"));
1237
1238                 /* create new self signature */
1239                 if( mainkey )
1240                     rc = make_keysig_packet( &newsig, main_pk, uid, NULL,
1241                                              sk, 0x13, 0,
1242                                              keygen_add_std_prefs, sk );
1243                 else
1244                     rc = make_keysig_packet( &newsig, main_pk, NULL, sub_pk,
1245                                              sk, 0x18, 0,
1246                                              keygen_add_key_expire, sk );
1247                 if( rc ) {
1248                     log_error("make_keysig_packet failed: %s\n",
1249                                                     g10_errstr(rc));
1250                     free_secret_key( sk );
1251                     return 0;
1252                 }
1253                 /* replace the packet */
1254                 newpkt = m_alloc_clear( sizeof *newpkt );
1255                 newpkt->pkttype = PKT_SIGNATURE;
1256                 newpkt->pkt.signature = newsig;
1257                 free_packet( node->pkt );
1258                 m_free( node->pkt );
1259                 node->pkt = newpkt;
1260                 if( sn ) {
1261                     newpkt = m_alloc_clear( sizeof *newpkt );
1262                     newpkt->pkttype = PKT_SIGNATURE;
1263                     newpkt->pkt.signature = copy_signature( NULL, newsig );
1264                     free_packet( sn->pkt );
1265                     m_free( sn->pkt );
1266                     sn->pkt = newpkt;
1267                 }
1268             }
1269         }
1270     }
1271
1272     free_secret_key( sk );
1273     return 1;
1274 }
1275
1276
1277 /****************
1278  * Select one user id or remove all selection if index is 0.
1279  * Returns: True if the selection changed;
1280  */
1281 static int
1282 menu_select_uid( KBNODE keyblock, int index )
1283 {
1284     KBNODE node;
1285     int i;
1286
1287     /* first check that the index is valid */
1288     if( index ) {
1289         for( i=0, node = keyblock; node; node = node->next ) {
1290             if( node->pkt->pkttype == PKT_USER_ID ) {
1291                 if( ++i == index )
1292                     break;
1293             }
1294         }
1295         if( !node ) {
1296             tty_printf(_("No user id with index %d\n"), index );
1297             return 0;
1298         }
1299     }
1300     else { /* reset all */
1301         for( i=0, node = keyblock; node; node = node->next ) {
1302             if( node->pkt->pkttype == PKT_USER_ID )
1303                 node->flag &= ~NODFLG_SELUID;
1304         }
1305         return 1;
1306     }
1307     /* and toggle the new index */
1308     for( i=0, node = keyblock; node; node = node->next ) {
1309         if( node->pkt->pkttype == PKT_USER_ID ) {
1310             if( ++i == index )
1311                 if( (node->flag & NODFLG_SELUID) )
1312                     node->flag &= ~NODFLG_SELUID;
1313                 else
1314                     node->flag |= NODFLG_SELUID;
1315         }
1316     }
1317
1318     return 1;
1319 }
1320
1321 /****************
1322  * Select secondary keys
1323  * Returns: True if the selection changed;
1324  */
1325 static int
1326 menu_select_key( KBNODE keyblock, int index )
1327 {
1328     KBNODE node;
1329     int i;
1330
1331     /* first check that the index is valid */
1332     if( index ) {
1333         for( i=0, node = keyblock; node; node = node->next ) {
1334             if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1335                 || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1336                 if( ++i == index )
1337                     break;
1338             }
1339         }
1340         if( !node ) {
1341             tty_printf(_("No secondary key with index %d\n"), index );
1342             return 0;
1343         }
1344     }
1345     else { /* reset all */
1346         for( i=0, node = keyblock; node; node = node->next ) {
1347             if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1348                 || node->pkt->pkttype == PKT_SECRET_SUBKEY )
1349                 node->flag &= ~NODFLG_SELKEY;
1350         }
1351         return 1;
1352     }
1353     /* and set the new index */
1354     for( i=0, node = keyblock; node; node = node->next ) {
1355         if( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1356             || node->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1357             if( ++i == index )
1358                 if( (node->flag & NODFLG_SELKEY) )
1359                     node->flag &= ~NODFLG_SELKEY;
1360                 else
1361                     node->flag |= NODFLG_SELKEY;
1362         }
1363     }
1364
1365     return 1;
1366 }
1367
1368
1369 static int
1370 count_uids_with_flag( KBNODE keyblock, unsigned flag )
1371 {
1372     KBNODE node;
1373     int i=0;
1374
1375     for( node = keyblock; node; node = node->next )
1376         if( node->pkt->pkttype == PKT_USER_ID && (node->flag & flag) )
1377             i++;
1378     return i;
1379 }
1380
1381 static int
1382 count_keys_with_flag( KBNODE keyblock, unsigned flag )
1383 {
1384     KBNODE node;
1385     int i=0;
1386
1387     for( node = keyblock; node; node = node->next )
1388         if( ( node->pkt->pkttype == PKT_PUBLIC_SUBKEY
1389               || node->pkt->pkttype == PKT_SECRET_SUBKEY)
1390             && (node->flag & flag) )
1391             i++;
1392     return i;
1393 }
1394
1395 static int
1396 count_uids( KBNODE keyblock )
1397 {
1398     KBNODE node;
1399     int i=0;
1400
1401     for( node = keyblock; node; node = node->next )
1402         if( node->pkt->pkttype == PKT_USER_ID )
1403             i++;
1404     return i;
1405 }
1406
1407
1408 /****************
1409  * Returns true if there is at least one selected user id
1410  */
1411 static int
1412 count_selected_uids( KBNODE keyblock )
1413 {
1414     return count_uids_with_flag( keyblock, NODFLG_SELUID);
1415 }
1416
1417 static int
1418 count_selected_keys( KBNODE keyblock )
1419 {
1420     return count_keys_with_flag( keyblock, NODFLG_SELKEY);
1421 }
1422