tests,json: Fix and improve t-json
[gpgme.git] / tests / run-keylist.c
1 /* run-keylist.c  - Helper to show a key listing.
2    Copyright (C) 2008, 2009 g10 Code GmbH
3
4    This file is part of GPGME.
5
6    GPGME is free software; you can redistribute it and/or modify it
7    under the terms of the GNU Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (at your option) any later version.
10
11    GPGME is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, see <https://www.gnu.org/licenses/>.
18 */
19
20 /* We need to include config.h so that we know whether we are building
21    with large file system (LFS) support. */
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <time.h>
30
31 #include <gpgme.h>
32
33 #define PGM "run-keylist"
34
35 #include "run-support.h"
36
37
38 static int verbose;
39
40
41 static int
42 show_usage (int ex)
43 {
44   fputs ("usage: " PGM " [options] [USERID_or_FILE]\n\n"
45          "Options:\n"
46          "  --verbose        run in verbose mode\n"
47          "  --openpgp        use the OpenPGP protocol (default)\n"
48          "  --cms            use the CMS protocol\n"
49          "  --secret         list only secret keys\n"
50          "  --with-secret    list pubkeys with secret info filled\n"
51          "  --local          use GPGME_KEYLIST_MODE_LOCAL\n"
52          "  --extern         use GPGME_KEYLIST_MODE_EXTERN\n"
53          "  --sigs           use GPGME_KEYLIST_MODE_SIGS\n"
54          "  --tofu           use GPGME_KEYLIST_MODE_TOFU\n"
55          "  --sig-notations  use GPGME_KEYLIST_MODE_SIG_NOTATIONS\n"
56          "  --ephemeral      use GPGME_KEYLIST_MODE_EPHEMERAL\n"
57          "  --validate       use GPGME_KEYLIST_MODE_VALIDATE\n"
58          "  --import         import all keys\n"
59          "  --offline        use offline mode\n"
60          "  --from-file      list all keys in the given file\n"
61          "  --from-wkd       list key from a web key directory\n"
62          "  --require-gnupg  required at least the given GnuPG version\n"
63          "  --trust-model    use the specified trust-model\n"
64          , stderr);
65   exit (ex);
66 }
67
68
69 static const char *
70 isotimestr (unsigned long value)
71 {
72   time_t t;
73   static char buffer[25+5];
74   struct tm *tp;
75
76   if (!value)
77     return "none";
78   t = value;
79
80   tp = gmtime (&t);
81   snprintf (buffer, sizeof buffer, "%04d-%02d-%02d %02d:%02d:%02d",
82             1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
83             tp->tm_hour, tp->tm_min, tp->tm_sec);
84   return buffer;
85 }
86
87
88
89 int
90 main (int argc, char **argv)
91 {
92   int last_argc = -1;
93   gpgme_error_t err;
94   gpgme_ctx_t ctx;
95   gpgme_keylist_mode_t mode = 0;
96   gpgme_key_t key;
97   gpgme_subkey_t subkey;
98   gpgme_keylist_result_t result;
99   int import = 0;
100   gpgme_key_t keyarray[100];
101   int keyidx = 0;
102   gpgme_protocol_t protocol = GPGME_PROTOCOL_OpenPGP;
103   int only_secret = 0;
104   int offline = 0;
105   int from_file = 0;
106   int from_wkd = 0;
107   gpgme_data_t data = NULL;
108   char *trust_model = NULL;
109
110
111   if (argc)
112     { argc--; argv++; }
113
114   while (argc && last_argc != argc )
115     {
116       last_argc = argc;
117       if (!strcmp (*argv, "--"))
118         {
119           argc--; argv++;
120           break;
121         }
122       else if (!strcmp (*argv, "--help"))
123         show_usage (0);
124       else if (!strcmp (*argv, "--verbose"))
125         {
126           verbose = 1;
127           argc--; argv++;
128         }
129       else if (!strcmp (*argv, "--openpgp"))
130         {
131           protocol = GPGME_PROTOCOL_OpenPGP;
132           argc--; argv++;
133         }
134       else if (!strcmp (*argv, "--cms"))
135         {
136           protocol = GPGME_PROTOCOL_CMS;
137           argc--; argv++;
138         }
139       else if (!strcmp (*argv, "--secret"))
140         {
141           only_secret = 1;
142           argc--; argv++;
143         }
144       else if (!strcmp (*argv, "--local"))
145         {
146           mode |= GPGME_KEYLIST_MODE_LOCAL;
147           argc--; argv++;
148         }
149       else if (!strcmp (*argv, "--extern"))
150         {
151           mode |= GPGME_KEYLIST_MODE_EXTERN;
152           argc--; argv++;
153         }
154       else if (!strcmp (*argv, "--tofu"))
155         {
156           mode |= GPGME_KEYLIST_MODE_WITH_TOFU;
157           argc--; argv++;
158         }
159       else if (!strcmp (*argv, "--sigs"))
160         {
161           mode |= GPGME_KEYLIST_MODE_SIGS;
162           argc--; argv++;
163         }
164       else if (!strcmp (*argv, "--sig-notations"))
165         {
166           mode |= GPGME_KEYLIST_MODE_SIG_NOTATIONS;
167           argc--; argv++;
168         }
169       else if (!strcmp (*argv, "--ephemeral"))
170         {
171           mode |= GPGME_KEYLIST_MODE_EPHEMERAL;
172           argc--; argv++;
173         }
174       else if (!strcmp (*argv, "--validate"))
175         {
176           mode |= GPGME_KEYLIST_MODE_VALIDATE;
177           argc--; argv++;
178         }
179       else if (!strcmp (*argv, "--with-secret"))
180         {
181           mode |= GPGME_KEYLIST_MODE_WITH_SECRET;
182           argc--; argv++;
183         }
184       else if (!strcmp (*argv, "--import"))
185         {
186           import = 1;
187           argc--; argv++;
188         }
189       else if (!strcmp (*argv, "--offline"))
190         {
191           offline = 1;
192           argc--; argv++;
193         }
194       else if (!strcmp (*argv, "--from-file"))
195         {
196           from_file = 1;
197           argc--; argv++;
198         }
199       else if (!strcmp (*argv, "--require-gnupg"))
200         {
201           argc--; argv++;
202           if (!argc)
203             show_usage (1);
204           gpgme_set_global_flag ("require-gnupg", *argv);
205           argc--; argv++;
206         }
207       else if (!strcmp (*argv, "--from-wkd"))
208         {
209           argc--; argv++;
210           mode |= GPGME_KEYLIST_MODE_LOCATE;
211           from_wkd = 1;
212         }
213       else if (!strcmp (*argv, "--trust-model"))
214         {
215           argc--; argv++;
216           if (!argc)
217             show_usage (1);
218           trust_model = strdup (*argv);
219           argc--; argv++;
220         }
221       else if (!strncmp (*argv, "--", 2))
222         show_usage (1);
223     }
224
225   if (argc > 1)
226     show_usage (1);
227   else if (from_file && !argc)
228     show_usage (1);
229
230   init_gpgme (protocol);
231
232   err = gpgme_new (&ctx);
233   fail_if_err (err);
234   gpgme_set_protocol (ctx, protocol);
235
236   gpgme_set_keylist_mode (ctx, mode);
237
238   gpgme_set_offline (ctx, offline);
239
240   if (trust_model)
241     {
242       err = gpgme_set_ctx_flag (ctx, "trust-model", trust_model);
243       fail_if_err (err);
244     }
245
246   if (from_wkd)
247     {
248       err = gpgme_set_ctx_flag (ctx, "auto-key-locate",
249                                 "clear,nodefault,wkd");
250       fail_if_err (err);
251     }
252
253   if (from_file)
254     {
255       err = gpgme_data_new_from_file (&data, *argv, 1);
256       fail_if_err (err);
257
258       err = gpgme_op_keylist_from_data_start (ctx, data, 0);
259     }
260   else
261     err = gpgme_op_keylist_start (ctx, argc? argv[0]:NULL, only_secret);
262   fail_if_err (err);
263
264   while (!(err = gpgme_op_keylist_next (ctx, &key)))
265     {
266       gpgme_user_id_t uid;
267       gpgme_tofu_info_t ti;
268       gpgme_key_sig_t ks;
269       int nuids;
270       int nsub;
271       int nsigs;
272
273       printf ("keyid   : %s\n", key->subkeys?nonnull (key->subkeys->keyid):"?");
274       printf ("fpr     : %s\n", key->subkeys?nonnull (key->subkeys->fpr):"?");
275       if (key->subkeys && key->subkeys->keygrip)
276         printf ("grip    : %s\n", key->subkeys->keygrip);
277       if (key->subkeys && key->subkeys->curve)
278             printf ("curve   : %s\n", key->subkeys->curve);
279       printf ("caps    : %s%s%s%s\n",
280               key->can_encrypt? "e":"",
281               key->can_sign? "s":"",
282               key->can_certify? "c":"",
283               key->can_authenticate? "a":"");
284       printf ("flags   :%s%s%s%s%s%s%s%s\n",
285               key->secret? " secret":"",
286               key->revoked? " revoked":"",
287               key->expired? " expired":"",
288               key->disabled? " disabled":"",
289               key->invalid? " invalid":"",
290               key->is_qualified? " qualified":"",
291               key->subkeys && key->subkeys->is_de_vs? " de-vs":"",
292               key->subkeys && key->subkeys->is_cardkey? " cardkey":"");
293       printf ("upd     : %lu (%u)\n", key->last_update, key->origin);
294
295       subkey = key->subkeys;
296       if (subkey)
297         subkey = subkey->next;
298       for (nsub=1; subkey; subkey = subkey->next, nsub++)
299         {
300           printf ("fpr   %2d: %s\n", nsub, nonnull (subkey->fpr));
301           if (subkey->keygrip)
302             printf ("grip  %2d: %s\n", nsub, subkey->keygrip);
303           if (subkey->curve)
304             printf ("curve %2d: %s\n", nsub, subkey->curve);
305           printf ("caps  %2d: %s%s%s%s\n",
306                   nsub,
307                   subkey->can_encrypt? "e":"",
308                   subkey->can_sign? "s":"",
309                   subkey->can_certify? "c":"",
310                   subkey->can_authenticate? "a":"");
311           printf ("flags %2d:%s%s%s%s%s%s%s%s\n",
312                   nsub,
313                   subkey->secret? " secret":"",
314                   subkey->revoked? " revoked":"",
315                   subkey->expired? " expired":"",
316                   subkey->disabled? " disabled":"",
317                   subkey->invalid? " invalid":"",
318                   subkey->is_qualified? " qualified":"",
319                   subkey->is_de_vs? " de-vs":"",
320                   subkey->is_cardkey? " cardkey":"");
321         }
322       for (nuids=0, uid=key->uids; uid; uid = uid->next, nuids++)
323         {
324           printf ("userid %d: %s\n", nuids, nonnull(uid->uid));
325           printf ("    mbox: %s\n", nonnull(uid->address));
326           if (uid->email && uid->email != uid->address)
327             printf ("   email: %s\n", uid->email);
328           if (uid->name)
329             printf ("    name: %s\n", uid->name);
330           if (uid->comment)
331             printf ("   cmmnt: %s\n", uid->comment);
332           printf ("     upd: %lu (%u)\n", uid->last_update, uid->origin);
333           printf ("   valid: %s\n",
334                   uid->validity == GPGME_VALIDITY_UNKNOWN? "unknown":
335                   uid->validity == GPGME_VALIDITY_UNDEFINED? "undefined":
336                   uid->validity == GPGME_VALIDITY_NEVER? "never":
337                   uid->validity == GPGME_VALIDITY_MARGINAL? "marginal":
338                   uid->validity == GPGME_VALIDITY_FULL? "full":
339                   uid->validity == GPGME_VALIDITY_ULTIMATE? "ultimate": "[?]");
340           if ((ti = uid->tofu))
341             {
342               printf ("    tofu: %u (%s)\n", ti->validity,
343                       ti->validity == 0? "conflict" :
344                       ti->validity == 1? "no history" :
345                       ti->validity == 2? "little history" :
346                       ti->validity == 3? "enough history" :
347                       ti->validity == 4? "lot of history" : "?");
348               printf ("  policy: %u (%s)\n", ti->policy,
349                       ti->policy == GPGME_TOFU_POLICY_NONE? "none" :
350                       ti->policy == GPGME_TOFU_POLICY_AUTO? "auto" :
351                       ti->policy == GPGME_TOFU_POLICY_GOOD? "good" :
352                       ti->policy == GPGME_TOFU_POLICY_UNKNOWN? "unknown" :
353                       ti->policy == GPGME_TOFU_POLICY_BAD? "bad" :
354                       ti->policy == GPGME_TOFU_POLICY_ASK? "ask" : "?");
355               printf ("   nsigs: %hu\n", ti->signcount);
356               printf ("   first: %s\n", isotimestr (ti->signfirst));
357               printf ("    last: %s\n", isotimestr (ti->signlast));
358               printf ("   nencr: %hu\n", ti->encrcount);
359               printf ("   first: %s\n", isotimestr (ti->encrfirst));
360               printf ("    last: %s\n", isotimestr (ti->encrlast));
361             }
362           for (nsigs=0, ks=uid->signatures; ks; ks = ks->next, nsigs++)
363             {
364               printf ("signature %d: %s\n", nsigs, nonnull (ks->uid));
365               printf ("       keyid: %s\n", nonnull (ks->keyid));
366               printf ("     created: %s\n", isotimestr(ks->timestamp));
367               printf ("     expires: %s\n", isotimestr(ks->expires));
368               printf ("       class: %x\n", ks->sig_class);
369             }
370         }
371
372       putchar ('\n');
373
374       if (import)
375         {
376           if (keyidx < DIM (keyarray)-1)
377             keyarray[keyidx++] = key;
378           else
379             {
380               fprintf (stderr, PGM": too many keys in import mode"
381                        "- skipping this key\n");
382               gpgme_key_unref (key);
383             }
384         }
385       else
386         gpgme_key_unref (key);
387     }
388   if (gpgme_err_code (err) != GPG_ERR_EOF)
389     fail_if_err (err);
390   err = gpgme_op_keylist_end (ctx);
391   fail_if_err (err);
392   keyarray[keyidx] = NULL;
393   gpgme_data_release (data);
394
395   result = gpgme_op_keylist_result (ctx);
396   if (result->truncated)
397     {
398       fprintf (stderr, PGM ": key listing unexpectedly truncated\n");
399       exit (1);
400     }
401
402   if (import)
403     {
404       gpgme_import_result_t impres;
405
406       err = gpgme_op_import_keys (ctx, keyarray);
407       fail_if_err (err);
408       impres = gpgme_op_import_result (ctx);
409       if (!impres)
410         {
411           fprintf (stderr, PGM ": no import result returned\n");
412           exit (1);
413         }
414       print_import_result (impres);
415     }
416
417   for (keyidx=0; keyarray[keyidx]; keyidx++)
418     gpgme_key_unref (keyarray[keyidx]);
419
420   free (trust_model);
421
422   gpgme_release (ctx);
423   return 0;
424 }