release 0.2.14
[gnupg.git] / g10 / keylist.c
1 /* keylist.c
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
28 #include "options.h"
29 #include "packet.h"
30 #include "errors.h"
31 #include "keydb.h"
32 #include "memory.h"
33 #include "util.h"
34 #include "trustdb.h"
35 #include "main.h"
36 #include "i18n.h"
37
38 static void list_all(void);
39 static void list_one(const char *name);
40 static void fingerprint( PKT_public_cert *pkc );
41
42
43 /****************
44  * List the keys
45  * If NNAMES is 0; all available keys are listed
46  */
47 void
48 std_key_list( int nnames, char **names )
49 {
50     if( !nnames )
51         list_all();
52     else { /* List by user id */
53         for( ; nnames ; nnames--, names++ )
54             list_one( *names );
55     }
56 }
57
58
59 static void
60 list_all()
61 {
62     int i, seq=0;
63     const char *s;
64     IOBUF a;
65
66     while( (s=get_keyring(seq++)) ) {
67         if( !(a = iobuf_open(s)) ) {
68             log_error(_("can't open %s: %s\n"), s, strerror(errno));
69             continue;
70         }
71         if( seq > 1 )
72             putchar('\n');
73         printf("%s\n", s );
74         for(i=strlen(s); i; i-- )
75             putchar('-');
76         putchar('\n');
77
78         proc_packets( a );
79         iobuf_close(a);
80     }
81 }
82
83
84 static void
85 list_one( const char *name )
86 {
87     int rc = 0;
88     KBNODE keyblock = NULL;
89     KBNODE kbctx;
90     KBNODE node;
91     KBPOS kbpos;
92     PKT_public_cert *pkc;
93     u32 keyid[2];
94     int any=0;
95
96     /* search the userid */
97     rc = find_keyblock_byname( &kbpos, name );
98     if( rc ) {
99         log_error("%s: user not found\n", name );
100         goto leave;
101     }
102
103     /* read the keyblock */
104     rc = read_keyblock( &kbpos, &keyblock );
105     if( rc ) {
106         log_error("%s: keyblock read problem: %s\n", name, g10_errstr(rc) );
107         goto leave;
108     }
109
110
111     /* get the keyid from the keyblock */
112     node = find_kbnode( keyblock, PKT_PUBLIC_CERT );
113     if( !node ) {
114         log_error("Oops; public key lost!\n");
115         goto leave;
116     }
117
118     pkc = node->pkt->pkt.public_cert;
119     keyid_from_pkc( pkc, keyid );
120     if( opt.with_colons )
121         printf("pub::%u:%d:%08lX%08lX:%s:%u:::",
122                 /* fixme: add trust value here */
123                 nbits_from_pkc( pkc ),
124                 pkc->pubkey_algo,
125                 (ulong)keyid[0],(ulong)keyid[1],
126                 datestr_from_pkc( pkc ),
127                 (unsigned)pkc->valid_days
128                 /* fixme: add LID and ownertrust here */
129                                         );
130     else
131         printf("pub  %4u%c/%08lX %s ", nbits_from_pkc( pkc ),
132                                    pubkey_letter( pkc->pubkey_algo ),
133                                    (ulong)keyid[1],
134                                    datestr_from_pkc( pkc ) );
135
136     for( kbctx=NULL; (node=walk_kbnode( keyblock, &kbctx, 0)) ; ) {
137         if( node->pkt->pkttype == PKT_USER_ID ) {
138             if( any ) {
139                 if( opt.with_colons )
140                     printf("uid:::::::::");
141                 else
142                     printf("uid%*s", 28, "");
143             }
144             print_string( stdout,  node->pkt->pkt.user_id->name,
145                           node->pkt->pkt.user_id->len, opt.with_colons );
146             if( opt.with_colons )
147                 putchar(':');
148             putchar('\n');
149             if( !any ) {
150                 if( opt.fingerprint )
151                     fingerprint( pkc );
152                 any = 1;
153             }
154         }
155         else if( node->pkt->pkttype == PKT_PUBKEY_SUBCERT ) {
156             u32 keyid2[2];
157             PKT_public_cert *pkc2 = node->pkt->pkt.public_cert;
158
159             if( !any ) {
160                 putchar('\n');
161                 if( opt.fingerprint )
162                     fingerprint( pkc ); /* of the main key */
163                 any = 1;
164             }
165
166             keyid_from_pkc( pkc2, keyid2 );
167             if( opt.with_colons )
168                 printf("sub::%u:%d:%08lX%08lX:%s:%u:::\n",
169                         /* fixme: add trust value here */
170                         nbits_from_pkc( pkc2 ),
171                         pkc2->pubkey_algo,
172                         (ulong)keyid2[0],(ulong)keyid2[1],
173                         datestr_from_pkc( pkc2 ),
174                         (unsigned)pkc2->valid_days
175                         /* fixme: add LID and ownertrust here */
176                                                 );
177             else
178                 printf("sub  %4u%c/%08lX %s\n", nbits_from_pkc( pkc2 ),
179                                            pubkey_letter( pkc2->pubkey_algo ),
180                                            (ulong)keyid2[1],
181                                            datestr_from_pkc( pkc2 ) );
182         }
183         else if( opt.list_sigs && node->pkt->pkttype == PKT_SIGNATURE ) {
184             PKT_signature *sig = node->pkt->pkt.signature;
185             int sigrc;
186
187             if( !any ) { /* no user id, (maybe a revocation follows)*/
188                 if( sig->sig_class == 0x20 )
189                     puts("[revoked]");
190                 else
191                     putchar('\n');
192                 if( opt.fingerprint )
193                     fingerprint( pkc );
194                 any=1;
195             }
196
197             if( sig->sig_class == 0x20 || sig->sig_class == 0x30 )
198                 fputs("rev", stdout);
199             else if( (sig->sig_class&~3) == 0x10 )
200                 fputs("sig", stdout);
201             else if( sig->sig_class == 0x18 )
202                 fputs("sig", stdout);
203             else {
204                 if( opt.with_colons )
205                     printf("sig::::::::::%02x:\n",sig->sig_class );
206                 else
207                     printf("sig                             "
208                        "[unexpected signature class 0x%02x]\n",sig->sig_class );
209                 continue;
210             }
211             if( opt.check_sigs ) {
212                 fflush(stdout);
213                 rc = check_key_signature( keyblock, node, NULL );
214                 switch( rc ) {
215                   case 0:                  sigrc = '!'; break;
216                   case G10ERR_BAD_SIGN:    sigrc = '-'; break;
217                   case G10ERR_NO_PUBKEY:   sigrc = '?'; break;
218                   default:                 sigrc = '%'; break;
219                 }
220             }
221             else {
222                 rc = 0;
223                 sigrc = ' ';
224             }
225             if( opt.with_colons ) {
226                 putchar(':');
227                 if( sigrc != ' ' )
228                     putchar(sigrc);
229                 printf(":::%08lX%08lX:%s::::", (ulong)sig->keyid[0],
230                            (ulong)sig->keyid[1], datestr_from_sig(sig));
231             }
232             else
233                 printf("%c       %08lX %s  ",
234                     sigrc, (ulong)sig->keyid[1], datestr_from_sig(sig));
235             if( sigrc == '%' )
236                 printf("[%s] ", g10_errstr(rc) );
237             else if( sigrc == '?' )
238                 ;
239             else {
240                 size_t n;
241                 char *p = get_user_id( sig->keyid, &n );
242                 print_string( stdout, p, n, opt.with_colons );
243                 m_free(p);
244             }
245             if( opt.with_colons )
246                 printf(":%02x:", sig->sig_class );
247             putchar('\n');
248         }
249     }
250     if( !any ) {/* oops, no user id */
251         if( opt.with_colons )
252             putchar(':');
253         putchar('\n');
254     }
255
256
257   leave:
258     release_kbnode( keyblock );
259 }
260
261 static void
262 fingerprint( PKT_public_cert *pkc )
263 {
264     byte *array, *p;
265     size_t i, n;
266
267     p = array = fingerprint_from_pkc( pkc, &n );
268     if( opt.with_colons ) {
269         printf("fpr:::::::::");
270         for(i=0; i < n ; i++, p++ )
271             printf("%02X", *p );
272         putchar(':');
273     }
274     else {
275         printf("     Key fingerprint =");
276         if( n == 20 ) {
277             for(i=0; i < n ; i++, i++, p += 2 ) {
278                 if( i == 10 )
279                     putchar(' ');
280                 printf(" %02X%02X", *p, p[1] );
281             }
282         }
283         else {
284             for(i=0; i < n ; i++, p++ ) {
285                 if( i && !(i%8) )
286                     putchar(' ');
287                 printf(" %02X", *p );
288             }
289         }
290     }
291     putchar('\n');
292     m_free(array);
293 }
294