tests: Mark lots of unused vars and fix const mismatches.
[gpgme.git] / tests / gpg / t-keylist.c
1 /* t-keylist.c  - regression test
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2003, 2004 g10 Code GmbH
4
5    This file is part of GPGME.
6
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 /* We need to include config.h so that we know whether we are building
23    with large file system (LFS) support. */
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #include <gpgme.h>
33
34 #include "t-support.h"
35
36
37 struct key_info_s
38 {
39   const char *fpr;
40   const char *sec_keyid;
41   struct
42   {
43     const char *name;
44     const char *comment;
45     const char *email;
46   } uid[3];
47   int n_subkeys;
48   void (*misc_check)(struct key_info_s *keyinfo, gpgme_key_t key);
49 };
50
51
52 static void check_whisky (struct key_info_s *keyinfo, gpgme_key_t key);
53
54
55 \f
56 struct key_info_s keys[] =
57   {
58     { "A0FF4590BB6122EDEF6E3C542D727CC768697734", "6AE6D7EE46A871F8",
59       { { "Alfa Test", "demo key", "alfa@example.net" },
60         { "Alpha Test", "demo key", "alpha@example.net" },
61         { "Alice", "demo key", NULL } }, 1 },
62     { "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2", "5381EA4EE29BA37F",
63       { { "Bob", "demo key", NULL },
64         { "Bravo Test", "demo key", "bravo@example.net" } }, 1 },
65     { "61EE841A2A27EB983B3B3C26413F4AF31AFDAB6C", "E71E72ACBC43DA60",
66       { { "Charlie Test", "demo key", "charlie@example.net" } }, 1 },
67     { "6560C59C43D031C54D7C588EEBA9F240EB9DC9E6", "06F22880B0C45424",
68       { { "Delta Test", "demo key", "delta@example.net" } }, 1 },
69     { "3531152DE293E26A07F504BC318C1FAEFAEF6D1B", "B5C79E1A7272144D",
70       { { "Echelon", "demo key", NULL },
71         { "Echo Test", "demo key", "echo@example.net" },
72         { "Eve", "demo key", NULL } }, 1 },
73     { "56D33268F7FE693FBB594762D4BF57F37372E243", "0A32EE79EE45198E",
74       { { "Foxtrot Test", "demo key", "foxtrot@example.net" } }, 1 },
75     { "C9C07DCC6621B9FB8D071B1D168410A48FC282E6", "247491CC9DCAD354",
76       { { "Golf Test", "demo key", "golf@example.net" } }, 1 },
77     { "9E91CBB11E4D4135583EF90513DB965534C6E3F1", "76E26537D622AD0A",
78       { { "Hotel Test", "demo key", "hotel@example.net" } }, 1 },
79     { "CD538D6CC9FB3D745ECDA5201FE8FC6F04259677", "C1C8EFDE61F76C73",
80       { { "India Test", "demo key", "india@example.net" } }, 1 },
81     { "F8F1EDC73995AB739AD54B380C820C71D2699313", "BD0B108735F8F136",
82       { { "Juliet Test", "demo key", "juliet@example.net" } }, 1 },
83     { "3FD11083779196C2ECDD9594AD1B0FAD43C2D0C7", "86CBB34A9AF64D02",
84       { { "Kilo Test", "demo key", "kilo@example.net" } }, 1 },
85     { "1DDD28CEF714F5B03B8C246937CAB51FB79103F8", "0363B449FE56350C",
86       { { "Lima Test", "demo key", "lima@example.net" } }, 1 },
87     { "2686AA191A278013992C72EBBE794852BE5CF886", "5F600A834F31EAE8",
88       { { "Mallory", "demo key", NULL },
89         { "Mike Test", "demo key", "mike@example.net" } }, 1 },
90     { "5AB9D6D7BAA1C95B3BAA3D9425B00FD430CEC684", "4C1D63308B70E472",
91       { { "November Test", "demo key", "november@example.net" } }, 1 },
92     { "43929E89F8F79381678CAE515F6356BA6D9732AC", "FF0785712681619F",
93       { { "Oscar Test", "demo key", "oscar@example.net" } }, 1 },
94     { "6FAA9C201E5E26DCBAEC39FD5D15E01D3FF13206", "2764E18263330D9C",
95       { { "Papa test", "demo key", "papa@example.net" } }, 1 },
96     { "A7969DA1C3297AA96D49843F1C67EC133C661C84", "6CDCFC44A029ACF4",
97       { { "Quebec Test", "demo key", "quebec@example.net" } }, 1 },
98     { "38FBE1E4BF6A5E1242C8F6A13BDBEDB1777FBED3", "9FAB805A11D102EA",
99       { { "Romeo Test", "demo key", "romeo@example.net" } }, 1 },
100     { "045B2334ADD69FC221076841A5E67F7FA3AE3EA1", "93B88B0F0F1B50B4",
101       { { "Sierra Test", "demo key", "sierra@example.net" } }, 1 },
102     { "ECAC774F4EEEB0620767044A58CB9A4C85A81F38", "97B60E01101C0402",
103       { { "Tango Test", "demo key", "tango@example.net" } }, 1 },
104     { "0DBCAD3F08843B9557C6C4D4A94C0F75653244D6", "93079B915522BDB9",
105       { { "Uniform Test", "demo key", "uniform@example.net" } }, 1 },
106     { "E8143C489C8D41124DC40D0B47AF4B6961F04784", "04071FB807287134",
107       { { "Victor Test", "demo key", "victor@example.org" } }, 1 },
108     { "E8D6C90B683B0982BD557A99DEF0F7B8EC67DBDE", "D7FBB421FD6E27F6",
109       { { "Whisky Test", "demo key", "whisky@example.net" } }, 3,
110           check_whisky },
111     { "04C1DF62EFA0EBB00519B06A8979A6C5567FB34A", "5CC6F87F41E408BE",
112       { { "XRay Test", "demo key", "xray@example.net" } }, 1 },
113     { "ED9B316F78644A58D042655A9EEF34CD4B11B25F", "5ADFD255F7B080AD",
114       { { "Yankee Test", "demo key", "yankee@example.net" } }, 1 },
115     { "23FD347A419429BACCD5E72D6BC4778054ACD246", "EF9DC276A172C881",
116       { { "Zulu Test", "demo key", "zulu@example.net" } }, 1 },
117     { "ADAB7FCC1F4DE2616ECFA402AF82244F9CD9FD55", "087DD7E0381701C4",
118       { { "Joe Random Hacker", "test key with passphrase \"abc\"",
119           "joe@example.com" } }, 1 },
120     { NULL }
121   };
122
123
124 int
125 main (int argc, char **argv)
126 {
127   gpgme_error_t err;
128   gpgme_ctx_t ctx;
129   gpgme_key_t key;
130   gpgme_keylist_result_t result;
131   int i = 0;
132   int n;
133   gpgme_subkey_t subkey;
134
135   (void)argc;
136   (void)argv;
137
138   init_gpgme (GPGME_PROTOCOL_OpenPGP);
139
140   err = gpgme_new (&ctx);
141   fail_if_err (err);
142
143   err = gpgme_op_keylist_start (ctx, NULL, 0);
144   fail_if_err (err);
145
146   while (!(err = gpgme_op_keylist_next (ctx, &key)))
147     {
148       if (!keys[i].fpr)
149         {
150           fprintf (stderr, "More keys returned than expected\n");
151           exit (1);
152         }
153
154       /* Global key flags.  */
155       if (key->revoked)
156         {
157           fprintf (stderr, "Key unexpectedly revoked\n");
158           exit (1);
159         }
160       if (key->expired)
161         {
162           fprintf (stderr, "Key unexpectedly expired\n");
163           exit (1);
164         }
165       if (key->disabled)
166         {
167           fprintf (stderr, "Key unexpectedly disabled\n");
168           exit (1);
169         }
170       if (key->invalid)
171         {
172           fprintf (stderr, "Key unexpectedly invalid\n");
173           exit (1);
174         }
175 #if 0
176       /* GnuPG 2.1+ have a different subkey for encryption.  */
177       if (!key->can_encrypt)
178         {
179           fprintf (stderr, "Key unexpectedly unusable for encryption\n");
180           exit (1);
181         }
182 #endif
183       if (!key->can_sign)
184         {
185           fprintf (stderr, "Key unexpectedly unusable for signing\n");
186           exit (1);
187         }
188       if (!key->can_certify)
189         {
190           fprintf (stderr, "Key unexpectedly unusable for certifications\n");
191           exit (1);
192         }
193       if (key->secret)
194         {
195           fprintf (stderr, "Key unexpectedly secret\n");
196           exit (1);
197         }
198       if (key->protocol != GPGME_PROTOCOL_OpenPGP)
199         {
200           fprintf (stderr, "Key has unexpected protocol: %s\n",
201                    gpgme_get_protocol_name (key->protocol));
202           exit (1);
203         }
204       if (key->issuer_serial)
205         {
206           fprintf (stderr, "Key unexpectedly carries issuer serial: %s\n",
207                    key->issuer_serial);
208           exit (1);
209         }
210       if (key->issuer_name)
211         {
212           fprintf (stderr, "Key unexpectedly carries issuer name: %s\n",
213                    key->issuer_name);
214           exit (1);
215         }
216       if (key->chain_id)
217         {
218           fprintf (stderr, "Key unexpectedly carries chain ID: %s\n",
219                    key->chain_id);
220           exit (1);
221         }
222       if (key->owner_trust != GPGME_VALIDITY_UNKNOWN)
223         {
224           fprintf (stderr, "Key has unexpected owner trust: %i\n",
225                    key->owner_trust);
226           exit (1);
227         }
228
229       for (n=0, subkey = key->subkeys; subkey; subkey = subkey->next)
230         n++;
231       if (!n || n-1 != keys[i].n_subkeys)
232         {
233           fprintf (stderr, "Key `%s' has unexpected number of subkeys\n",
234                    keys[i].uid[0].name);
235           exit (1);
236         }
237
238       /* Primary key.  */
239       if (key->subkeys->revoked)
240         {
241           fprintf (stderr, "Primary key unexpectedly revoked\n");
242           exit (1);
243         }
244       if (key->subkeys->expired)
245         {
246           fprintf (stderr, "Primary key unexpectedly expired\n");
247           exit (1);
248         }
249       if (key->subkeys->disabled)
250         {
251           fprintf (stderr, "Primary key unexpectedly disabled\n");
252           exit (1);
253         }
254       if (key->subkeys->invalid)
255         {
256           fprintf (stderr, "Primary key unexpectedly invalid\n");
257           exit (1);
258         }
259       if (key->subkeys->can_encrypt)
260         {
261           fprintf (stderr, "Primary key unexpectedly usable for encryption\n");
262           exit (1);
263         }
264       if (!key->subkeys->can_sign)
265         {
266           fprintf (stderr, "Primary key unexpectedly unusable for signing\n");
267           exit (1);
268         }
269       if (!key->subkeys->can_certify)
270         {
271           fprintf (stderr, "Primary key unexpectedly unusable for certifications\n");
272           exit (1);
273         }
274       if (key->subkeys->secret)
275         {
276           fprintf (stderr, "Primary key unexpectedly secret\n");
277           exit (1);
278         }
279       if (key->subkeys->is_cardkey)
280         {
281           fprintf (stderr, "Public key marked as card key\n");
282           exit (1);
283         }
284       if (key->subkeys->card_number)
285         {
286           fprintf (stderr, "Public key with card number set\n");
287           exit (1);
288         }
289       if (key->subkeys->pubkey_algo != GPGME_PK_DSA)
290         {
291           fprintf (stderr, "Primary key has unexpected public key algo: %s\n",
292                    gpgme_pubkey_algo_name (key->subkeys->pubkey_algo));
293           exit (1);
294         }
295       if (key->subkeys->length != 1024)
296         {
297           fprintf (stderr, "Primary key has unexpected length: %i\n",
298                    key->subkeys->length);
299           exit (1);
300         }
301       if (strcmp (key->subkeys->keyid, &keys[i].fpr[40 - 16]))
302         {
303           fprintf (stderr, "Primary key `%s' has unexpected key ID: %s\n",
304                    keys[i].uid[0].name, key->subkeys->keyid);
305           exit (1);
306         }
307       if (strcmp (key->subkeys->fpr, keys[i].fpr))
308         {
309           fprintf (stderr, "Primary key has unexpected fingerprint: %s\n",
310                    key->subkeys->fpr);
311           exit (1);
312         }
313       if (key->subkeys->expires)
314         {
315           fprintf (stderr, "Primary key `%s' unexpectedly expires: %lu\n",
316                    keys[i].uid[0].name, key->subkeys->expires);
317           exit (1);
318         }
319
320       /* Secondary key.  */
321       if (key->subkeys->next->revoked)
322         {
323           fprintf (stderr, "Secondary key unexpectedly revoked\n");
324           exit (1);
325         }
326       if (key->subkeys->next->expired)
327         {
328           fprintf (stderr, "Secondary key unexpectedly expired\n");
329           exit (1);
330         }
331       if (key->subkeys->next->disabled)
332         {
333           fprintf (stderr, "Secondary key unexpectedly disabled\n");
334           exit (1);
335         }
336       if (key->subkeys->next->invalid)
337         {
338           fprintf (stderr, "Secondary key unexpectedly invalid\n");
339           exit (1);
340         }
341       if (!key->subkeys->next->can_encrypt)
342         {
343           fprintf (stderr, "Secondary key unexpectedly unusable for encryption\n");
344           exit (1);
345         }
346       if (key->subkeys->next->can_sign)
347         {
348           fprintf (stderr, "Secondary key unexpectedly usable for signing\n");
349           exit (1);
350         }
351       if (key->subkeys->next->can_certify)
352         {
353           fprintf (stderr, "Secondary key unexpectedly usable for certifications\n");
354           exit (1);
355         }
356       if (key->subkeys->next->secret)
357         {
358           fprintf (stderr, "Secondary key unexpectedly secret\n");
359           exit (1);
360         }
361       if (key->subkeys->next->is_cardkey)
362         {
363           fprintf (stderr, "Secondary public key marked as card key\n");
364           exit (1);
365         }
366       if (key->subkeys->next->card_number)
367         {
368           fprintf (stderr, "Secondary public key with card number set\n");
369           exit (1);
370         }
371       if (key->subkeys->next->pubkey_algo != GPGME_PK_ELG_E)
372         {
373           fprintf (stderr, "Secondary key has unexpected public key algo: %s\n",
374                    gpgme_pubkey_algo_name (key->subkeys->next->pubkey_algo));
375           exit (1);
376         }
377       if (key->subkeys->next->length != 1024)
378         {
379           fprintf (stderr, "Secondary key has unexpected length: %i\n",
380                    key->subkeys->next->length);
381           exit (1);
382         }
383       if (strcmp (key->subkeys->next->keyid, keys[i].sec_keyid))
384         {
385           fprintf (stderr, "Secondary key `%s' has unexpected key ID: %s/%s\n",
386                    keys[i].uid[0].name,
387                    key->subkeys->next->keyid, keys[i].sec_keyid );
388           exit (1);
389         }
390       if (!key->subkeys->next->fpr)
391         {
392           fprintf (stderr, "Secondary key has unexpectedly no fingerprint\n");
393           exit (1);
394         }
395       if (key->subkeys->next->expires)
396         {
397           fprintf (stderr, "Secondary key unexpectedly expires: %lu\n",
398                    key->subkeys->next->expires);
399           exit (1);
400         }
401
402       /* FIXME: The below test will crash if we want to check for a
403          name, comment or email that doesn't exist in the key's user
404          IDs.  */
405       if (!((!keys[i].uid[0].name && !key->uids)
406             || (keys[i].uid[0].name && !keys[i].uid[1].name
407                 && key->uids && !key->uids->next)
408             || (keys[i].uid[0].name && keys[i].uid[1].name
409                 && !keys[i].uid[2].name
410                 && key->uids && key->uids->next && !key->uids->next->next)
411             || (keys[i].uid[0].name && keys[i].uid[1].name
412                 && keys[i].uid[2].name
413                 && key->uids && key->uids->next && key->uids->next->next
414                 && !key->uids->next->next->next)))
415           {
416             fprintf (stderr, "Key has unexpected number of user IDs\n");
417             exit (1);
418           }
419       if (key->uids && key->uids->revoked)
420         {
421           fprintf (stderr, "First user ID unexpectedly revoked\n");
422           exit (1);
423         }
424       if (key->uids && key->uids->invalid)
425         {
426           fprintf (stderr, "First user ID unexpectedly invalid\n");
427           exit (1);
428         }
429       if (key->uids && key->uids->validity != GPGME_VALIDITY_UNKNOWN)
430         {
431           fprintf (stderr, "First user ID has unexpectedly validity: %i\n",
432                    key->uids->validity);
433           exit (1);
434         }
435       if (key->uids && key->uids->signatures)
436         {
437           fprintf (stderr, "First user ID unexpectedly signed\n");
438           exit (1);
439         }
440       if (keys[i].uid[0].name
441           && strcmp (keys[i].uid[0].name, key->uids->name))
442         {
443           fprintf (stderr, "Unexpected name in first user ID: %s\n",
444                    key->uids->name);
445           exit (1);
446         }
447       if (keys[i].uid[0].comment
448           && strcmp (keys[i].uid[0].comment, key->uids->comment))
449         {
450           fprintf (stderr, "Unexpected comment in first user ID: %s\n",
451                    key->uids->comment);
452           exit (1);
453         }
454       if (keys[i].uid[0].email
455           && strcmp (keys[i].uid[0].email, key->uids->email))
456         {
457           fprintf (stderr, "Unexpected email in first user ID: %s\n",
458                    key->uids->email);
459           exit (1);
460         }
461       if (key->uids && key->uids->next && key->uids->next->revoked)
462         {
463           fprintf (stderr, "Second user ID unexpectedly revoked\n");
464           exit (1);
465         }
466       if (key->uids && key->uids->next && key->uids->next->invalid)
467         {
468           fprintf (stderr, "Second user ID unexpectedly invalid\n");
469           exit (1);
470         }
471       if (key->uids && key->uids->next
472           && key->uids->next->validity != GPGME_VALIDITY_UNKNOWN)
473         {
474           fprintf (stderr, "Second user ID has unexpectedly validity: %i\n",
475                    key->uids->next->validity);
476           exit (1);
477         }
478       if (key->uids && key->uids->next && key->uids->next->signatures)
479         {
480           fprintf (stderr, "Second user ID unexpectedly signed\n");
481           exit (1);
482         }
483       if (keys[i].uid[1].name
484           && strcmp (keys[i].uid[1].name, key->uids->next->name))
485         {
486           fprintf (stderr, "Unexpected name in second user ID: %s\n",
487                    key->uids->next->name);
488           exit (1);
489         }
490       if (keys[i].uid[1].comment
491           && strcmp (keys[i].uid[1].comment, key->uids->next->comment))
492         {
493           fprintf (stderr, "Unexpected comment in second user ID: %s\n",
494                    key->uids->next->comment);
495           exit (1);
496         }
497       if (keys[i].uid[1].email
498           && strcmp (keys[i].uid[1].email, key->uids->next->email))
499         {
500           fprintf (stderr, "Unexpected email in second user ID: %s\n",
501                    key->uids->next->email);
502           exit (1);
503         }
504       if (key->uids && key->uids->next && key->uids->next->next
505           && key->uids->next->next->revoked)
506         {
507           fprintf (stderr, "Third user ID unexpectedly revoked\n");
508           exit (1);
509         }
510       if (key->uids && key->uids->next && key->uids->next->next
511           && key->uids->next->next->invalid)
512         {
513           fprintf (stderr, "Third user ID unexpectedly invalid\n");
514           exit (1);
515         }
516       if (key->uids && key->uids->next && key->uids->next->next
517           && key->uids->next->next->validity != GPGME_VALIDITY_UNKNOWN)
518         {
519           fprintf (stderr, "Third user ID has unexpectedly validity: %i\n",
520                    key->uids->next->next->validity);
521           exit (1);
522         }
523       if (key->uids && key->uids->next && key->uids->next->next
524           && key->uids->next->next->signatures)
525         {
526           fprintf (stderr, "Third user ID unexpectedly signed\n");
527           exit (1);
528         }
529       if (keys[i].uid[2].name
530           && strcmp (keys[i].uid[2].name, key->uids->next->next->name))
531         {
532           fprintf (stderr, "Unexpected name in third user ID: %s\n",
533                    key->uids->next->next->name);
534           exit (1);
535         }
536       if (keys[i].uid[2].comment
537           && strcmp (keys[i].uid[2].comment, key->uids->next->next->comment))
538         {
539           fprintf (stderr, "Unexpected comment in third user ID: %s\n",
540                    key->uids->next->next->comment);
541           exit (1);
542         }
543       if (keys[i].uid[2].email
544           && strcmp (keys[i].uid[2].email, key->uids->next->next->email))
545         {
546           fprintf (stderr, "Unexpected email in third user ID: %s\n",
547                    key->uids->next->next->email);
548           exit (1);
549         }
550
551       if (keys[i].misc_check)
552         keys[i].misc_check (keys+i, key);
553
554       gpgme_key_unref (key);
555       i++;
556     }
557   if (gpgme_err_code (err) != GPG_ERR_EOF)
558     fail_if_err (err);
559   err = gpgme_op_keylist_end (ctx);
560   fail_if_err (err);
561
562   result = gpgme_op_keylist_result (ctx);
563   if (result->truncated)
564     {
565       fprintf (stderr, "Key listing unexpectedly truncated\n");
566       exit (1);
567     }
568
569   if (keys[i].fpr)
570     {
571       fprintf (stderr, "Less keys returned than expected\n");
572       exit (1);
573     }
574
575   gpgme_release (ctx);
576   return 0;
577 }
578
579
580
581 /* Check expration of keys.  This test assumes three subkeys of which
582    2 are expired; it is used with the "Whisky" test key.  It has
583    already been checked that these 3 subkeys are available. */
584 static void
585 check_whisky (struct key_info_s *keyinfo, gpgme_key_t key)
586 {
587   const char *name = keyinfo->uid[0].name;
588   gpgme_subkey_t sub1, sub2;
589
590   sub1 = key->subkeys->next->next;
591   sub2 = sub1->next;
592
593   if (!sub1->expired || !sub2->expired)
594     {
595       fprintf (stderr, "Subkey of `%s' not flagged as expired\n", name);
596       exit (1);
597     }
598   if (sub1->expires != 1129636886 || sub2->expires != 1129636939)
599     {
600       fprintf (stderr, "Subkey of `%s' has wrong expiration date\n", name);
601       exit (1);
602     }
603
604 }
605