mutt_FormatString -> m_strformat (will soon end up into the str lib \o/)
[apps/madmutt.git] / lib-crypt / crypt-gpgme.c
1 /*
2  * Copyright notice from original mutt:
3  * crypt-gpgme.c - GPGME based crypto operations
4  * Copyright (C) 1996,1997 Michael R. Elkins <me@cs.hmc.edu>
5  * Copyright (C) 1998,1999,2000 Thomas Roessler <roessler@guug.de>
6  * Copyright (C) 2001  Thomas Roessler <roessler@guug.de>
7  *                     Oliver Ehli <elmy@acm.org>
8  * Copyright (C) 2002, 2003, 2004 g10 Code GmbH
9  *
10  * This file is part of mutt-ng, see http://www.muttng.org/.
11  * It's licensed under the GNU General Public License,
12  * please see the file GPL in the top level source directory.
13  */
14
15 #include <lib-lib/lib-lib.h>
16
17 #ifdef CRYPT_BACKEND_GPGME
18
19 #ifdef HAVE_LOCALE_H
20 #  include <locale.h>
21 #endif
22 #ifdef HAVE_LANGINFO_D_T_FMT
23 #  include <langinfo.h>
24 #endif
25 #ifdef HAVE_SYS_RESOURCE_H
26 #  include <sys/resource.h>
27 #endif
28
29 #include <gpgme.h>
30
31 #include <lib-mime/mime.h>
32
33 #include <lib-ui/curses.h>
34 #include <lib-ui/enter.h>
35 #include <lib-ui/menu.h>
36
37 #include "lib.h"
38 #include "alias.h"
39 #include <lib-crypt/crypt.h>
40 #include "handler.h"
41 #include "copy.h"
42 #include "pager.h"
43 #include "recvattach.h"
44 #include "sort.h"
45 #include "crypt-gpgme.h"
46
47 /*
48  * Helper macros.
49  */
50 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
51 #define hexdigitp(a) (digitp (a)                     \
52                       || (*(a) >= 'A' && *(a) <= 'F')  \
53                       || (*(a) >= 'a' && *(a) <= 'f'))
54 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
55                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
56 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
57
58 /* Values used for comparing addresses. */
59 #define CRYPT_KV_VALID    1
60 #define CRYPT_KV_ADDR     2
61 #define CRYPT_KV_STRING   4
62 #define CRYPT_KV_STRONGID 8
63 #define CRYPT_KV_MATCH (CRYPT_KV_ADDR|CRYPT_KV_STRING)
64
65 /*
66  * Type definitions.
67  */
68
69 struct crypt_cache {
70   char *what;
71   char *dflt;
72   struct crypt_cache *next;
73 };
74
75 struct dn_array_s {
76   char *key;
77   char *value;
78 };
79
80 /* We work based on user IDs, getting from a user ID to the key is
81    check and does not need any memory (gpgme uses reference counting). */
82 typedef struct crypt_keyinfo {
83   struct crypt_keyinfo *next;
84   gpgme_key_t kobj;
85   int idx;                      /* and the user ID at this index */
86   const char *uid;              /* and for convenience point to this user ID */
87   unsigned int flags;           /* global and per uid flags (for convenience) */
88 } crypt_key_t;
89
90 typedef struct crypt_entry {
91   ssize_t num;
92   crypt_key_t *key;
93 } crypt_entry_t;
94
95
96 static struct crypt_cache *id_defaults = NULL;
97 static gpgme_key_t signature_key = NULL;
98
99 /*
100  * General helper functions.
101  */
102
103 /* return true when S points to a didgit or letter. */
104 static int digit_or_letter (const unsigned char *s)
105 {
106   return ((*s >= '0' && *s <= '9')
107           || (*s >= 'A' && *s <= 'Z')
108           || (*s >= 'a' && *s <= 'z'));
109 }
110
111
112 /* Print the utf-8 encoded string BUF of length LEN bytes to stream
113    FP. Convert the character set. */
114 static void print_utf8 (FILE * fp, const char *buf, ssize_t len)
115 {
116   char *tstr;
117
118   tstr = p_dupstr(buf, len);
119   mutt_convert_string (&tstr, "utf-8", Charset, M_ICONV_HOOK_FROM);
120   fputs (tstr, fp);
121   p_delete(&tstr);
122 }
123
124
125 /*
126  * Key management.
127  */
128
129 /* Return the keyID for the key K.  Note that this string is valid as
130    long as K is valid */
131 static const char *crypt_keyid (crypt_key_t * k)
132 {
133   const char *s = "????????";
134
135   if (k->kobj && k->kobj->subkeys) {
136     s = k->kobj->subkeys->keyid;
137     if ((!option (OPTPGPLONGIDS)) && (m_strlen(s) == 16))
138       /* Return only the short keyID.  */
139       s += 8;
140   }
141
142   return s;
143 }
144
145 /* Return the hexstring fingerprint from the key K. */
146 static const char *crypt_fpr (crypt_key_t * k)
147 {
148   const char *s = "";
149
150   if (k->kobj && k->kobj->subkeys)
151     s = k->kobj->subkeys->fpr;
152
153   return s;
154 }
155
156 /* Parse FLAGS and return a statically allocated(!) string with them. */
157 static char *crypt_key_abilities (int flags)
158 {
159   static char buff[3];
160
161   if (!(flags & KEYFLAG_CANENCRYPT))
162     buff[0] = '-';
163   else if (flags & KEYFLAG_PREFER_SIGNING)
164     buff[0] = '.';
165   else
166     buff[0] = 'e';
167
168   if (!(flags & KEYFLAG_CANSIGN))
169     buff[1] = '-';
170   else if (flags & KEYFLAG_PREFER_ENCRYPTION)
171     buff[1] = '.';
172   else
173     buff[1] = 's';
174
175   buff[2] = '\0';
176
177   return buff;
178 }
179
180 /* Parse FLAGS and return a character describing the most important flag. */
181 static char crypt_flags (int flags)
182 {
183   if (flags & KEYFLAG_REVOKED)
184     return 'R';
185   else if (flags & KEYFLAG_EXPIRED)
186     return 'X';
187   else if (flags & KEYFLAG_DISABLED)
188     return 'd';
189   else if (flags & KEYFLAG_CRITICAL)
190     return 'c';
191   else
192     return ' ';
193 }
194
195 /* Return a copy of KEY. */
196 static crypt_key_t *crypt_copy_key (crypt_key_t *key)
197 {
198   crypt_key_t *k;
199
200   k = p_new(crypt_key_t, 1);
201   k->kobj = key->kobj;
202   gpgme_key_ref (key->kobj);
203   k->idx = key->idx;
204   k->uid = key->uid;
205   k->flags = key->flags;
206
207   return k;
208 }
209
210 /* Release all the keys at the address of KEYLIST and set the address
211    to NULL. */
212 static void crypt_free_key (crypt_key_t ** keylist)
213 {
214   while (*keylist) {
215     crypt_key_t *k = (*keylist)->next;
216
217     p_delete(&k);
218     *keylist = k;
219   }
220 }
221
222 /* Return trute when key K is valid. */
223 static int crypt_key_is_valid (crypt_key_t * k)
224 {
225   if (k->flags & KEYFLAG_CANTUSE)
226     return 0;
227   return 1;
228 }
229
230 /* Return true whe validity of KEY is sufficient. */
231 static int crypt_id_is_strong (crypt_key_t * key)
232 {
233   gpgme_validity_t val = GPGME_VALIDITY_UNKNOWN;
234   gpgme_user_id_t uid = NULL;
235   int is_strong = 0;
236   int i = 0;
237
238   if ((key->flags & KEYFLAG_ISX509))
239     return 1;
240
241   for (i = 0, uid = key->kobj->uids; (i < key->idx) && uid;
242        i++, uid = uid->next);
243   if (uid)
244     val = uid->validity;
245
246   switch (val) {
247   case GPGME_VALIDITY_UNKNOWN:
248   case GPGME_VALIDITY_UNDEFINED:
249   case GPGME_VALIDITY_NEVER:
250   case GPGME_VALIDITY_MARGINAL:
251     is_strong = 0;
252     break;
253
254   case GPGME_VALIDITY_FULL:
255   case GPGME_VALIDITY_ULTIMATE:
256     is_strong = 1;
257     break;
258   }
259
260   return is_strong;
261 }
262
263 /* Return true when the KEY is valid, i.e. not marked as unusable. */
264 static int crypt_id_is_valid (crypt_key_t * key)
265 {
266   return !(key->flags & KEYFLAG_CANTUSE);
267 }
268
269 /* Return a bit vector describing how well the addresses ADDR and
270    U_ADDR match and whether KEY is valid. */
271 static int crypt_id_matches_addr (address_t * addr, address_t * u_addr,
272                                   crypt_key_t * key)
273 {
274   int rv = 0;
275
276   if (crypt_id_is_valid (key))
277     rv |= CRYPT_KV_VALID;
278
279   if (crypt_id_is_strong (key))
280     rv |= CRYPT_KV_STRONGID;
281
282   if (addr->mailbox && u_addr->mailbox
283       && m_strcasecmp(addr->mailbox, u_addr->mailbox) == 0)
284     rv |= CRYPT_KV_ADDR;
285
286   if (addr->personal && u_addr->personal
287       && m_strcasecmp(addr->personal, u_addr->personal) == 0)
288     rv |= CRYPT_KV_STRING;
289
290   return rv;
291 }
292
293
294 /*
295  * GPGME convenient functions.
296  */
297
298 /* Create a new gpgme context and return it.  With FOR_SMIME set to
299    true, the protocol of the context is set to CMS. */
300 static gpgme_ctx_t create_gpgme_context (int for_smime)
301 {
302   gpgme_error_t err;
303   gpgme_ctx_t ctx;
304
305   err = gpgme_new (&ctx);
306   if (err) {
307     mutt_error (_("error creating gpgme context: %s\n"), gpgme_strerror (err));
308     sleep (2);
309     mutt_exit (1);
310   }
311
312   if (for_smime) {
313     err = gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
314     if (err) {
315       mutt_error (_("error enabling CMS protocol: %s\n"), gpgme_strerror (err));
316       sleep (2);
317       mutt_exit (1);
318     }
319   }
320
321   return ctx;
322 }
323
324 /* Create a new gpgme data object.  This is a wrapper to die on
325    error. */
326 static gpgme_data_t create_gpgme_data (void)
327 {
328   gpgme_error_t err;
329   gpgme_data_t data;
330
331   err = gpgme_data_new (&data);
332   if (err) {
333     mutt_error (_("error creating gpgme data object: %s\n"),
334                 gpgme_strerror (err));
335     sleep (2);
336     mutt_exit (1);
337   }
338   return data;
339 }
340
341 /* Create a new GPGME Data object from the mail body A.  With CONVERT
342    passed as true, the lines are converted to CR,LF if required.
343    Return NULL on error or the gpgme_data_t object on success. */
344 static gpgme_data_t body_to_data_object (BODY * a, int convert)
345 {
346   char tempfile[_POSIX_PATH_MAX];
347   FILE *fptmp;
348   int err = 0;
349   gpgme_data_t data;
350
351   fptmp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
352   if (!fptmp) {
353     mutt_perror (_("Can't create temporary file"));
354     return NULL;
355   }
356
357   mutt_write_mime_header (a, fptmp);
358   fputc ('\n', fptmp);
359   mutt_write_mime_body (a, fptmp);
360
361   if (convert) {
362     int c, hadcr = 0;
363     unsigned char buf[1];
364
365     data = create_gpgme_data ();
366     rewind (fptmp);
367     while ((c = fgetc (fptmp)) != EOF) {
368       if (c == '\r')
369         hadcr = 1;
370       else {
371         if (c == '\n' && !hadcr) {
372           buf[0] = '\r';
373           gpgme_data_write (data, buf, 1);
374         }
375
376         hadcr = 0;
377       }
378       /* FIXME: This is quite suboptimal */
379       buf[0] = c;
380       gpgme_data_write (data, buf, 1);
381     }
382     gpgme_data_seek (data, 0, SEEK_SET);
383   } else {
384     err = gpgme_data_new_from_file (&data, tempfile, 1);
385   }
386   m_fclose(&fptmp);
387   unlink (tempfile);
388   if (err) {
389     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
390     return NULL;
391   }
392
393   return data;
394 }
395
396 /* Create a GPGME data object from the stream FP but limit the object
397    to LENGTH bytes starting at OFFSET bytes from the beginning of the
398    file. */
399 static gpgme_data_t file_to_data_object (FILE * fp, long offset, long length)
400 {
401   int err = 0;
402   gpgme_data_t data;
403
404   err = gpgme_data_new_from_filepart (&data, NULL, fp, offset, length);
405   if (err) {
406     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
407     return NULL;
408   }
409
410   return data;
411 }
412
413 /* Write a GPGME data object to the stream FP. */
414 static int data_object_to_stream (gpgme_data_t data, FILE * fp)
415 {
416   int err;
417   char buf[4096], *p;
418   ssize_t nread;
419
420   err = ((gpgme_data_seek (data, 0, SEEK_SET) == -1)
421          ? gpgme_error_from_errno (errno) : 0);
422   if (err) {
423     mutt_error (_("error rewinding data object: %s\n"), gpgme_strerror (err));
424     return -1;
425   }
426
427   while ((nread = gpgme_data_read (data, buf, sizeof (buf)))) {
428     /* fixme: we are not really converting CRLF to LF but just
429        skipping CR. Doing it correctly needs a more complex logic */
430     for (p = buf; nread; p++, nread--) {
431       if (*p != '\r')
432         putc (*p, fp);
433     }
434
435     if (ferror (fp)) {
436       mutt_perror ("[tempfile]");
437       return -1;
438     }
439   }
440   if (nread == -1) {
441     mutt_error (_("error reading data object: %s\n"), strerror (errno));
442     return -1;
443   }
444   return 0;
445 }
446
447 /* Copy a data object to a newly created temporay file and return that
448    filename. Caller must free.  With RET_FP not NULL, don't close the
449    stream but return it there. */
450 static char *data_object_to_tempfile (gpgme_data_t data, FILE ** ret_fp)
451 {
452   int err;
453   char tempfile[_POSIX_PATH_MAX];
454   FILE *fp;
455   ssize_t nread = 0;
456
457   fp = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
458   if (!fp) {
459     mutt_perror (_("Can't create temporary file"));
460     return NULL;
461   }
462
463   err = ((gpgme_data_seek (data, 0, SEEK_SET) == -1)
464          ? gpgme_error_from_errno (errno) : 0);
465   if (!err) {
466     char buf[4096];
467
468     while ((nread = gpgme_data_read (data, buf, sizeof (buf)))) {
469       if (fwrite (buf, nread, 1, fp) != 1) {
470         mutt_perror (_("Can't create temporary file"));
471         m_fclose(&fp);
472         unlink (tempfile);
473         return NULL;
474       }
475     }
476   }
477   if (ret_fp)
478     rewind (fp);
479   else
480     m_fclose(&fp);
481   if (nread == -1) {
482     mutt_error (_("error reading data object: %s\n"), gpgme_strerror (err));
483     unlink (tempfile);
484     m_fclose(&fp);
485     return NULL;
486   }
487   if (ret_fp)
488     *ret_fp = fp;
489   return m_strdup(tempfile);
490 }
491
492
493 /* Create a GpgmeRecipientSet from the keys in the string KEYLIST.
494    The keys must be space delimited. */
495 static gpgme_key_t *create_recipient_set (const char *keylist,
496                                           gpgme_protocol_t protocol)
497 {
498   int err;
499   const char *s;
500   char buf[100];
501   int i;
502   gpgme_key_t *rset = NULL;
503   unsigned int rset_n = 0;
504   gpgme_key_t key = NULL;
505   gpgme_ctx_t context = NULL;
506
507   err = gpgme_new (&context);
508   if (!err)
509     err = gpgme_set_protocol (context, protocol);
510
511   if (!err) {
512     s = keylist;
513     do {
514       while (*s == ' ')
515         s++;
516       for (i = 0; *s && *s != ' ' && i < ssizeof(buf) - 1;)
517         buf[i++] = *s++;
518       buf[i] = 0;
519       if (*buf) {
520         if (i > 1 && buf[i - 1] == '!') {
521           /* The user selected to override the valididy of that
522              key. */
523           buf[i - 1] = 0;
524
525           err = gpgme_get_key (context, buf, &key, 0);
526           if (!err)
527             key->uids->validity = GPGME_VALIDITY_FULL;
528           buf[i - 1] = '!';
529         }
530         else
531           err = gpgme_get_key (context, buf, &key, 0);
532
533         if (!err) {
534           p_realloc(&rset, rset_n + 1);
535           rset[rset_n++] = key;
536         }
537         else {
538           mutt_error (_("error adding recipient `%s': %s\n"),
539                       buf, gpgme_strerror (err));
540           p_delete(&rset);
541           return NULL;
542         }
543       }
544     } while (*s);
545   }
546
547   /* NULL terminate.  */
548   p_realloc(&rset, rset_n + 1);
549   rset[rset_n++] = NULL;
550
551   if (context)
552     gpgme_release (context);
553
554   return rset;
555 }
556
557
558 /* Make sure that the correct signer is set. Returns 0 on success. */
559 static int set_signer (gpgme_ctx_t ctx, int for_smime)
560 {
561   char *signid = for_smime ? SmimeDefaultKey : PgpSignAs;
562   gpgme_error_t err;
563   gpgme_ctx_t listctx;
564   gpgme_key_t key, key2;
565
566   if (!signid || !*signid)
567     return 0;
568
569   listctx = create_gpgme_context (for_smime);
570   err = gpgme_op_keylist_start (listctx, signid, 1);
571   if (!err)
572     err = gpgme_op_keylist_next (listctx, &key);
573   if (err) {
574     gpgme_release (listctx);
575     mutt_error (_("secret key `%s' not found: %s\n"),
576                 signid, gpgme_strerror (err));
577     return -1;
578   }
579   err = gpgme_op_keylist_next (listctx, &key2);
580   if (!err) {
581     gpgme_key_release (key);
582     gpgme_key_release (key2);
583     gpgme_release (listctx);
584     mutt_error (_("ambiguous specification of secret key `%s'\n"), signid);
585     return -1;
586   }
587   gpgme_op_keylist_end (listctx);
588   gpgme_release (listctx);
589
590   gpgme_signers_clear (ctx);
591   err = gpgme_signers_add (ctx, key);
592   gpgme_key_release (key);
593   if (err) {
594     mutt_error (_("error setting secret key `%s': %s\n"),
595                 signid, gpgme_strerror (err));
596     return -1;
597   }
598   return 0;
599 }
600
601
602 /* Encrypt the gpgme data object PLAINTEXT to the recipients in RSET
603    and return an allocated filename to a temporary file containing the
604    enciphered text.  With USE_SMIME set to true, the smime backend is
605    used.  With COMBINED_SIGNED a PGP message is signed and
606    encrypted.  Returns NULL in case of error */
607 static char *encrypt_gpgme_object (gpgme_data_t plaintext, gpgme_key_t * rset,
608                                    int use_smime, int combined_signed)
609 {
610   int err;
611   gpgme_ctx_t ctx;
612   gpgme_data_t ciphertext;
613   char *outfile;
614
615   ctx = create_gpgme_context (use_smime);
616   if (!use_smime)
617     gpgme_set_armor (ctx, 1);
618
619   ciphertext = create_gpgme_data ();
620
621   if (combined_signed) {
622     if (set_signer (ctx, use_smime)) {
623       gpgme_data_release (ciphertext);
624       gpgme_release (ctx);
625       return NULL;
626     }
627     err = gpgme_op_encrypt_sign (ctx, rset, GPGME_ENCRYPT_ALWAYS_TRUST,
628                                  plaintext, ciphertext);
629   }
630   else
631     err = gpgme_op_encrypt (ctx, rset, GPGME_ENCRYPT_ALWAYS_TRUST,
632                             plaintext, ciphertext);
633   mutt_need_hard_redraw ();
634   if (err) {
635     mutt_error (_("error encrypting data: %s\n"), gpgme_strerror (err));
636     gpgme_data_release (ciphertext);
637     gpgme_release (ctx);
638     return NULL;
639   }
640
641   gpgme_release (ctx);
642
643   outfile = data_object_to_tempfile (ciphertext, NULL);
644   gpgme_data_release (ciphertext);
645   return outfile;
646 }
647
648 /* Find the "micalg" parameter from the last Gpgme operation on
649    context CTX.  It is expected that this operation was a sign
650    operation.  Return the algorithm name as a C string in buffer BUF
651    which must have been allocated by the caller with size BUFLEN.
652    Returns 0 on success or -1 in case of an error.  The return string
653    is truncted to BUFLEN - 1. */
654 static int get_micalg (gpgme_ctx_t ctx, char *buf, ssize_t buflen)
655 {
656   gpgme_sign_result_t result = NULL;
657   const char *algorithm_name = NULL;
658
659   if (!buflen)
660     return -1;
661
662   *buf = 0;
663   result = gpgme_op_sign_result (ctx);
664   if (result) {
665     algorithm_name = gpgme_hash_algo_name (result->signatures->hash_algo);
666     if (algorithm_name) {
667       m_strcpy(buf, buflen, algorithm_name);
668     }
669   }
670
671   return *buf ? 0 : -1;
672 }
673
674 static void print_time (time_t t, STATE * s)
675 {
676   char p[STRING];
677
678   setlocale (LC_TIME, "");
679 #ifdef HAVE_LANGINFO_D_T_FMT
680   strftime (p, sizeof (p), nl_langinfo (D_T_FMT), localtime (&t));
681 #else
682   strftime (p, sizeof (p), "%c", localtime (&t));
683 #endif
684   setlocale (LC_TIME, "C");
685   state_attach_puts (p, s);
686 }
687
688 /* 
689  * Implementation of `sign_message'.
690  */
691
692 /* Sign the MESSAGE in body A either using OpenPGP or S/MIME when
693    USE_SMIME is passed as true.  Returns the new body or NULL on
694    error. */
695 static BODY *sign_message (BODY * a, int use_smime)
696 {
697   BODY *t;
698   char *sigfile;
699   int err = 0;
700   char buf[100];
701   gpgme_ctx_t ctx;
702   gpgme_data_t message, signature;
703
704   convert_to_7bit (a);          /* Signed data _must_ be in 7-bit format. */
705
706   message = body_to_data_object (a, 1);
707   if (!message)
708     return NULL;
709   signature = create_gpgme_data ();
710
711   ctx = create_gpgme_context (use_smime);
712   if (!use_smime)
713     gpgme_set_armor (ctx, 1);
714
715   if (set_signer (ctx, use_smime)) {
716     gpgme_data_release (signature);
717     gpgme_release (ctx);
718     return NULL;
719   }
720
721   err = gpgme_op_sign (ctx, message, signature, GPGME_SIG_MODE_DETACH);
722   mutt_need_hard_redraw ();
723   gpgme_data_release (message);
724   if (err) {
725     gpgme_data_release (signature);
726     gpgme_release (ctx);
727     mutt_error (_("error signing data: %s\n"), gpgme_strerror (err));
728     return NULL;
729   }
730
731   sigfile = data_object_to_tempfile (signature, NULL);
732   gpgme_data_release (signature);
733   if (!sigfile) {
734     gpgme_release (ctx);
735     return NULL;
736   }
737
738   t = body_new();
739   t->type = TYPEMULTIPART;
740   t->subtype = m_strdup("signed");
741   t->encoding = ENC7BIT;
742   t->use_disp = 0;
743   t->disposition = DISPINLINE;
744
745   parameter_set_boundary(&t->parameter);
746   parameter_setval(&t->parameter, "protocol",
747                    use_smime ? "application/pkcs7-signature"
748                              : "application/pgp-signature");
749   /* Get the micalg from gpgme.  Old gpgme versions don't support this
750      for S/MIME so we assume sha-1 in this case. */
751   if (!get_micalg (ctx, buf, sizeof buf))
752     parameter_setval(&t->parameter, "micalg", buf);
753   else if (use_smime)
754     parameter_setval(&t->parameter, "micalg", "sha1");
755   gpgme_release (ctx);
756
757   t->parts = a;
758   a = t;
759
760   t->parts->next = body_new();
761   t = t->parts->next;
762   t->type = TYPEAPPLICATION;
763   if (use_smime) {
764     t->subtype = m_strdup("pkcs7-signature");
765     parameter_setval(&t->parameter, "name", "smime.p7s");
766     t->encoding = ENCBASE64;
767     t->use_disp = 1;
768     t->disposition = DISPATTACH;
769     t->d_filename = m_strdup("smime.p7s");
770   }
771   else {
772     t->subtype = m_strdup("pgp-signature");
773     t->use_disp = 0;
774     t->disposition = DISPINLINE;
775     t->encoding = ENC7BIT;
776   }
777   t->filename = sigfile;
778   t->unlink = 1;                /* ok to remove this file after sending. */
779
780   return a;
781 }
782
783
784 BODY *pgp_gpgme_sign_message (BODY * a)
785 {
786   return sign_message (a, 0);
787 }
788
789 BODY *smime_gpgme_sign_message (BODY * a)
790 {
791   return sign_message (a, 1);
792 }
793
794 /*
795  * Implementation of `encrypt_message'.
796  */
797
798 /* Encrypt the mail body A to all keys given as space separated keyids
799    or fingerprints in KEYLIST and return the encrypted body.  */
800 BODY *pgp_gpgme_encrypt_message (BODY * a, char *keylist, int sign)
801 {
802   char *outfile = NULL;
803   BODY *t;
804   gpgme_key_t *rset = NULL;
805   gpgme_data_t plaintext;
806
807   rset = create_recipient_set (keylist, GPGME_PROTOCOL_OpenPGP);
808   if (!rset)
809     return NULL;
810
811   if (sign)
812     convert_to_7bit (a);
813   plaintext = body_to_data_object (a, 0);
814   if (!plaintext) {
815     p_delete(&rset);
816     return NULL;
817   }
818
819   outfile = encrypt_gpgme_object (plaintext, rset, 0, sign);
820   gpgme_data_release (plaintext);
821   p_delete(&rset);
822   if (!outfile)
823     return NULL;
824
825   t = body_new();
826   t->type = TYPEMULTIPART;
827   t->subtype = m_strdup("encrypted");
828   t->encoding = ENC7BIT;
829   t->use_disp = 0;
830   t->disposition = DISPINLINE;
831
832   parameter_set_boundary(&t->parameter);
833   parameter_setval(&t->parameter, "protocol", "application/pgp-encrypted");
834
835   t->parts = body_new();
836   t->parts->type = TYPEAPPLICATION;
837   t->parts->subtype = m_strdup("pgp-encrypted");
838   t->parts->encoding = ENC7BIT;
839
840   t->parts->next = body_new();
841   t->parts->next->type = TYPEAPPLICATION;
842   t->parts->next->subtype = m_strdup("octet-stream");
843   t->parts->next->encoding = ENC7BIT;
844   t->parts->next->filename = outfile;
845   t->parts->next->use_disp = 1;
846   t->parts->next->disposition = DISPINLINE;
847   t->parts->next->unlink = 1;   /* delete after sending the message */
848   t->parts->next->d_filename = m_strdup("msg.asc"); /* non pgp/mime
849                                                            can save */
850
851   return t;
852 }
853
854 /*
855  * Implementation of `smime_build_smime_entity'.
856  */
857
858 /* Encrypt the mail body A to all keys given as space separated
859    fingerprints in KEYLIST and return the S/MIME encrypted body.  */
860 BODY *smime_gpgme_build_smime_entity (BODY * a, char *keylist)
861 {
862   char *outfile = NULL;
863   BODY *t;
864   gpgme_key_t *rset = NULL;
865   gpgme_data_t plaintext;
866
867   rset = create_recipient_set (keylist, GPGME_PROTOCOL_CMS);
868   if (!rset)
869     return NULL;
870
871   plaintext = body_to_data_object (a, 0);
872   if (!plaintext) {
873     p_delete(&rset);
874     return NULL;
875   }
876
877   outfile = encrypt_gpgme_object (plaintext, rset, 1, 0);
878   gpgme_data_release (plaintext);
879   p_delete(&rset);
880   if (!outfile)
881     return NULL;
882
883   t = body_new();
884   t->type = TYPEAPPLICATION;
885   t->subtype = m_strdup("pkcs7-mime");
886   parameter_setval(&t->parameter, "name", "smime.p7m");
887   parameter_setval(&t->parameter, "smime-type", "enveloped-data");
888   t->encoding = ENCBASE64;      /* The output of OpenSSL SHOULD be binary */
889   t->use_disp = 1;
890   t->disposition = DISPATTACH;
891   t->d_filename = m_strdup("smime.p7m");
892   t->filename = outfile;
893   t->unlink = 1;                /*delete after sending the message */
894   t->parts = 0;
895   t->next = 0;
896
897   return t;
898 }
899
900
901 /* 
902  * Implementation of `verify_one'.
903  */
904
905 /* Display the common attributes of the signature summary SUM.
906    Return 1 if there is is a severe warning.
907  */
908 static int show_sig_summary (unsigned long sum,
909                              gpgme_ctx_t ctx, gpgme_key_t key, int idx,
910                              STATE * s)
911 {
912   int severe = 0;
913
914   if ((sum & GPGME_SIGSUM_KEY_REVOKED)) {
915     state_attach_puts (_("Warning: One of the keys has been revoked\n"), s);
916     severe = 1;
917   }
918
919   if ((sum & GPGME_SIGSUM_KEY_EXPIRED)) {
920     time_t at = key->subkeys->expires ? key->subkeys->expires : 0;
921
922     if (at) {
923       state_attach_puts (_("Warning: The key used to create the "
924                            "signature expired at: "), s);
925       print_time (at, s);
926       state_attach_puts ("\n", s);
927     }
928     else
929       state_attach_puts (_("Warning: At least one certification key "
930                            "has expired\n"), s);
931   }
932
933   if ((sum & GPGME_SIGSUM_SIG_EXPIRED)) {
934     gpgme_verify_result_t result;
935     gpgme_signature_t sig;
936     int i;
937
938     result = gpgme_op_verify_result (ctx);
939
940     for (sig = result->signatures, i = 0; sig && (i < idx);
941          sig = sig->next, i++);
942
943     state_attach_puts (_("Warning: The signature expired at: "), s);
944     print_time (sig ? sig->exp_timestamp : 0, s);
945     state_attach_puts ("\n", s);
946   }
947
948   if ((sum & GPGME_SIGSUM_KEY_MISSING))
949     state_attach_puts (_("Can't verify due to a missing "
950                          "key or certificate\n"), s);
951
952   if ((sum & GPGME_SIGSUM_CRL_MISSING)) {
953     state_attach_puts (_("The CRL is not available\n"), s);
954     severe = 1;
955   }
956
957   if ((sum & GPGME_SIGSUM_CRL_TOO_OLD)) {
958     state_attach_puts (_("Available CRL is too old\n"), s);
959     severe = 1;
960   }
961
962   if ((sum & GPGME_SIGSUM_BAD_POLICY))
963     state_attach_puts (_("A policy requirement was not met\n"), s);
964
965   if ((sum & GPGME_SIGSUM_SYS_ERROR)) {
966     const char *t0 = NULL, *t1 = NULL;
967     gpgme_verify_result_t result;
968     gpgme_signature_t sig;
969     int i;
970
971     state_attach_puts (_("A system error occurred"), s);
972
973     /* Try to figure out some more detailed system error information. */
974     result = gpgme_op_verify_result (ctx);
975     for (sig = result->signatures, i = 0; sig && (i < idx);
976          sig = sig->next, i++);
977     if (sig) {
978       t0 = "";
979       t1 = sig->wrong_key_usage ? "Wrong_Key_Usage" : "";
980     }
981
982     if (t0 || t1) {
983       state_attach_puts (": ", s);
984       if (t0)
985         state_attach_puts (t0, s);
986       if (t1 && !(t0 && !m_strcmp(t0, t1))) {
987         if (t0)
988           state_attach_puts (",", s);
989         state_attach_puts (t1, s);
990       }
991     }
992     state_attach_puts ("\n", s);
993   }
994
995   return severe;
996 }
997
998
999 static void show_fingerprint (gpgme_key_t key, STATE * state)
1000 {
1001   const char *s;
1002   int i, is_pgp;
1003   char *buf, *p;
1004   const char *prefix = _("Fingerprint: ");
1005   ssize_t bufsize;
1006
1007   if (!key)
1008     return;
1009   s = key->subkeys ? key->subkeys->fpr : NULL;
1010   if (!s)
1011     return;
1012   is_pgp = (key->protocol == GPGME_PROTOCOL_OpenPGP);
1013
1014   bufsize = m_strlen(prefix) + m_strlen(s) * 4 + 2;
1015   buf = xmalloc(bufsize);
1016   m_strcpy(buf, bufsize, prefix);
1017   p = buf + m_strlen(buf);
1018   if (is_pgp && m_strlen(s) == 40) {     /* PGP v4 style formatted. */
1019     for (i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++) {
1020       *p++ = s[0];
1021       *p++ = s[1];
1022       *p++ = s[2];
1023       *p++ = s[3];
1024       *p++ = ' ';
1025       if (i == 4)
1026         *p++ = ' ';
1027     }
1028   }
1029   else {
1030     for (i = 0; *s && s[1] && s[2]; s += 2, i++) {
1031       *p++ = s[0];
1032       *p++ = s[1];
1033       *p++ = is_pgp ? ' ' : ':';
1034       if (is_pgp && i == 7)
1035         *p++ = ' ';
1036     }
1037   }
1038
1039   /* just in case print remaining odd digits */
1040   for (; *s; s++)
1041     *p++ = *s;
1042   *p++ = '\n';
1043   *p = 0;
1044   state_attach_puts (buf, state);
1045   p_delete(&buf);
1046 }
1047
1048 /* Show the valididy of a key used for one signature. */
1049 static void show_one_sig_validity (gpgme_ctx_t ctx, int idx, STATE * s)
1050 {
1051   gpgme_verify_result_t result = NULL;
1052   gpgme_signature_t sig = NULL;
1053   const char *txt = NULL;
1054
1055   result = gpgme_op_verify_result (ctx);
1056   if (result)
1057     for (sig = result->signatures; sig && (idx > 0); sig = sig->next, idx--);
1058
1059   switch (sig ? sig->validity : 0) {
1060   case GPGME_VALIDITY_UNKNOWN:
1061     txt = _("WARNING: We have NO indication whether "
1062             "the key belongs to the person named " "as shown above\n");
1063     break;
1064   case GPGME_VALIDITY_UNDEFINED:
1065     break;
1066   case GPGME_VALIDITY_NEVER:
1067     txt = _("WARNING: The key does NOT BELONG to "
1068             "the person named as shown above\n");
1069     break;
1070   case GPGME_VALIDITY_MARGINAL:
1071     txt = _("WARNING: It is NOT certain that the key "
1072             "belongs to the person named as shown above\n");
1073     break;
1074   case GPGME_VALIDITY_FULL:
1075   case GPGME_VALIDITY_ULTIMATE:
1076     txt = NULL;
1077     break;
1078   }
1079   if (txt)
1080     state_attach_puts (txt, s);
1081 }
1082
1083 /* Show information about one signature.  This fucntion is called with
1084    the context CTX of a sucessful verification operation and the
1085    enumerator IDX which should start at 0 and incremete for each
1086    call/signature. 
1087
1088    Return values are: 0 for normal procession, 1 for a bad signature,
1089    2 for a signature with a warning or -1 for no more signature.  */
1090 static int show_one_sig_status (gpgme_ctx_t ctx, int idx, STATE * s)
1091 {
1092   time_t created;
1093   const char *fpr, *uid;
1094   gpgme_key_t key = NULL;
1095   int i, anybad = 0, anywarn = 0;
1096   unsigned int sum;
1097   gpgme_user_id_t uids = NULL;
1098   gpgme_verify_result_t result;
1099   gpgme_signature_t sig;
1100   gpgme_error_t err = GPG_ERR_NO_ERROR;
1101
1102   result = gpgme_op_verify_result (ctx);
1103   if (result) {
1104     /* FIXME: this code should use a static variable and remember
1105        the current position in the list of signatures, IMHO.
1106        -moritz.  */
1107
1108     for (i = 0, sig = result->signatures; sig && (i < idx);
1109          i++, sig = sig->next);
1110     if (!sig)
1111       return -1;                /* Signature not found.  */
1112
1113     if (signature_key) {
1114       gpgme_key_release (signature_key);
1115       signature_key = NULL;
1116     }
1117
1118     created = sig->timestamp;
1119     fpr = sig->fpr;
1120     sum = sig->summary;
1121
1122     if (gpg_err_code (sig->status) != GPG_ERR_NO_ERROR)
1123       anybad = 1;
1124
1125     err = gpgme_get_key (ctx, fpr, &key, 0);    /* secret key?  */
1126     if (!err) {
1127       uid = (key->uids && key->uids->uid) ? key->uids->uid : "[?]";
1128       if (!signature_key)
1129         signature_key = key;
1130     }
1131     else {
1132       key = NULL;               /* Old gpgme versions did not set KEY to NULL on
1133                                    error.   Do it here to avoid a double free. */
1134       uid = "[?]";
1135     }
1136
1137     if (!s || !s->fpout || !(s->flags & M_DISPLAY));    /* No state information so no way to print anything. */
1138     else if (err) {
1139       state_attach_puts (_("Error getting key information: "), s);
1140       state_attach_puts (gpg_strerror (err), s);
1141       state_attach_puts ("\n", s);
1142       anybad = 1;
1143     }
1144     else if ((sum & GPGME_SIGSUM_GREEN)) {
1145       state_attach_puts (_("Good signature from: "), s);
1146       state_attach_puts (uid, s);
1147       state_attach_puts ("\n", s);
1148       for (i = 1, uids = key->uids; uids; i++, uids = uids->next) {
1149         if (i == 1)
1150           /* Skip primary UID.  */
1151           continue;
1152         if (uids->revoked)
1153           continue;
1154         state_attach_puts (_("                aka: "), s);
1155         state_attach_puts (uids->uid, s);
1156         state_attach_puts ("\n", s);
1157       }
1158       state_attach_puts (_("            created: "), s);
1159       print_time (created, s);
1160       state_attach_puts ("\n", s);
1161       if (show_sig_summary (sum, ctx, key, idx, s))
1162         anywarn = 1;
1163       show_one_sig_validity (ctx, idx, s);
1164     }
1165     else if ((sum & GPGME_SIGSUM_RED)) {
1166       state_attach_puts (_("*BAD* signature claimed to be from: "), s);
1167       state_attach_puts (uid, s);
1168       state_attach_puts ("\n", s);
1169       show_sig_summary (sum, ctx, key, idx, s);
1170     }
1171     else if (!anybad && key && (key->protocol == GPGME_PROTOCOL_OpenPGP)) {     /* We can't decide (yellow) but this is a PGP key with a good
1172                                                                                    signature, so we display what a PGP user expects: The name,
1173                                                                                    fingerprint and the key validity (which is neither fully or
1174                                                                                    ultimate). */
1175       state_attach_puts (_("Good signature from: "), s);
1176       state_attach_puts (uid, s);
1177       state_attach_puts ("\n", s);
1178       state_attach_puts (_("            created: "), s);
1179       print_time (created, s);
1180       state_attach_puts ("\n", s);
1181       show_one_sig_validity (ctx, idx, s);
1182       show_fingerprint (key, s);
1183       if (show_sig_summary (sum, ctx, key, idx, s))
1184         anywarn = 1;
1185     }
1186     else {                      /* can't decide (yellow) */
1187
1188       state_attach_puts (_("Error checking signature"), s);
1189       state_attach_puts ("\n", s);
1190       show_sig_summary (sum, ctx, key, idx, s);
1191     }
1192
1193     if (key != signature_key)
1194       gpgme_key_release (key);
1195   }
1196
1197   return anybad ? 1 : anywarn ? 2 : 0;
1198 }
1199
1200 /* Do the actual verification step. With IS_SMIME set to true we
1201    assume S/MIME (surprise!) */
1202 static int verify_one (BODY * sigbdy, STATE * s,
1203                        const char *tempfile, int is_smime)
1204 {
1205   int badsig = -1;
1206   int anywarn = 0;
1207   int err;
1208   gpgme_ctx_t ctx;
1209   gpgme_data_t signature, message;
1210
1211   signature = file_to_data_object (s->fpin, sigbdy->offset, sigbdy->length);
1212   if (!signature)
1213     return -1;
1214
1215   /* We need to tell gpgme about the encoding because the backend can't
1216      auto-detect plain base-64 encoding which is used by S/MIME. */
1217   if (is_smime)
1218     gpgme_data_set_encoding (signature, GPGME_DATA_ENCODING_BASE64);
1219
1220   err = gpgme_data_new_from_file (&message, tempfile, 1);
1221   if (err) {
1222     gpgme_data_release (signature);
1223     mutt_error (_("error allocating data object: %s\n"), gpgme_strerror (err));
1224     return -1;
1225   }
1226   ctx = create_gpgme_context (is_smime);
1227
1228   /* Note: We don't need a current time output because GPGME avoids
1229      such an attack by separating the meta information from the
1230      data. */
1231   state_attach_puts (_("[-- Begin signature information --]\n"), s);
1232
1233   err = gpgme_op_verify (ctx, signature, message, NULL);
1234   mutt_need_hard_redraw ();
1235   if (err) {
1236     char buf[200];
1237
1238     snprintf (buf, sizeof (buf) - 1,
1239               _("Error: verification failed: %s\n"), gpgme_strerror (err));
1240     state_attach_puts (buf, s);
1241   }
1242   else {                        /* Verification succeeded, see what the result is. */
1243     int res, idx;
1244     int anybad = 0;
1245
1246     if (signature_key) {
1247       gpgme_key_release (signature_key);
1248       signature_key = NULL;
1249     }
1250
1251     for (idx = 0; (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1252       if (res == 1)
1253         anybad = 1;
1254       else if (res == 2)
1255         anywarn = 2;
1256     }
1257     if (!anybad)
1258       badsig = 0;
1259   }
1260
1261   if (!badsig) {
1262     gpgme_verify_result_t result;
1263     gpgme_sig_notation_t notation;
1264     gpgme_signature_t sig;
1265
1266     result = gpgme_op_verify_result (ctx);
1267     if (result) {
1268       for (sig = result->signatures; sig; sig = sig->next) {
1269         if (sig->notations) {
1270           state_attach_puts ("*** Begin Notation (signature by: ", s);
1271           state_attach_puts (sig->fpr, s);
1272           state_attach_puts (") ***\n", s);
1273           for (notation = sig->notations; notation; notation = notation->next)
1274           {
1275             if (notation->name) {
1276               state_attach_puts (notation->name, s);
1277               state_attach_puts ("=", s);
1278             }
1279             if (notation->value) {
1280               state_attach_puts (notation->value, s);
1281               if (!(*notation->value
1282                     && (notation->value[m_strlen(notation->value) - 1] ==
1283                         '\n')))
1284                 state_attach_puts ("\n", s);
1285             }
1286           }
1287           state_attach_puts ("*** End Notation ***\n", s);
1288         }
1289       }
1290     }
1291   }
1292
1293   gpgme_release (ctx);
1294
1295   state_attach_puts (_("[-- End signature information --]\n\n"), s);
1296
1297   return badsig ? 1 : anywarn ? 2 : 0;
1298 }
1299
1300 int pgp_gpgme_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
1301 {
1302   return verify_one (sigbdy, s, tempfile, 0);
1303 }
1304
1305 int smime_gpgme_verify_one (BODY * sigbdy, STATE * s, const char *tempfile)
1306 {
1307   return verify_one (sigbdy, s, tempfile, 1);
1308 }
1309
1310 /*
1311  * Implementation of `decrypt_part'.
1312  */
1313
1314 /* Decrypt a PGP or SMIME message (depending on the boolean flag
1315    IS_SMIME) with body A described further by state S.  Write
1316    plaintext out to file FPOUT and return a new body.  For PGP returns
1317    a flag in R_IS_SIGNED to indicate whether this is a combined
1318    encrypted and signed message, for S/MIME it returns true when it is
1319    not a encrypted but a signed message.  */
1320 static BODY *decrypt_part (BODY * a, STATE * s, FILE * fpout, int is_smime,
1321                            int *r_is_signed)
1322 {
1323   struct stat info;
1324   BODY *tattach;
1325   int err = 0;
1326   gpgme_ctx_t ctx;
1327   gpgme_data_t ciphertext, plaintext;
1328   int maybe_signed = 0;
1329   int anywarn = 0;
1330   int sig_stat = 0;
1331
1332   if (r_is_signed)
1333     *r_is_signed = 0;
1334
1335   ctx = create_gpgme_context (is_smime);
1336
1337 restart:
1338   /* Make a data object from the body, create context etc. */
1339   ciphertext = file_to_data_object (s->fpin, a->offset, a->length);
1340   if (!ciphertext)
1341     return NULL;
1342   plaintext = create_gpgme_data ();
1343
1344   /* Do the decryption or the verification in case of the S/MIME hack. */
1345   if ((!is_smime) || maybe_signed) {
1346     if (!is_smime)
1347       err = gpgme_op_decrypt_verify (ctx, ciphertext, plaintext);
1348     else if (maybe_signed)
1349       err = gpgme_op_verify (ctx, ciphertext, NULL, plaintext);
1350
1351     {
1352       /* Check wether signatures have been verified.  */
1353       gpgme_verify_result_t verify_result = gpgme_op_verify_result (ctx);
1354
1355       if (verify_result->signatures)
1356         sig_stat = 1;
1357     }
1358   }
1359   else
1360     err = gpgme_op_decrypt (ctx, ciphertext, plaintext);
1361   gpgme_data_release (ciphertext);
1362   if (err) {
1363     if (is_smime && !maybe_signed && gpg_err_code (err) == GPG_ERR_NO_DATA) {
1364       /* Check whether this might be a signed message despite what
1365          the mime header told us.  Retry then.  gpgsm returns the
1366          error information "unsupported Algorithm '?'" but gpgme
1367          will not store this unknown algorithm, thus we test that
1368          it has not been set. */
1369       gpgme_decrypt_result_t result;
1370
1371       result = gpgme_op_decrypt_result (ctx);
1372       if (!result->unsupported_algorithm) {
1373         maybe_signed = 1;
1374         gpgme_data_release (plaintext);
1375         goto restart;
1376       }
1377     }
1378     mutt_need_hard_redraw ();
1379     if ((s->flags & M_DISPLAY)) {
1380       char buf[200];
1381
1382       snprintf (buf, sizeof (buf) - 1,
1383                 _("[-- Error: decryption failed: %s --]\n\n"),
1384                 gpgme_strerror (err));
1385       state_attach_puts (buf, s);
1386     }
1387     gpgme_data_release (plaintext);
1388     gpgme_release (ctx);
1389     return NULL;
1390   }
1391   mutt_need_hard_redraw ();
1392
1393   /* Read the output from GPGME, and make sure to change CRLF to LF,
1394      otherwise read_mime_header has a hard time parsing the message.  */
1395   if (data_object_to_stream (plaintext, fpout)) {
1396     gpgme_data_release (plaintext);
1397     gpgme_release (ctx);
1398     return NULL;
1399   }
1400   gpgme_data_release (plaintext);
1401
1402   a->is_signed_data = 0;
1403   if (sig_stat) {
1404     int res, idx;
1405     int anybad = 0;
1406
1407     if (maybe_signed)
1408       a->is_signed_data = 1;
1409     if (r_is_signed)
1410       *r_is_signed = -1;        /* A signature exists. */
1411
1412     if ((s->flags & M_DISPLAY))
1413       state_attach_puts (_("[-- Begin signature " "information --]\n"), s);
1414     for (idx = 0; (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1415       if (res == 1)
1416         anybad = 1;
1417       else if (res == 2)
1418         anywarn = 1;
1419     }
1420     if (!anybad && idx && r_is_signed && *r_is_signed)
1421       *r_is_signed = anywarn ? 2 : 1;   /* Good signature. */
1422
1423     if ((s->flags & M_DISPLAY))
1424       state_attach_puts (_("[-- End signature " "information --]\n\n"), s);
1425   }
1426   gpgme_release (ctx);
1427   ctx = NULL;
1428
1429   fflush (fpout);
1430   rewind (fpout);
1431   tattach = mutt_read_mime_header (fpout, 0);
1432   if (tattach) {
1433     /*
1434      * Need to set the length of this body part.
1435      */
1436     fstat (fileno (fpout), &info);
1437     tattach->length = info.st_size - tattach->offset;
1438
1439     tattach->warnsig = anywarn;
1440
1441     /* See if we need to recurse on this MIME part.  */
1442     mutt_parse_part (fpout, tattach);
1443   }
1444
1445   return tattach;
1446 }
1447
1448 /* Decrypt a PGP/MIME message in FPIN and B and return a new body and
1449    the stream in CUR and FPOUT.  Returns 0 on success. */
1450 int pgp_gpgme_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b, BODY ** cur)
1451 {
1452   char tempfile[_POSIX_PATH_MAX];
1453   STATE s;
1454   BODY *first_part = b;
1455   int is_signed;
1456
1457   first_part->goodsig = 0;
1458   first_part->warnsig = 0;
1459
1460   if (!mutt_is_multipart_encrypted (b))
1461     return -1;
1462
1463   if (!b->parts || !b->parts->next)
1464     return -1;
1465
1466   b = b->parts->next;
1467
1468   p_clear(&s, 1);
1469   s.fpin = fpin;
1470   *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1471   if (!*fpout) {
1472     mutt_perror (_("Can't create temporary file"));
1473     return -1;
1474   }
1475   unlink (tempfile);
1476
1477   *cur = decrypt_part (b, &s, *fpout, 0, &is_signed);
1478   rewind (*fpout);
1479   if (is_signed > 0)
1480     first_part->goodsig = 1;
1481
1482   return *cur ? 0 : -1;
1483 }
1484
1485
1486 /* Decrypt a S/MIME message in FPIN and B and return a new body and
1487    the stream in CUR and FPOUT.  Returns 0 on success. */
1488 int smime_gpgme_decrypt_mime (FILE * fpin, FILE ** fpout, BODY * b,
1489                               BODY ** cur)
1490 {
1491   char tempfile[_POSIX_PATH_MAX];
1492   STATE s;
1493   FILE *tmpfp = NULL;
1494   int is_signed;
1495   long saved_b_offset;
1496   ssize_t saved_b_length;
1497   int saved_b_type;
1498
1499   if (!mutt_is_application_smime (b))
1500     return -1;
1501
1502   if (b->parts)
1503     return -1;
1504
1505   /* Decode the body - we need to pass binary CMS to the
1506      backend.  The backend allows for Base64 encoded data but it does
1507      not allow for QP which I have seen in some messages.  So better
1508      do it here. */
1509   saved_b_type = b->type;
1510   saved_b_offset = b->offset;
1511   saved_b_length = b->length;
1512   p_clear(&s, 1);
1513   s.fpin = fpin;
1514   fseeko (s.fpin, b->offset, 0);
1515   tmpfp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1516   if (!tmpfp) {
1517     mutt_perror (_("Can't create temporary file"));
1518     return -1;
1519   }
1520   mutt_unlink (tempfile);
1521
1522   s.fpout = tmpfp;
1523   mutt_decode_attachment (b, &s);
1524   fflush (tmpfp);
1525   b->length = ftello (s.fpout);
1526   b->offset = 0;
1527   rewind (tmpfp);
1528
1529   p_clear(&s, 1);
1530   s.fpin = tmpfp;
1531   s.fpout = 0;
1532   *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1533   if (!*fpout) {
1534     mutt_perror (_("Can't create temporary file"));
1535     return -1;
1536   }
1537   mutt_unlink (tempfile);
1538
1539   *cur = decrypt_part (b, &s, *fpout, 1, &is_signed);
1540   if (*cur)
1541     (*cur)->goodsig = is_signed > 0;
1542   b->type = saved_b_type;
1543   b->length = saved_b_length;
1544   b->offset = saved_b_offset;
1545   m_fclose(&tmpfp);
1546   rewind (*fpout);
1547   if (*cur && !is_signed && !(*cur)->parts
1548       && mutt_is_application_smime (*cur)) {
1549     /* Assume that this is a opaque signed s/mime message.  This is
1550        an ugly way of doing it but we have anyway a problem with
1551        arbitrary encoded S/MIME messages: Only the outer part may be
1552        encrypted.  The entire mime parsing should be revamped,
1553        probably by keeping the temportary files so that we don't
1554        need to decrypt them all the time.  Inner parts of an
1555        encrypted part can then pint into this file and tehre won't
1556        never be a need to decrypt again.  This needs a partial
1557        rewrite of the MIME engine. */
1558     BODY *bb = *cur;
1559     BODY *tmp_b;
1560
1561     saved_b_type = bb->type;
1562     saved_b_offset = bb->offset;
1563     saved_b_length = bb->length;
1564     p_clear(&s, 1);
1565     s.fpin = *fpout;
1566     fseeko (s.fpin, bb->offset, 0);
1567     tmpfp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1568     if (!tmpfp) {
1569       mutt_perror (_("Can't create temporary file"));
1570       return -1;
1571     }
1572     mutt_unlink (tempfile);
1573
1574     s.fpout = tmpfp;
1575     mutt_decode_attachment (bb, &s);
1576     fflush (tmpfp);
1577     bb->length = ftello (s.fpout);
1578     bb->offset = 0;
1579     rewind (tmpfp);
1580     m_fclose(&*fpout);
1581
1582     p_clear(&s, 1);
1583     s.fpin = tmpfp;
1584     s.fpout = 0;
1585     *fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1586     if (!*fpout) {
1587       mutt_perror (_("Can't create temporary file"));
1588       return -1;
1589     }
1590     mutt_unlink (tempfile);
1591
1592     tmp_b = decrypt_part (bb, &s, *fpout, 1, &is_signed);
1593     if (tmp_b)
1594       tmp_b->goodsig = is_signed > 0;
1595     bb->type = saved_b_type;
1596     bb->length = saved_b_length;
1597     bb->offset = saved_b_offset;
1598     m_fclose(&tmpfp);
1599     rewind (*fpout);
1600     body_list_wipe(cur);
1601     *cur = tmp_b;
1602   }
1603   return *cur ? 0 : -1;
1604 }
1605
1606
1607 /* 
1608  * Implementation of `pgp_check_traditional'.
1609  */
1610
1611 static int pgp_check_traditional_one_body (FILE * fp, BODY * b,
1612                                            int tagged_only)
1613 {
1614   char tempfile[_POSIX_PATH_MAX];
1615   char buf[HUGE_STRING];
1616   FILE *tfp;
1617
1618   short sgn = 0;
1619   short enc = 0;
1620
1621   if (b->type != TYPETEXT)
1622     return 0;
1623
1624   if (tagged_only && !b->tagged)
1625     return 0;
1626
1627   mutt_mktemp (tempfile);
1628   if (mutt_decode_save_attachment (fp, b, tempfile, 0, 0) != 0) {
1629     unlink (tempfile);
1630     return 0;
1631   }
1632
1633   if ((tfp = fopen (tempfile, "r")) == NULL) {
1634     unlink (tempfile);
1635     return 0;
1636   }
1637
1638   while (fgets (buf, sizeof (buf), tfp)) {
1639     if (!m_strncmp("-----BEGIN PGP ", buf, 15)) {
1640       if (!m_strcmp("MESSAGE-----\n", buf + 15))
1641         enc = 1;
1642       else if (!m_strcmp("SIGNED MESSAGE-----\n", buf + 15))
1643         sgn = 1;
1644     }
1645   }
1646   m_fclose(&tfp);
1647   unlink (tempfile);
1648
1649   if (!enc && !sgn)
1650     return 0;
1651
1652   /* fix the content type */
1653
1654   parameter_setval(&b->parameter, "format", "fixed");
1655   parameter_setval(&b->parameter, "x-action",
1656                    enc ? "pgp-encrypted" : "pgp-signed");
1657   return 1;
1658 }
1659
1660 int pgp_gpgme_check_traditional (FILE * fp, BODY * b, int tagged_only)
1661 {
1662   int rv = 0;
1663   int r;
1664
1665   for (; b; b = b->next) {
1666     if (is_multipart (b))
1667       rv = (pgp_gpgme_check_traditional (fp, b->parts, tagged_only) || rv);
1668     else if (b->type == TYPETEXT) {
1669       if ((r = mutt_is_application_pgp (b)))
1670         rv = (rv || r);
1671       else
1672         rv = (pgp_check_traditional_one_body (fp, b, tagged_only) || rv);
1673     }
1674   }
1675   return rv;
1676 }
1677
1678
1679 /* 
1680  * Implementation of `application_handler'.
1681  */
1682
1683 /* 
1684   Copy a clearsigned message, and strip the signature and PGP's
1685   dash-escaping.
1686   
1687   XXX - charset handling: We assume that it is safe to do
1688   character set decoding first, dash decoding second here, while
1689   we do it the other way around in the main handler.
1690   
1691   (Note that we aren't worse than Outlook & Cie in this, and also
1692   note that we can successfully handle anything produced by any
1693   existing versions of mutt.)  */
1694
1695 static void copy_clearsigned (gpgme_data_t data, STATE * s, char *charset)
1696 {
1697   char buf[HUGE_STRING];
1698   short complete, armor_header;
1699   fgetconv_t *fc;
1700   char *fname;
1701   FILE *fp;
1702
1703   fname = data_object_to_tempfile (data, &fp);
1704   if (!fname)
1705     return;
1706   unlink (fname);
1707   p_delete(&fname);
1708
1709   fc = fgetconv_open (fp, charset, Charset, M_ICONV_HOOK_FROM);
1710
1711   for (complete = 1, armor_header = 1;
1712        fgetconvs (buf, sizeof (buf), fc) != NULL;
1713        complete = strchr (buf, '\n') != NULL) {
1714     if (!complete) {
1715       if (!armor_header)
1716         state_puts (buf, s);
1717       continue;
1718     }
1719
1720     if (!m_strcmp(buf, "-----BEGIN PGP SIGNATURE-----\n"))
1721       break;
1722
1723     if (armor_header) {
1724       if (buf[0] == '\n')
1725         armor_header = 0;
1726       continue;
1727     }
1728
1729     if (s->prefix)
1730       state_puts (s->prefix, s);
1731
1732     if (buf[0] == '-' && buf[1] == ' ')
1733       state_puts (buf + 2, s);
1734     else
1735       state_puts (buf, s);
1736   }
1737
1738   fgetconv_close (&fc);
1739   m_fclose(&fp);
1740 }
1741
1742
1743 /* Support for classic_application/pgp */
1744 int pgp_gpgme_application_handler (BODY * m, STATE * s)
1745 {
1746   int needpass = -1, pgp_keyblock = 0;
1747   int clearsign = 0;
1748   long start_pos = 0;
1749   long bytes;
1750   off_t last_pos, offset;
1751   char buf[HUGE_STRING];
1752   FILE *pgpout = NULL;
1753
1754   gpgme_error_t err = 0;
1755   gpgme_data_t armored_data = NULL;
1756
1757   short maybe_goodsig = 1;
1758   short have_any_sigs = 0;
1759
1760   char body_charset[STRING];    /* Only used for clearsigned messages. */
1761
1762   /* For clearsigned messages we won't be able to get a character set
1763      but we know that this may only be text thus we assume Latin-1
1764      here. */
1765   if (!mutt_get_body_charset (body_charset, sizeof (body_charset), m))
1766     m_strcpy(body_charset, sizeof(body_charset), "iso-8859-1");
1767
1768   fseeko (s->fpin, m->offset, 0);
1769   last_pos = m->offset;
1770
1771   for (bytes = m->length; bytes > 0;) {
1772     if (fgets (buf, sizeof (buf), s->fpin) == NULL)
1773       break;
1774
1775     offset = ftello (s->fpin);
1776     bytes -= (offset - last_pos);       /* don't rely on m_strlen(buf) */
1777     last_pos = offset;
1778
1779     if (!m_strncmp("-----BEGIN PGP ", buf, 15)) {
1780       clearsign = 0;
1781       start_pos = last_pos;
1782
1783       if (!m_strcmp("MESSAGE-----\n", buf + 15))
1784         needpass = 1;
1785       else if (!m_strcmp("SIGNED MESSAGE-----\n", buf + 15)) {
1786         clearsign = 1;
1787         needpass = 0;
1788       }
1789       else if (!option (OPTDONTHANDLEPGPKEYS) &&
1790                !m_strcmp("PUBLIC KEY BLOCK-----\n", buf + 15)) {
1791         needpass = 0;
1792         pgp_keyblock = 1;
1793       }
1794       else {
1795         /* XXX - we may wish to recode here */
1796         if (s->prefix)
1797           state_puts (s->prefix, s);
1798         state_puts (buf, s);
1799         continue;
1800       }
1801
1802       have_any_sigs = (have_any_sigs || (clearsign && (s->flags & M_VERIFY)));
1803
1804       /* Copy PGP material to an data container */
1805       armored_data = create_gpgme_data ();
1806       gpgme_data_write (armored_data, buf, m_strlen(buf));
1807       while (bytes > 0 && fgets (buf, sizeof (buf) - 1, s->fpin) != NULL) {
1808         offset = ftello (s->fpin);
1809         bytes -= (offset - last_pos);   /* don't rely on m_strlen(buf) */
1810         last_pos = offset;
1811
1812         gpgme_data_write (armored_data, buf, m_strlen(buf));
1813
1814         if ((needpass && !m_strcmp("-----END PGP MESSAGE-----\n", buf))
1815             || (!needpass
1816                 && (!m_strcmp("-----END PGP SIGNATURE-----\n", buf)
1817                     || !m_strcmp("-----END PGP PUBLIC KEY BLOCK-----\n",
1818                                      buf))))
1819           break;
1820       }
1821
1822       /* Invoke PGP if needed */
1823       if (!clearsign || (s->flags & M_VERIFY)) {
1824         unsigned int sig_stat = 0;
1825         gpgme_data_t plaintext;
1826         gpgme_ctx_t ctx;
1827
1828         plaintext = create_gpgme_data ();
1829         ctx = create_gpgme_context (0);
1830
1831         if (clearsign)
1832           err = gpgme_op_verify (ctx, armored_data, NULL, plaintext);
1833         else {
1834           err = gpgme_op_decrypt_verify (ctx, armored_data, plaintext);
1835           if (gpg_err_code (err) == GPG_ERR_NO_DATA) {
1836             /* Decrypt verify can't handle signed only messages. */
1837             err = (gpgme_data_seek (armored_data, 0, SEEK_SET) == -1)
1838               ? gpgme_error_from_errno (errno) : 0;
1839             /* Must release plaintext so that we supply an
1840                uninitialized object. */
1841             gpgme_data_release (plaintext);
1842             plaintext = create_gpgme_data ();
1843             err = gpgme_op_verify (ctx, armored_data, NULL, plaintext);
1844           }
1845         }
1846
1847         if (err) {
1848           char errbuf[200];
1849
1850           snprintf (errbuf, sizeof (errbuf) - 1,
1851                     _("Error: decryption/verification failed: %s\n"),
1852                     gpgme_strerror (err));
1853           state_attach_puts (errbuf, s);
1854         }
1855         else {                  /* Decryption/Verification succeeded */
1856           char *tmpfname;
1857
1858           {
1859             /* Check wether signatures have been verified.  */
1860             gpgme_verify_result_t verify_result;
1861
1862             verify_result = gpgme_op_verify_result (ctx);
1863             if (verify_result->signatures)
1864               sig_stat = 1;
1865           }
1866
1867           have_any_sigs = 0;
1868           maybe_goodsig = 0;
1869           if ((s->flags & M_DISPLAY) && sig_stat) {
1870             int res, idx;
1871             int anybad = 0;
1872             int anywarn = 0;
1873
1874             state_attach_puts (_("[-- Begin signature "
1875                                  "information --]\n"), s);
1876             have_any_sigs = 1;
1877             for (idx = 0;
1878                  (res = show_one_sig_status (ctx, idx, s)) != -1; idx++) {
1879               if (res == 1)
1880                 anybad = 1;
1881               else if (res == 2)
1882                 anywarn = 1;
1883             }
1884             if (!anybad && idx)
1885               maybe_goodsig = 1;
1886
1887             state_attach_puts (_("[-- End signature "
1888                                  "information --]\n\n"), s);
1889           }
1890
1891           tmpfname = data_object_to_tempfile (plaintext, &pgpout);
1892           if (!tmpfname) {
1893             pgpout = NULL;
1894             state_attach_puts (_("Error: copy data failed\n"), s);
1895           }
1896           else {
1897             unlink (tmpfname);
1898             p_delete(&tmpfname);
1899           }
1900         }
1901         gpgme_release (ctx);
1902       }
1903
1904       /*
1905        * Now, copy cleartext to the screen.  NOTE - we expect that PGP
1906        * outputs utf-8 cleartext.  This may not always be true, but it 
1907        * seems to be a reasonable guess.
1908        */
1909
1910       if (s->flags & M_DISPLAY) {
1911         if (needpass)
1912           state_attach_puts (_("[-- BEGIN PGP MESSAGE --]\n\n"), s);
1913         else if (pgp_keyblock)
1914           state_attach_puts (_("[-- BEGIN PGP PUBLIC KEY BLOCK --]\n"), s);
1915         else
1916           state_attach_puts (_("[-- BEGIN PGP SIGNED MESSAGE --]\n\n"), s);
1917       }
1918
1919       if (clearsign) {
1920         copy_clearsigned (armored_data, s, body_charset);
1921       }
1922       else if (pgpout) {
1923         fgetconv_t *fc;
1924         int c;
1925
1926         rewind (pgpout);
1927         fc = fgetconv_open (pgpout, "utf-8", Charset, 0);
1928         while ((c = fgetconv (fc)) != EOF) {
1929           state_putc (c, s);
1930           if (c == '\n' && s->prefix)
1931             state_puts (s->prefix, s);
1932         }
1933         fgetconv_close (&fc);
1934       }
1935
1936       if (s->flags & M_DISPLAY) {
1937         state_putc ('\n', s);
1938         if (needpass)
1939           state_attach_puts (_("[-- END PGP MESSAGE --]\n"), s);
1940         else if (pgp_keyblock)
1941           state_attach_puts (_("[-- END PGP PUBLIC KEY BLOCK --]\n"), s);
1942         else
1943           state_attach_puts (_("[-- END PGP SIGNED MESSAGE --]\n"), s);
1944       }
1945
1946       if (pgpout) {
1947         m_fclose(&pgpout);
1948       }
1949     }
1950     else {
1951       /* XXX - we may wish to recode here */
1952       if (s->prefix)
1953         state_puts (s->prefix, s);
1954       state_puts (buf, s);
1955     }
1956   }
1957
1958   m->goodsig = (maybe_goodsig && have_any_sigs);
1959
1960   if (needpass == -1) {
1961     state_attach_puts (_("[-- Error: could not find beginning"
1962                          " of PGP message! --]\n\n"), s);
1963     return (-1);
1964   }
1965   return (err);
1966 }
1967
1968 /* 
1969  * Implementation of `encrypted_handler'.
1970  */
1971
1972 /* MIME handler for pgp/mime encrypted messages. */
1973 int pgp_gpgme_encrypted_handler (BODY * a, STATE * s)
1974 {
1975   char tempfile[_POSIX_PATH_MAX];
1976   FILE *fpout;
1977   BODY *tattach;
1978   BODY *orig_body = a;
1979   int is_signed;
1980   int rc = 0;
1981
1982   a = a->parts;
1983   if (!a || a->type != TYPEAPPLICATION || !a->subtype
1984       || ascii_strcasecmp ("pgp-encrypted", a->subtype)
1985       || !a->next || a->next->type != TYPEAPPLICATION || !a->next->subtype
1986       || ascii_strcasecmp ("octet-stream", a->next->subtype)) {
1987     if (s->flags & M_DISPLAY)
1988       state_attach_puts (_("[-- Error: malformed PGP/MIME message! --]\n\n"),
1989                          s);
1990     return (-1);
1991   }
1992
1993   /* Move forward to the application/pgp-encrypted body. */
1994   a = a->next;
1995
1996   fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
1997   if (!fpout) {
1998     if (s->flags & M_DISPLAY)
1999       state_attach_puts (_("[-- Error: could not create temporary file! "
2000                            "--]\n"), s);
2001     return (-1);
2002   }
2003
2004   tattach = decrypt_part (a, s, fpout, 0, &is_signed);
2005   if (tattach) {
2006     tattach->goodsig = is_signed > 0;
2007
2008     if (s->flags & M_DISPLAY)
2009       state_attach_puts (is_signed ?
2010                          _
2011                          ("[-- The following data is PGP/MIME signed and encrypted --]\n\n") :
2012                          _("[-- The following data is PGP/MIME encrypted --]\n\n"), s);
2013
2014     {
2015       FILE *savefp = s->fpin;
2016
2017       s->fpin = fpout;
2018       rc = mutt_body_handler (tattach, s);
2019       s->fpin = savefp;
2020     }
2021
2022     /* 
2023      * if a multipart/signed is the _only_ sub-part of a
2024      * multipart/encrypted, cache signature verification
2025      * status.
2026      */
2027     if (mutt_is_multipart_signed (tattach) && !tattach->next)
2028       orig_body->goodsig |= tattach->goodsig;
2029
2030     if (s->flags & M_DISPLAY) {
2031       state_puts ("\n", s);
2032       state_attach_puts (is_signed ?
2033                          _
2034                          ("[-- End of PGP/MIME signed and encrypted data --]\n")
2035                          : _("[-- End of PGP/MIME encrypted data --]\n"), s);
2036     }
2037
2038     body_list_wipe(&tattach);
2039   }
2040
2041   m_fclose(&fpout);
2042   mutt_unlink (tempfile);
2043   return (rc);
2044 }
2045
2046 /* Support for application/smime */
2047 int smime_gpgme_application_handler (BODY * a, STATE * s)
2048 {
2049   char tempfile[_POSIX_PATH_MAX];
2050   FILE *fpout;
2051   BODY *tattach;
2052   int is_signed;
2053   int rc = 0;
2054
2055   a->warnsig = 0;
2056   fpout = m_tempfile(tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
2057   if (!fpout) {
2058     if (s->flags & M_DISPLAY)
2059       state_attach_puts (_("[-- Error: could not create temporary file! "
2060                            "--]\n"), s);
2061     return (-1);
2062   }
2063
2064   tattach = decrypt_part (a, s, fpout, 1, &is_signed);
2065   if (tattach) {
2066     tattach->goodsig = is_signed > 0;
2067
2068     if (s->flags & M_DISPLAY)
2069       state_attach_puts (is_signed ?
2070                          _("[-- The following data is S/MIME signed --]\n\n") :
2071                          _("[-- The following data is S/MIME encrypted --]\n\n"), s);
2072
2073     {
2074       FILE *savefp = s->fpin;
2075
2076       s->fpin = fpout;
2077       rc = mutt_body_handler (tattach, s);
2078       s->fpin = savefp;
2079     }
2080
2081     /* 
2082      * if a multipart/signed is the _only_ sub-part of a
2083      * multipart/encrypted, cache signature verification
2084      * status.
2085      */
2086     if (mutt_is_multipart_signed (tattach) && !tattach->next) {
2087       if (!(a->goodsig = tattach->goodsig))
2088         a->warnsig = tattach->warnsig;
2089     }
2090     else if (tattach->goodsig) {
2091       a->goodsig = 1;
2092       a->warnsig = tattach->warnsig;
2093     }
2094
2095     if (s->flags & M_DISPLAY) {
2096       state_puts ("\n", s);
2097       state_attach_puts (is_signed ?
2098                          _("[-- End of S/MIME signed data --]\n") :
2099                          _("[-- End of S/MIME encrypted data --]\n"), s);
2100     }
2101
2102     body_list_wipe(&tattach);
2103   }
2104
2105   m_fclose(&fpout);
2106   mutt_unlink (tempfile);
2107   return (rc);
2108 }
2109
2110
2111 /*
2112  * Format an entry on the CRYPT key selection menu.
2113  * 
2114  * %n   number
2115  * %k   key id          %K      key id of the principal key
2116  * %u   user id
2117  * %a   algorithm       %A      algorithm of the princ. key
2118  * %l   length          %L      length of the princ. key
2119  * %f   flags           %F      flags of the princ. key
2120  * %c   capabilities    %C      capabilities of the princ. key
2121  * %t   trust/validity of the key-uid association
2122  * %p           protocol
2123  * %[...] date of key using strftime(3)
2124  */
2125
2126 static const char *
2127 crypt_entry_fmt (char *dest, ssize_t destlen, char op,
2128                  const char *src, const char *prefix,
2129                  const char *ifstring, const char *elsestring,
2130                  unsigned long data, format_flag flags)
2131 {
2132   char fmt[16];
2133   crypt_entry_t *entry;
2134   crypt_key_t *key;
2135   int kflags = 0;
2136   int optional = (flags & M_FORMAT_OPTIONAL);
2137   const char *s = NULL;
2138   unsigned long val;
2139
2140   entry = (crypt_entry_t *) data;
2141   key = entry->key;
2142
2143 /*    if (isupper ((unsigned char) op)) */
2144 /*      key = pkey; */
2145
2146   kflags = (key->flags          /*| (pkey->flags & KEYFLAG_RESTRICTIONS)
2147                                    | uid->flags */ );
2148
2149   switch (ascii_tolower (op)) {
2150   case '[':
2151     {
2152       const char *cp;
2153       char buf2[STRING], *p;
2154       int do_locales;
2155       struct tm *tm;
2156       ssize_t len;
2157
2158       p = dest;
2159
2160       cp = src;
2161       if (*cp == '!') {
2162         do_locales = 0;
2163         cp++;
2164       }
2165       else
2166         do_locales = 1;
2167
2168       len = destlen - 1;
2169       while (len > 0 && *cp != ']') {
2170         if (*cp == '%') {
2171           cp++;
2172           if (len >= 2) {
2173             *p++ = '%';
2174             *p++ = *cp;
2175             len -= 2;
2176           }
2177           else
2178             break;              /* not enough space */
2179           cp++;
2180         }
2181         else {
2182           *p++ = *cp++;
2183           len--;
2184         }
2185       }
2186       *p = 0;
2187
2188       if (do_locales && Locale)
2189         setlocale (LC_TIME, Locale);
2190
2191       {
2192         time_t tt = 0;
2193
2194         if (key->kobj->subkeys && (key->kobj->subkeys->timestamp > 0))
2195           tt = key->kobj->subkeys->timestamp;
2196
2197         tm = localtime (&tt);
2198       }
2199       strftime (buf2, sizeof (buf2), dest, tm);
2200
2201       if (do_locales)
2202         setlocale (LC_TIME, "C");
2203
2204       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2205       snprintf (dest, destlen, fmt, buf2);
2206       if (len > 0)
2207         src = cp + 1;
2208     }
2209     break;
2210   case 'n':
2211     if (!optional) {
2212       snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
2213       snprintf (dest, destlen, fmt, entry->num);
2214     }
2215     break;
2216   case 'k':
2217     if (!optional) {
2218       /* fixme: we need a way to distinguish between main and subkeys.
2219          Store the idx in entry? */
2220       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2221       snprintf (dest, destlen, fmt, crypt_keyid (key));
2222     }
2223     break;
2224   case 'u':
2225     if (!optional) {
2226       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2227       snprintf (dest, destlen, fmt, key->uid);
2228     }
2229     break;
2230   case 'a':
2231     if (!optional) {
2232       snprintf (fmt, sizeof (fmt), "%%%s.3s", prefix);
2233       if (key->kobj->subkeys)
2234         s = gpgme_pubkey_algo_name (key->kobj->subkeys->pubkey_algo);
2235       else
2236         s = "?";
2237       snprintf (dest, destlen, fmt, s);
2238     }
2239     break;
2240   case 'l':
2241     if (!optional) {
2242       snprintf (fmt, sizeof (fmt), "%%%slu", prefix);
2243       if (key->kobj->subkeys)
2244         val = key->kobj->subkeys->length;
2245       else
2246         val = 0;
2247       snprintf (dest, destlen, fmt, val);
2248     }
2249     break;
2250   case 'f':
2251     if (!optional) {
2252       snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
2253       snprintf (dest, destlen, fmt, crypt_flags (kflags));
2254     }
2255     else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
2256       optional = 0;
2257     break;
2258   case 'c':
2259     if (!optional) {
2260       snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2261       snprintf (dest, destlen, fmt, crypt_key_abilities (kflags));
2262     }
2263     else if (!(kflags & (KEYFLAG_ABILITIES)))
2264       optional = 0;
2265     break;
2266   case 't':
2267     if ((kflags & KEYFLAG_ISX509))
2268       s = "x";
2269     else {
2270       gpgme_user_id_t uid = NULL;
2271       int i = 0;
2272
2273       for (i = 0, uid = key->kobj->uids; uid && (i < key->idx);
2274            i++, uid = uid->next);
2275       if (uid)
2276         switch (uid->validity) {
2277         case GPGME_VALIDITY_UNDEFINED:
2278           s = "q";
2279           break;
2280         case GPGME_VALIDITY_NEVER:
2281           s = "n";
2282           break;
2283         case GPGME_VALIDITY_MARGINAL:
2284           s = "m";
2285           break;
2286         case GPGME_VALIDITY_FULL:
2287           s = "f";
2288           break;
2289         case GPGME_VALIDITY_ULTIMATE:
2290           s = "u";
2291           break;
2292         case GPGME_VALIDITY_UNKNOWN:
2293         default:
2294           s = "?";
2295           break;
2296         }
2297     }
2298     snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
2299     snprintf (dest, destlen, fmt, s ? *s : 'B');
2300     break;
2301   case 'p':
2302     snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
2303     snprintf (dest, destlen, fmt,
2304               gpgme_get_protocol_name (key->kobj->protocol));
2305     break;
2306
2307   default:
2308     *dest = '\0';
2309   }
2310
2311   if (optional)
2312     m_strformat (dest, destlen, ifstring, mutt_attach_fmt, data, 0);
2313   else if (flags & M_FORMAT_OPTIONAL)
2314     m_strformat (dest, destlen, elsestring, mutt_attach_fmt, data, 0);
2315   return (src);
2316 }
2317
2318 /* Used by the display fucntion to format a line. */
2319 static void crypt_entry (char *s, ssize_t l, MUTTMENU * menu, int num)
2320 {
2321   crypt_key_t **key_table = (crypt_key_t **) menu->data;
2322   crypt_entry_t entry;
2323
2324   entry.key = key_table[num];
2325   entry.num = num + 1;
2326
2327   m_strformat (s, l, NONULL (PgpEntryFormat), crypt_entry_fmt,
2328                      (unsigned long) &entry, M_FORMAT_ARROWCURSOR);
2329 }
2330
2331 /* Compare two addresses and the keyid to be used for sorting. */
2332 static int _crypt_compare_address (const void *a, const void *b)
2333 {
2334   crypt_key_t **s = (crypt_key_t **) a;
2335   crypt_key_t **t = (crypt_key_t **) b;
2336   int r;
2337
2338   if ((r = m_strcasecmp((*s)->uid, (*t)->uid)))
2339     return r > 0;
2340   else
2341     return m_strcasecmp(crypt_keyid (*s), crypt_keyid (*t)) > 0;
2342 }
2343
2344 static int crypt_compare_address (const void *a, const void *b)
2345 {
2346   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_address (a, b)
2347           : _crypt_compare_address (a, b));
2348 }
2349
2350
2351 /* Compare two key IDs and the addresses to be used for sorting. */
2352 static int _crypt_compare_keyid (const void *a, const void *b)
2353 {
2354   crypt_key_t **s = (crypt_key_t **) a;
2355   crypt_key_t **t = (crypt_key_t **) b;
2356   int r;
2357
2358   if ((r = m_strcasecmp(crypt_keyid (*s), crypt_keyid (*t))))
2359     return r > 0;
2360   else
2361     return m_strcasecmp((*s)->uid, (*t)->uid) > 0;
2362 }
2363
2364 static int crypt_compare_keyid (const void *a, const void *b)
2365 {
2366   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_keyid (a, b)
2367           : _crypt_compare_keyid (a, b));
2368 }
2369
2370 /* Compare 2 creation dates and the addresses.  For sorting. */
2371 static int _crypt_compare_date (const void *a, const void *b)
2372 {
2373   crypt_key_t **s = (crypt_key_t **) a;
2374   crypt_key_t **t = (crypt_key_t **) b;
2375   unsigned long ts = 0, tt = 0;
2376
2377   if ((*s)->kobj->subkeys && ((*s)->kobj->subkeys->timestamp > 0))
2378     ts = (*s)->kobj->subkeys->timestamp;
2379   if ((*t)->kobj->subkeys && ((*t)->kobj->subkeys->timestamp > 0))
2380     tt = (*t)->kobj->subkeys->timestamp;
2381
2382   if (ts > tt)
2383     return 1;
2384   if (ts < tt)
2385     return 0;
2386
2387   return m_strcasecmp((*s)->uid, (*t)->uid) > 0;
2388 }
2389
2390 static int crypt_compare_date (const void *a, const void *b)
2391 {
2392   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_date (a, b)
2393           : _crypt_compare_date (a, b));
2394 }
2395
2396 /* Compare two trust values, the key length, the creation dates. the
2397    addresses and the key IDs.  For sorting. */
2398 static int _crypt_compare_trust (const void *a, const void *b)
2399 {
2400   crypt_key_t **s = (crypt_key_t **) a;
2401   crypt_key_t **t = (crypt_key_t **) b;
2402   unsigned long ts = 0, tt = 0;
2403   int r;
2404
2405   if ((r = (((*s)->flags & (KEYFLAG_RESTRICTIONS))
2406             - ((*t)->flags & (KEYFLAG_RESTRICTIONS)))))
2407     return r > 0;
2408
2409   if ((*s)->kobj->uids)
2410     ts = (*s)->kobj->uids->validity;
2411   if ((*t)->kobj->uids)
2412     tt = (*t)->kobj->uids->validity;
2413   if ((r = (tt - ts)))
2414     return r < 0;
2415
2416   if ((*s)->kobj->subkeys)
2417     ts = (*s)->kobj->subkeys->length;
2418   if ((*t)->kobj->subkeys)
2419     tt = (*t)->kobj->subkeys->length;
2420   if (ts != tt)
2421     return ts > tt;
2422
2423   if ((*s)->kobj->subkeys && ((*s)->kobj->subkeys->timestamp > 0))
2424     ts = (*s)->kobj->subkeys->timestamp;
2425   if ((*t)->kobj->subkeys && ((*t)->kobj->subkeys->timestamp > 0))
2426     tt = (*t)->kobj->subkeys->timestamp;
2427   if (ts > tt)
2428     return 1;
2429   if (ts < tt)
2430     return 0;
2431
2432   if ((r = m_strcasecmp((*s)->uid, (*t)->uid)))
2433     return r > 0;
2434   return (m_strcasecmp(crypt_keyid ((*s)), crypt_keyid ((*t)))) > 0;
2435 }
2436
2437 static int crypt_compare_trust (const void *a, const void *b)
2438 {
2439   return ((PgpSortKeys & SORT_REVERSE) ? !_crypt_compare_trust (a, b)
2440           : _crypt_compare_trust (a, b));
2441 }
2442
2443 /* Print the X.500 Distinguished Name part KEY from the array of parts
2444    DN to FP. */
2445 static int print_dn_part (FILE * fp, struct dn_array_s *dn, const char *key)
2446 {
2447   int any = 0;
2448
2449   for (; dn->key; dn++) {
2450     if (!m_strcmp(dn->key, key)) {
2451       if (any)
2452         fputs (" + ", fp);
2453       print_utf8 (fp, dn->value, m_strlen(dn->value));
2454       any = 1;
2455     }
2456   }
2457   return any;
2458 }
2459
2460 /* Print all parts of a DN in a standard sequence. */
2461 static void print_dn_parts (FILE * fp, struct dn_array_s *dn)
2462 {
2463   const char *stdpart[] = {
2464     "CN", "OU", "O", "STREET", "L", "ST", "C", NULL
2465   };
2466   int any = 0, any2 = 0, i;
2467
2468   for (i = 0; stdpart[i]; i++) {
2469     if (any)
2470       fputs (", ", fp);
2471     any = print_dn_part (fp, dn, stdpart[i]);
2472   }
2473   /* now print the rest without any specific ordering */
2474   for (; dn->key; dn++) {
2475     for (i = 0; stdpart[i]; i++) {
2476       if (!m_strcmp(dn->key, stdpart[i]))
2477         break;
2478     }
2479     if (!stdpart[i]) {
2480       if (any)
2481         fputs (", ", fp);
2482       if (!any2)
2483         fputs ("(", fp);
2484       any = print_dn_part (fp, dn, dn->key);
2485       any2 = 1;
2486     }
2487   }
2488   if (any2)
2489     fputs (")", fp);
2490 }
2491
2492
2493 /* Parse an RDN; this is a helper to parse_dn(). */
2494 static const unsigned char *parse_dn_part (struct dn_array_s *array,
2495                                            const unsigned char *string)
2496 {
2497   const unsigned char *s, *s1;
2498   ssize_t n;
2499   unsigned char *p;
2500
2501   /* parse attributeType */
2502   for (s = string + 1; *s && *s != '='; s++);
2503   if (!*s)
2504     return NULL;                /* error */
2505   n = s - string;
2506   if (!n)
2507     return NULL;                /* empty key */
2508   array->key = p_dupstr(string, n );
2509   p = (unsigned char *) array->key;
2510   string = s + 1;
2511
2512   if (*string == '#') {         /* hexstring */
2513     string++;
2514     for (s = string; hexdigitp (s); s++)
2515       s++;
2516     n = s - string;
2517     if (!n || (n & 1))
2518       return NULL;              /* empty or odd number of digits */
2519     n /= 2;
2520     p = xmalloc(n + 1);
2521     array->value = (char *) p;
2522     for (s1 = string; n; s1 += 2, n--)
2523       *p++ = xtoi_2 (s1);
2524     *p = 0;
2525   }
2526   else {                        /* regular v3 quoted string */
2527     for (n = 0, s = string; *s; s++) {
2528       if (*s == '\\') {         /* pair */
2529         s++;
2530         if (*s == ',' || *s == '=' || *s == '+'
2531             || *s == '<' || *s == '>' || *s == '#' || *s == ';'
2532             || *s == '\\' || *s == '\"' || *s == ' ')
2533           n++;
2534         else if (hexdigitp (s) && hexdigitp (s + 1)) {
2535           s++;
2536           n++;
2537         }
2538         else
2539           return NULL;          /* invalid escape sequence */
2540       }
2541       else if (*s == '\"')
2542         return NULL;            /* invalid encoding */
2543       else if (*s == ',' || *s == '=' || *s == '+'
2544                || *s == '<' || *s == '>' || *s == '#' || *s == ';')
2545         break;
2546       else
2547         n++;
2548     }
2549
2550     p = xmalloc(n + 1);
2551     array->value = (char *) p;
2552     for (s = string; n; s++, n--) {
2553       if (*s == '\\') {
2554         s++;
2555         if (hexdigitp (s)) {
2556           *p++ = xtoi_2 (s);
2557           s++;
2558         }
2559         else
2560           *p++ = *s;
2561       }
2562       else
2563         *p++ = *s;
2564     }
2565     *p = 0;
2566   }
2567   return s;
2568 }
2569
2570
2571 /* Parse a DN and return an array-ized one.  This is not a validating
2572    parser and it does not support any old-stylish syntax; gpgme is
2573    expected to return only rfc2253 compatible strings. */
2574 static struct dn_array_s *parse_dn (const unsigned char *string)
2575 {
2576   struct dn_array_s *array;
2577   ssize_t arrayidx, arraysize;
2578   int i;
2579
2580   arraysize = 7;                /* C,ST,L,O,OU,CN,email */
2581   array = p_new(struct dn_array_s, arraysize + 1);
2582   arrayidx = 0;
2583   while (*string) {
2584     while (*string == ' ')
2585       string++;
2586     if (!*string)
2587       break;                    /* ready */
2588     if (arrayidx >= arraysize) {        /* mutt lacks a real safe_realoc - so we need to copy */
2589       struct dn_array_s *a2;
2590
2591       arraysize += 5;
2592       a2 = p_new(struct dn_array_s, arraysize + 1);
2593       for (i = 0; i < arrayidx; i++) {
2594         a2[i].key = array[i].key;
2595         a2[i].value = array[i].value;
2596       }
2597       p_delete(&array);
2598       array = a2;
2599     }
2600     array[arrayidx].key = NULL;
2601     array[arrayidx].value = NULL;
2602     string = parse_dn_part (array + arrayidx, string);
2603     arrayidx++;
2604     if (!string)
2605       goto failure;
2606     while (*string == ' ')
2607       string++;
2608     if (*string && *string != ',' && *string != ';' && *string != '+')
2609       goto failure;             /* invalid delimiter */
2610     if (*string)
2611       string++;
2612   }
2613   array[arrayidx].key = NULL;
2614   array[arrayidx].value = NULL;
2615   return array;
2616
2617 failure:
2618   for (i = 0; i < arrayidx; i++) {
2619     p_delete(&array[i].key);
2620     p_delete(&array[i].value);
2621   }
2622   p_delete(&array);
2623   return NULL;
2624 }
2625
2626
2627 /* Print a nice representation of the USERID and make sure it is
2628    displayed in a proper way, which does mean to reorder some parts
2629    for S/MIME's DNs.  USERID is a string as returned by the gpgme key
2630    functions.  It is utf-8 encoded. */
2631 static void parse_and_print_user_id (FILE * fp, const char *userid)
2632 {
2633   const char *s;
2634   int i;
2635
2636   if (*userid == '<') {
2637     s = strchr (userid + 1, '>');
2638     if (s)
2639       print_utf8 (fp, userid + 1, s - userid - 1);
2640   }
2641   else if (*userid == '(')
2642     fputs (_("[Can't display this user ID (unknown encoding)]"), fp);
2643   else if (!digit_or_letter ((const unsigned char *) userid))
2644     fputs (_("[Can't display this user ID (invalid encoding)]"), fp);
2645   else {
2646     struct dn_array_s *dn = parse_dn ((const unsigned char *) userid);
2647
2648     if (!dn)
2649       fputs (_("[Can't display this user ID (invalid DN)]"), fp);
2650     else {
2651       print_dn_parts (fp, dn);
2652       for (i = 0; dn[i].key; i++) {
2653         p_delete(&dn[i].key);
2654         p_delete(&dn[i].value);
2655       }
2656       p_delete(&dn);
2657     }
2658   }
2659 }
2660
2661 typedef enum {
2662   KEY_CAP_CAN_ENCRYPT,
2663   KEY_CAP_CAN_SIGN,
2664   KEY_CAP_CAN_CERTIFY
2665 } key_cap_t;
2666
2667 static unsigned int key_check_cap (gpgme_key_t key, key_cap_t cap)
2668 {
2669   gpgme_subkey_t subkey = NULL;
2670   unsigned int ret = 0;
2671
2672   switch (cap) {
2673   case KEY_CAP_CAN_ENCRYPT:
2674     if (!(ret = key->can_encrypt))
2675       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2676         if ((ret = subkey->can_encrypt))
2677           break;
2678     break;
2679   case KEY_CAP_CAN_SIGN:
2680     if (!(ret = key->can_sign))
2681       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2682         if ((ret = subkey->can_sign))
2683           break;
2684     break;
2685   case KEY_CAP_CAN_CERTIFY:
2686     if (!(ret = key->can_certify))
2687       for (subkey = key->subkeys; subkey; subkey = subkey->next)
2688         if ((ret = subkey->can_certify))
2689           break;
2690     break;
2691   }
2692
2693   return ret;
2694 }
2695
2696
2697 /* Print verbose information about a key or certificate to FP. */
2698 static void print_key_info (gpgme_key_t key, FILE * fp)
2699 {
2700   int idx;
2701   const char *s = NULL, *s2 = NULL;
2702   time_t tt = 0;
2703   struct tm *tm;
2704   char shortbuf[STRING];
2705   unsigned long aval = 0;
2706   const char *delim;
2707   int is_pgp = 0;
2708   int i;
2709   gpgme_user_id_t uid = NULL;
2710
2711   if (Locale)
2712     setlocale (LC_TIME, Locale);
2713
2714   is_pgp = key->protocol == GPGME_PROTOCOL_OpenPGP;
2715
2716   for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
2717     if (uid->revoked)
2718       continue;
2719
2720     s = uid->uid;
2721     fputs (idx ? _(" aka ......: ") :_("Name ......: "), fp);
2722
2723     if (uid->invalid) {
2724       fputs (_("[Invalid]"), fp);
2725       putc (' ', fp);
2726     }
2727     if (is_pgp)
2728       print_utf8 (fp, s, m_strlen(s));
2729     else
2730       parse_and_print_user_id (fp, s);
2731     putc ('\n', fp);
2732   }
2733
2734   if (key->subkeys && (key->subkeys->timestamp > 0)) {
2735     tt = key->subkeys->timestamp;
2736
2737     tm = localtime (&tt);
2738 #ifdef HAVE_LANGINFO_D_T_FMT
2739     strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2740 #else
2741     strftime (shortbuf, sizeof shortbuf, "%c", tm);
2742 #endif
2743     fprintf (fp, _("Valid From : %s\n"), shortbuf);
2744   }
2745
2746   if (key->subkeys && (key->subkeys->expires > 0)) {
2747     tt = key->subkeys->expires;
2748
2749     tm = localtime (&tt);
2750 #ifdef HAVE_LANGINFO_D_T_FMT
2751     strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2752 #else
2753     strftime (shortbuf, sizeof shortbuf, "%c", tm);
2754 #endif
2755     fprintf (fp, _("Valid To ..: %s\n"), shortbuf);
2756   }
2757
2758   if (key->subkeys)
2759     s = gpgme_pubkey_algo_name (key->subkeys->pubkey_algo);
2760   else
2761     s = "?";
2762
2763   s2 = is_pgp ? "PGP" : "X.509";
2764
2765   if (key->subkeys)
2766     aval = key->subkeys->length;
2767
2768   fprintf (fp, _("Key Type ..: %s, %lu bit %s\n"), s2, aval, s);
2769
2770   fprintf (fp, _("Key Usage .: "));
2771   delim = "";
2772
2773   if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT)) {
2774     fprintf (fp, "%s%s", delim, _("encryption"));
2775     delim = _(", ");
2776   }
2777   if (key_check_cap (key, KEY_CAP_CAN_SIGN)) {
2778     fprintf (fp, "%s%s", delim, _("signing"));
2779     delim = _(", ");
2780   }
2781   if (key_check_cap (key, KEY_CAP_CAN_CERTIFY)) {
2782     fprintf (fp, "%s%s", delim, _("certification"));
2783     delim = _(", ");
2784   }
2785   putc ('\n', fp);
2786
2787   if (key->subkeys) {
2788     s = key->subkeys->fpr;
2789     fputs (_("Fingerprint: "), fp);
2790     if (is_pgp && m_strlen(s) == 40) {
2791       for (i = 0; *s && s[1] && s[2] && s[3] && s[4]; s += 4, i++) {
2792         putc (*s, fp);
2793         putc (s[1], fp);
2794         putc (s[2], fp);
2795         putc (s[3], fp);
2796         putc (is_pgp ? ' ' : ':', fp);
2797         if (is_pgp && i == 4)
2798           putc (' ', fp);
2799       }
2800     }
2801     else {
2802       for (i = 0; *s && s[1] && s[2]; s += 2, i++) {
2803         putc (*s, fp);
2804         putc (s[1], fp);
2805         putc (is_pgp ? ' ' : ':', fp);
2806         if (is_pgp && i == 7)
2807           putc (' ', fp);
2808       }
2809     }
2810     fprintf (fp, "%s\n", s);
2811   }
2812
2813   if (key->issuer_serial) {
2814     s = key->issuer_serial;
2815     if (s)
2816       fprintf (fp, _("Serial-No .: 0x%s\n"), s);
2817   }
2818
2819   if (key->issuer_name) {
2820     s = key->issuer_name;
2821     if (s) {
2822       fprintf (fp, _("Issued By .: "));
2823       parse_and_print_user_id (fp, s);
2824       putc ('\n', fp);
2825     }
2826   }
2827
2828   /* For PGP we list all subkeys. */
2829   if (is_pgp) {
2830     gpgme_subkey_t subkey = NULL;
2831
2832     for (idx = 1, subkey = key->subkeys; subkey; idx++, subkey = subkey->next) {
2833       s = subkey->keyid;
2834
2835       putc ('\n', fp);
2836       if (m_strlen(s) == 16)
2837         s += 8;                 /* display only the short keyID */
2838       fprintf (fp, _("Subkey ....: 0x%s"), s);
2839       if (subkey->revoked) {
2840         putc (' ', fp);
2841         fputs (_("[Revoked]"), fp);
2842       }
2843       if (subkey->invalid) {
2844         putc (' ', fp);
2845         fputs (_("[Invalid]"), fp);
2846       }
2847       if (subkey->expired) {
2848         putc (' ', fp);
2849         fputs (_("[Expired]"), fp);
2850       }
2851       if (subkey->disabled) {
2852         putc (' ', fp);
2853         fputs (_("[Disabled]"), fp);
2854       }
2855       putc ('\n', fp);
2856
2857       if (subkey->timestamp > 0) {
2858         tt = subkey->timestamp;
2859
2860         tm = localtime (&tt);
2861 #ifdef HAVE_LANGINFO_D_T_FMT
2862         strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2863 #else
2864         strftime (shortbuf, sizeof shortbuf, "%c", tm);
2865 #endif
2866         fprintf (fp, _("Valid From : %s\n"), shortbuf);
2867       }
2868
2869       if (subkey->expires > 0) {
2870         tt = subkey->expires;
2871
2872         tm = localtime (&tt);
2873 #ifdef HAVE_LANGINFO_D_T_FMT
2874         strftime (shortbuf, sizeof shortbuf, nl_langinfo (D_T_FMT), tm);
2875 #else
2876         strftime (shortbuf, sizeof shortbuf, "%c", tm);
2877 #endif
2878         fprintf (fp, _("Valid To ..: %s\n"), shortbuf);
2879       }
2880
2881       if (subkey)
2882         s = gpgme_pubkey_algo_name (subkey->pubkey_algo);
2883       else
2884         s = "?";
2885
2886       if (subkey)
2887         aval = subkey->length;
2888       else
2889         aval = 0;
2890
2891       fprintf (fp, _("Key Type ..: %s, %lu bit %s\n"), "PGP", aval, s);
2892
2893       fprintf (fp, _("Key Usage .: "));
2894       delim = "";
2895
2896       if (subkey->can_encrypt) {
2897         fprintf (fp, "%s%s", delim, _("encryption"));
2898         delim = _(", ");
2899       }
2900       if (subkey->can_sign) {
2901         fprintf (fp, "%s%s", delim, _("signing"));
2902         delim = _(", ");
2903       }
2904       if (subkey->can_certify) {
2905         fprintf (fp, "%s%s", delim, _("certification"));
2906         delim = _(", ");
2907       }
2908       putc ('\n', fp);
2909     }
2910   }
2911
2912   if (Locale)
2913     setlocale (LC_TIME, "C");
2914 }
2915
2916
2917 /* Show detailed information about the selected key */
2918 static void verify_key (crypt_key_t * key)
2919 {
2920   FILE *fp;
2921   char cmd[LONG_STRING], tempfile[_POSIX_PATH_MAX];
2922   const char *s;
2923   gpgme_ctx_t listctx = NULL;
2924   gpgme_error_t err;
2925   gpgme_key_t k = NULL;
2926   int maxdepth = 100;
2927
2928   fp = m_tempfile (tempfile, sizeof(tempfile), NONULL(Tempdir), NULL);
2929   if (!fp) {
2930     mutt_perror (_("Can't create temporary file"));
2931     return;
2932   }
2933   mutt_message _("Collecting data...");
2934
2935   print_key_info (key->kobj, fp);
2936
2937   err = gpgme_new (&listctx);
2938   if (err) {
2939     fprintf (fp, "Internal error: can't create gpgme context: %s\n",
2940              gpgme_strerror (err));
2941     goto leave;
2942   }
2943   if ((key->flags & KEYFLAG_ISX509))
2944     gpgme_set_protocol (listctx, GPGME_PROTOCOL_CMS);
2945
2946   k = key->kobj;
2947   gpgme_key_ref (k);
2948   while ((s = k->chain_id) && k->subkeys && m_strcmp(s, k->subkeys->fpr)) {
2949     putc ('\n', fp);
2950     err = gpgme_op_keylist_start (listctx, s, 0);
2951     gpgme_key_release (k);
2952     k = NULL;
2953     if (!err)
2954       err = gpgme_op_keylist_next (listctx, &k);
2955     if (err) {
2956       fprintf (fp, _("Error finding issuer key: %s\n"), gpgme_strerror (err));
2957       goto leave;
2958     }
2959     gpgme_op_keylist_end (listctx);
2960
2961     print_key_info (k, fp);
2962     if (!--maxdepth) {
2963       putc ('\n', fp);
2964       fputs (_("Error: certification chain to long - stopping here\n"), fp);
2965       break;
2966     }
2967   }
2968
2969 leave:
2970   gpgme_key_release (k);
2971   gpgme_release (listctx);
2972   m_fclose(&fp);
2973   mutt_clear_error ();
2974   snprintf (cmd, sizeof (cmd), _("Key ID: 0x%s"), crypt_keyid (key));
2975   mutt_do_pager (cmd, tempfile, 0, NULL);
2976 }
2977
2978 /* 
2979  * Implementation of `findkeys'.
2980  */
2981
2982
2983 /* Convert string_list_t into a pattern string suitable to be passed to GPGME.
2984    We need to convert spaces in an item into a '+' and '%' into
2985    "%25". */
2986 static char *list_to_pattern (string_list_t * list)
2987 {
2988   string_list_t *l;
2989   char *pattern, *p;
2990   const char *s;
2991   ssize_t n;
2992
2993   n = 0;
2994   for (l = list; l; l = l->next) {
2995     for (s = l->data; *s; s++) {
2996       if (*s == '%')
2997         n += 2;
2998       n++;
2999     }
3000     n++;                        /* delimiter or end of string */
3001   }
3002   n++;                          /* make sure to allocate at least one byte */
3003   pattern = p = p_new(char, n);
3004   for (l = list; l; l = l->next) {
3005     s = l->data;
3006     if (*s) {
3007       if (l != list)
3008         *p++ = ' ';
3009       for (s = l->data; *s; s++) {
3010         if (*s == '%') {
3011           *p++ = '%';
3012           *p++ = '2';
3013           *p++ = '5';
3014         }
3015         else if (*s == '+') {
3016           *p++ = '%';
3017           *p++ = '2';
3018           *p++ = 'B';
3019         }
3020         else if (*s == ' ')
3021           *p++ = '+';
3022         else
3023           *p++ = *s;
3024       }
3025     }
3026   }
3027   *p = 0;
3028   return pattern;
3029 }
3030
3031 /* Return a list of keys which are candidates for the selection.
3032    Select by looking at the HINTS list. */
3033 static crypt_key_t *get_candidates (string_list_t * hints, unsigned int app,
3034                                     int secret)
3035 {
3036   crypt_key_t *db, *k, **kend;
3037   char *pattern;
3038   gpgme_error_t err;
3039   gpgme_ctx_t ctx;
3040   gpgme_key_t key;
3041   int idx;
3042   gpgme_user_id_t uid = NULL;
3043
3044   pattern = list_to_pattern (hints);
3045   if (!pattern)
3046     return NULL;
3047
3048   err = gpgme_new (&ctx);
3049   if (err) {
3050     mutt_error (_("gpgme_new failed: %s"), gpgme_strerror (err));
3051     p_delete(&pattern);
3052     return NULL;
3053   }
3054
3055   db = NULL;
3056   kend = &db;
3057
3058   if ((app & APPLICATION_PGP)) {
3059     /* Its all a mess.  That old GPGME expects different things
3060        depending on the protocol.  For gpg we don' t need percent
3061        escaped pappert but simple strings passed in an array to the
3062        keylist_ext_start function. */
3063     string_list_t *l;
3064     ssize_t n;
3065     char **patarr;
3066
3067     for (l = hints, n = 0; l; l = l->next) {
3068       if (l->data && *l->data)
3069         n++;
3070     }
3071     if (!n)
3072       goto no_pgphints;
3073
3074     patarr = p_new(char *, n + 1);
3075     for (l = hints, n = 0; l; l = l->next) {
3076       if (l->data && *l->data)
3077         patarr[n++] = m_strdup(l->data);
3078     }
3079     patarr[n] = NULL;
3080     err = gpgme_op_keylist_ext_start (ctx, (const char **) patarr, secret, 0);
3081     for (n = 0; patarr[n]; n++)
3082       p_delete(&patarr[n]);
3083     p_delete(&patarr);
3084     if (err) {
3085       mutt_error (_("gpgme_op_keylist_start failed: %s"), gpgme_strerror (err));
3086       gpgme_release (ctx);
3087       p_delete(&pattern);
3088       return NULL;
3089     }
3090
3091     while (!(err = gpgme_op_keylist_next (ctx, &key))) {
3092       unsigned int flags = 0;
3093
3094       if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT))
3095         flags |= KEYFLAG_CANENCRYPT;
3096       if (key_check_cap (key, KEY_CAP_CAN_SIGN))
3097         flags |= KEYFLAG_CANSIGN;
3098
3099 #if 0                           /* DISABLED code */
3100       if (!flags) {
3101         /* Bug in gpg.  Capabilities are not listed for secret
3102            keys.  Try to deduce them from the algorithm. */
3103
3104         switch (key->subkeys[0].pubkey_algo) {
3105         case GPGME_PK_RSA:
3106           flags |= KEYFLAG_CANENCRYPT;
3107           flags |= KEYFLAG_CANSIGN;
3108           break;
3109         case GPGME_PK_ELG_E:
3110           flags |= KEYFLAG_CANENCRYPT;
3111           break;
3112         case GPGME_PK_DSA:
3113           flags |= KEYFLAG_CANSIGN;
3114           break;
3115         }
3116       }
3117 #endif /* DISABLED code */
3118
3119       for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
3120         k = p_new(crypt_key_t, 1);
3121         k->kobj = key;
3122         k->idx = idx;
3123         k->uid = uid->uid;
3124         k->flags = flags;
3125         *kend = k;
3126         kend = &k->next;
3127       }
3128     }
3129     if (gpg_err_code (err) != GPG_ERR_EOF)
3130       mutt_error (_("gpgme_op_keylist_next failed: %s"), gpgme_strerror (err));
3131     gpgme_op_keylist_end (ctx);
3132   no_pgphints:
3133     ;
3134   }
3135
3136   if ((app & APPLICATION_SMIME)) {
3137     /* and now look for x509 certificates */
3138     gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
3139     err = gpgme_op_keylist_start (ctx, pattern, 0);
3140     if (err) {
3141       mutt_error (_("gpgme_op_keylist_start failed: %s"), gpgme_strerror (err));
3142       gpgme_release (ctx);
3143       p_delete(&pattern);
3144       return NULL;
3145     }
3146
3147     while (!(err = gpgme_op_keylist_next (ctx, &key))) {
3148       unsigned int flags = KEYFLAG_ISX509;
3149
3150       if (key_check_cap (key, KEY_CAP_CAN_ENCRYPT))
3151         flags |= KEYFLAG_CANENCRYPT;
3152       if (key_check_cap (key, KEY_CAP_CAN_SIGN))
3153         flags |= KEYFLAG_CANSIGN;
3154
3155       for (idx = 0, uid = key->uids; uid; idx++, uid = uid->next) {
3156         k = p_new(crypt_key_t, 1);
3157         k->kobj = key;
3158         k->idx = idx;
3159         k->uid = uid->uid;
3160         k->flags = flags;
3161         *kend = k;
3162         kend = &k->next;
3163       }
3164     }
3165     if (gpg_err_code (err) != GPG_ERR_EOF)
3166       mutt_error (_("gpgme_op_keylist_next failed: %s"), gpgme_strerror (err));
3167     gpgme_op_keylist_end (ctx);
3168   }
3169
3170   gpgme_release (ctx);
3171   p_delete(&pattern);
3172   return db;
3173 }
3174
3175 /* Add the string STR to the list HINTS.  This list is later used to
3176    match addresses. */
3177 static string_list_t *crypt_add_string_to_hints (string_list_t * hints, const char *str)
3178 {
3179   char *scratch;
3180   char *t;
3181
3182   if ((scratch = m_strdup(str)) == NULL)
3183     return hints;
3184
3185   for (t = strtok (scratch, " ,.:\"()<>\n"); t;
3186        t = strtok (NULL, " ,.:\"()<>\n")) {
3187     if (m_strlen(t) > 3)
3188       hints = mutt_add_list(hints, t);
3189   }
3190
3191   p_delete(&scratch);
3192   return hints;
3193 }
3194
3195 /* Display a menu to select a key from the array KEYS. FORCED_VALID
3196    will be set to true on return if the user did override the the
3197    key's validity. */
3198 static crypt_key_t *crypt_select_key (crypt_key_t * keys,
3199                                       address_t * p, const char *s,
3200                                       unsigned int app, int *forced_valid)
3201 {
3202   int keymax;
3203   crypt_key_t **key_table;
3204   MUTTMENU *menu;
3205   int i, done = 0;
3206   char helpstr[STRING], buf[LONG_STRING];
3207   crypt_key_t *k;
3208   int (*f) (const void *, const void *);
3209   int menu_to_use = 0;
3210   int unusable = 0;
3211
3212   *forced_valid = 0;
3213
3214   /* build the key table */
3215   keymax = i = 0;
3216   key_table = NULL;
3217   for (k = keys; k; k = k->next) {
3218     if (!option (OPTPGPSHOWUNUSABLE) && (k->flags & KEYFLAG_CANTUSE)) {
3219       unusable = 1;
3220       continue;
3221     }
3222
3223     if (i == keymax) {
3224       keymax += 20;
3225       p_realloc(&key_table, keymax);
3226     }
3227
3228     key_table[i++] = k;
3229   }
3230
3231   if (!i && unusable) {
3232     mutt_error _("All matching keys are marked expired/revoked.");
3233
3234     mutt_sleep (1);
3235     return NULL;
3236   }
3237
3238   switch (PgpSortKeys & SORT_MASK) {
3239   case SORT_DATE:
3240     f = crypt_compare_date;
3241     break;
3242   case SORT_KEYID:
3243     f = crypt_compare_keyid;
3244     break;
3245   case SORT_ADDRESS:
3246     f = crypt_compare_address;
3247     break;
3248   case SORT_TRUST:
3249   default:
3250     f = crypt_compare_trust;
3251     break;
3252   }
3253   qsort (key_table, i, sizeof (crypt_key_t *), f);
3254
3255   if (app & APPLICATION_PGP)
3256     menu_to_use = MENU_KEY_SELECT_PGP;
3257   else if (app & APPLICATION_SMIME)
3258     menu_to_use = MENU_KEY_SELECT_SMIME;
3259
3260   helpstr[0] = 0;
3261   mutt_make_help (buf, sizeof (buf), _("Exit  "), menu_to_use, OP_EXIT);
3262   m_strcat(helpstr, sizeof(helpstr), buf);
3263   mutt_make_help (buf, sizeof (buf), _("Select  "), menu_to_use,
3264                   OP_GENERIC_SELECT_ENTRY);
3265   m_strcat(helpstr, sizeof(helpstr), buf);
3266   mutt_make_help (buf, sizeof (buf), _("Check key  "),
3267                   menu_to_use, OP_VERIFY_KEY);
3268   m_strcat(helpstr, sizeof(helpstr), buf);
3269   mutt_make_help (buf, sizeof (buf), _("Help"), menu_to_use, OP_HELP);
3270   m_strcat(helpstr, sizeof(helpstr), buf);
3271
3272   menu = mutt_new_menu ();
3273   menu->max = i;
3274   menu->make_entry = crypt_entry;
3275   menu->menu = menu_to_use;
3276   menu->help = helpstr;
3277   menu->data = key_table;
3278
3279   {
3280     const char *ts;
3281
3282     if ((app & APPLICATION_PGP) && (app & APPLICATION_SMIME))
3283       ts = _("PGP and S/MIME keys matching");
3284     else if ((app & APPLICATION_PGP))
3285       ts = _("PGP keys matching");
3286     else if ((app & APPLICATION_SMIME))
3287       ts = _("S/MIME keys matching");
3288     else
3289       ts = _("keys matching");
3290
3291     if (p)
3292       snprintf (buf, sizeof (buf), _("%s <%s>."), ts, p->mailbox);
3293     else
3294       snprintf (buf, sizeof (buf), _("%s \"%s\"."), ts, s);
3295     menu->title = buf;
3296   }
3297
3298   mutt_clear_error ();
3299   k = NULL;
3300   while (!done) {
3301     *forced_valid = 0;
3302     switch (mutt_menuLoop (menu)) {
3303     case OP_VERIFY_KEY:
3304       verify_key (key_table[menu->current]);
3305       menu->redraw = REDRAW_FULL;
3306       break;
3307
3308     case OP_VIEW_ID:
3309       mutt_message ("%s", key_table[menu->current]->uid);
3310       break;
3311
3312     case OP_GENERIC_SELECT_ENTRY:
3313       /* FIXME make error reporting more verbose - this should be
3314          easy because gpgme provides more information */
3315       if (option (OPTPGPCHECKTRUST)) {
3316         if (!crypt_key_is_valid (key_table[menu->current])) {
3317           mutt_error _("This key can't be used: "
3318                        "expired/disabled/revoked.");
3319           break;
3320         }
3321       }
3322
3323       if (option (OPTPGPCHECKTRUST) &&
3324           (!crypt_id_is_valid (key_table[menu->current])
3325            || !crypt_id_is_strong (key_table[menu->current]))) {
3326         const char *warn_s;
3327         char buff[LONG_STRING];
3328
3329         if (key_table[menu->current]->flags & KEYFLAG_CANTUSE)
3330           s = N_("ID is expired/disabled/revoked.");
3331         else {
3332           gpgme_validity_t val = GPGME_VALIDITY_UNKNOWN;
3333           gpgme_user_id_t uid = NULL;
3334           int j = 0;
3335
3336           warn_s = "??";
3337
3338           uid = key_table[menu->current]->kobj->uids;
3339           for (j = 0; (j < key_table[menu->current]->idx) && uid;
3340                j++, uid = uid->next);
3341           if (uid)
3342             val = uid->validity;
3343
3344           switch (val) {
3345           case GPGME_VALIDITY_UNKNOWN:
3346           case GPGME_VALIDITY_UNDEFINED:
3347             warn_s = N_("ID has undefined validity.");
3348             break;
3349           case GPGME_VALIDITY_NEVER:
3350             warn_s = N_("ID is not valid.");
3351             break;
3352           case GPGME_VALIDITY_MARGINAL:
3353             warn_s = N_("ID is only marginally valid.");
3354             break;
3355           case GPGME_VALIDITY_FULL:
3356           case GPGME_VALIDITY_ULTIMATE:
3357             break;
3358           }
3359
3360           snprintf (buff, sizeof (buff),
3361                     _("%s Do you really want to use the key?"), _(warn_s));
3362
3363           if (mutt_yesorno (buff, 0) != 1) {
3364             mutt_clear_error ();
3365             break;
3366           }
3367           *forced_valid = 1;
3368         }
3369       }
3370
3371       k = crypt_copy_key (key_table[menu->current]);
3372       done = 1;
3373       break;
3374
3375     case OP_EXIT:
3376       k = NULL;
3377       done = 1;
3378       break;
3379     }
3380   }
3381
3382   mutt_menuDestroy (&menu);
3383   p_delete(&key_table);
3384
3385   set_option (OPTNEEDREDRAW);
3386
3387   return k;
3388 }
3389
3390 static crypt_key_t *crypt_getkeybyaddr (address_t * a, short abilities,
3391                                         unsigned int app, int *forced_valid)
3392 {
3393   address_t *r, *p;
3394   string_list_t *hints = NULL;
3395
3396   int weak = 0;
3397   int invalid = 0;
3398   int multi = 0;
3399   int this_key_has_strong;
3400   int this_key_has_weak;
3401   int this_key_has_invalid;
3402   int match;
3403
3404   crypt_key_t *keys, *k;
3405   crypt_key_t *the_valid_key = NULL;
3406   crypt_key_t *matches = NULL;
3407   crypt_key_t **matches_endp = &matches;
3408
3409   *forced_valid = 0;
3410
3411   if (a && a->mailbox)
3412     hints = crypt_add_string_to_hints (hints, a->mailbox);
3413   if (a && a->personal)
3414     hints = crypt_add_string_to_hints (hints, a->personal);
3415
3416   mutt_message (_("Looking for keys matching \"%s\"..."), a->mailbox);
3417   keys = get_candidates (hints, app, (abilities & KEYFLAG_CANSIGN));
3418
3419   string_list_wipe(&hints);
3420
3421   if (!keys)
3422     return NULL;
3423
3424   for (k = keys; k; k = k->next) {
3425     if (abilities && !(k->flags & abilities)) {
3426       continue;
3427     }
3428
3429     this_key_has_weak = 0;      /* weak but valid match   */
3430     this_key_has_invalid = 0;   /* invalid match          */
3431     this_key_has_strong = 0;    /* strong and valid match */
3432     match = 0;                  /* any match            */
3433
3434     r = rfc822_parse_adrlist (NULL, k->uid);
3435     for (p = r; p; p = p->next) {
3436       int validity = crypt_id_matches_addr (a, p, k);
3437
3438       if (validity & CRYPT_KV_MATCH)    /* something matches */
3439         match = 1;
3440
3441       /* is this key a strong candidate? */
3442       if ((validity & CRYPT_KV_VALID)
3443           && (validity & CRYPT_KV_STRONGID)
3444           && (validity & CRYPT_KV_ADDR)) {
3445         if (the_valid_key && the_valid_key != k)
3446           multi = 1;
3447         the_valid_key = k;
3448         this_key_has_strong = 1;
3449       }
3450       else if ((validity & CRYPT_KV_MATCH)
3451                && !(validity & CRYPT_KV_VALID))
3452         this_key_has_invalid = 1;
3453       else if ((validity & CRYPT_KV_MATCH)
3454                && (!(validity & CRYPT_KV_STRONGID)
3455                    || !(validity & CRYPT_KV_ADDR)))
3456         this_key_has_weak = 1;
3457     }
3458     address_list_wipe(&r);
3459
3460     if (match) {
3461       crypt_key_t *tmp;
3462
3463       if (!this_key_has_strong && this_key_has_invalid)
3464         invalid = 1;
3465       if (!this_key_has_strong && this_key_has_weak)
3466         weak = 1;
3467
3468       *matches_endp = tmp = crypt_copy_key (k);
3469       matches_endp = &tmp->next;
3470       the_valid_key = tmp;
3471     }
3472   }
3473
3474   crypt_free_key (&keys);
3475
3476   if (matches) {
3477     if (the_valid_key && !multi && !weak
3478         && !(invalid && option (OPTPGPSHOWUNUSABLE))) {
3479       /* 
3480        * There was precisely one strong match on a valid ID, there
3481        * were no valid keys with weak matches, and we aren't
3482        * interested in seeing invalid keys.
3483        * 
3484        * Proceed without asking the user.
3485        */
3486       k = crypt_copy_key (the_valid_key);
3487     }
3488     else {
3489       /* 
3490        * Else: Ask the user.
3491        */
3492       k = crypt_select_key (matches, a, NULL, app, forced_valid);
3493     }
3494     crypt_free_key (&matches);
3495   }
3496   else
3497     k = NULL;
3498
3499   return k;
3500 }
3501
3502
3503 static crypt_key_t *crypt_getkeybystr (const char *p, short abilities,
3504                                        unsigned int app, int *forced_valid)
3505 {
3506   string_list_t *hints = NULL;
3507   crypt_key_t *keys;
3508   crypt_key_t *matches = NULL;
3509   crypt_key_t **matches_endp = &matches;
3510   crypt_key_t *k;
3511   int match;
3512
3513   mutt_message (_("Looking for keys matching \"%s\"..."), p);
3514
3515   *forced_valid = 0;
3516
3517   hints = crypt_add_string_to_hints (hints, p);
3518   keys = get_candidates (hints, app, (abilities & KEYFLAG_CANSIGN));
3519   string_list_wipe(&hints);
3520
3521   if (!keys)
3522     return NULL;
3523
3524   for (k = keys; k; k = k->next) {
3525     if (abilities && !(k->flags & abilities))
3526       continue;
3527
3528     match = 0;
3529
3530     if (!*p || !m_strcasecmp(p, crypt_keyid (k))
3531         || (!m_strncasecmp(p, "0x", 2)
3532             && !m_strcasecmp(p + 2, crypt_keyid (k)))
3533         || (option (OPTPGPLONGIDS)
3534             && !m_strncasecmp(p, "0x", 2)
3535             && !m_strcasecmp(p + 2, crypt_keyid (k) + 8))
3536         || m_stristr(k->uid, p)) {
3537       crypt_key_t *tmp;
3538
3539       *matches_endp = tmp = crypt_copy_key (k);
3540       matches_endp = &tmp->next;
3541     }
3542   }
3543
3544   crypt_free_key (&keys);
3545
3546   if (matches) {
3547     k = crypt_select_key (matches, NULL, p, app, forced_valid);
3548     crypt_free_key (&matches);
3549     return k;
3550   }
3551
3552   return NULL;
3553 }
3554
3555 /* Display TAG as a prompt to ask for a key.  If WHATFOR is not null
3556    use it as default and store it under that label as the next
3557    default.  ABILITIES describe the required key abilities (sign,
3558    encrypt) and APP the type of the requested key; ether S/MIME or
3559    PGP.  Return a copy of the key or NULL if not found. */
3560 static crypt_key_t *crypt_ask_for_key (char *tag,
3561                                        char *whatfor,
3562                                        short abilities,
3563                                        unsigned int app, int *forced_valid)
3564 {
3565   crypt_key_t *key;
3566   char resp[STRING];
3567   struct crypt_cache *l = NULL;
3568   int dummy;
3569
3570   if (!forced_valid)
3571     forced_valid = &dummy;
3572
3573   mutt_clear_error ();
3574
3575   *forced_valid = 0;
3576   resp[0] = 0;
3577   if (whatfor) {
3578
3579     for (l = id_defaults; l; l = l->next)
3580       if (!m_strcasecmp(whatfor, l->what)) {
3581         m_strcpy(resp, sizeof(resp), NONULL(l->dflt));
3582         break;
3583       }
3584   }
3585
3586
3587   for (;;) {
3588     resp[0] = 0;
3589     if (mutt_get_field (tag, resp, sizeof (resp), M_CLEAR) != 0)
3590       return NULL;
3591
3592     if (whatfor) {
3593       if (l)
3594         m_strreplace(&l->dflt, resp);
3595       else {
3596         l = p_new(struct crypt_cache, 1);
3597         l->next = id_defaults;
3598         id_defaults = l;
3599         l->what = m_strdup(whatfor);
3600         l->dflt = m_strdup(resp);
3601       }
3602     }
3603
3604     if ((key = crypt_getkeybystr (resp, abilities, app, forced_valid)))
3605       return key;
3606
3607     BEEP ();
3608   }
3609   /* not reached */
3610 }
3611
3612 /* This routine attempts to find the keyids of the recipients of a
3613    message.  It returns NULL if any of the keys can not be found.  */
3614 static char *find_keys (address_t * to, address_t * cc, address_t * bcc,
3615                         unsigned int app)
3616 {
3617   char *keylist = NULL, *t;
3618   const char *keyID;
3619   ssize_t keylist_size = 0;
3620   ssize_t keylist_used = 0;
3621   address_t *tmp = NULL, *addr = NULL;
3622   address_t **last = &tmp;
3623   address_t *p, *q;
3624   int i;
3625   crypt_key_t *k_info, *key;
3626   const char *fqdn = mutt_fqdn (1);
3627
3628 #if 0
3629   *r_application = APPLICATION_PGP | APPLICATION_SMIME;
3630 #endif
3631
3632   for (i = 0; i < 3; i++) {
3633     switch (i) {
3634     case 0:
3635       p = to;
3636       break;
3637     case 1:
3638       p = cc;
3639       break;
3640     case 2:
3641       p = bcc;
3642       break;
3643     default:
3644       abort ();
3645     }
3646
3647     *last = address_list_dup (p);
3648     while (*last)
3649       last = &((*last)->next);
3650   }
3651
3652   rfc822_qualify(tmp, fqdn);
3653   address_list_uniq(tmp);
3654
3655   for (p = tmp; p; p = p->next) {
3656     char buf[LONG_STRING];
3657     int forced_valid = 0;
3658
3659     q = p;
3660     k_info = NULL;
3661
3662     if ((keyID = mutt_crypt_hook (p)) != NULL) {
3663       int r;
3664
3665       snprintf (buf, sizeof (buf), _("Use keyID = \"%s\" for %s?"),
3666                 keyID, p->mailbox);
3667       if ((r = mutt_yesorno (buf, M_YES)) == M_YES) {
3668         /* check for e-mail address */
3669         if ((t = strchr (keyID, '@')) &&
3670             (addr = rfc822_parse_adrlist (NULL, keyID))) {
3671           rfc822_qualify(addr, fqdn);
3672           q = addr;
3673         }
3674         else {
3675           k_info = crypt_getkeybystr (keyID, KEYFLAG_CANENCRYPT,
3676                                       app, &forced_valid);
3677         }
3678       }
3679       else if (r == -1) {
3680         p_delete(&keylist);
3681         address_list_wipe(&tmp);
3682         address_list_wipe(&addr);
3683         return NULL;
3684       }
3685     }
3686
3687     if (k_info == NULL
3688         && (k_info = crypt_getkeybyaddr (q, KEYFLAG_CANENCRYPT,
3689                                          app, &forced_valid)) == NULL) {
3690       snprintf (buf, sizeof (buf), _("Enter keyID for %s: "), q->mailbox);
3691
3692       if ((key = crypt_ask_for_key (buf, q->mailbox, KEYFLAG_CANENCRYPT,
3693                                     app,
3694                                     &forced_valid)) == NULL) {
3695         p_delete(&keylist);
3696         address_list_wipe(&tmp);
3697         address_list_wipe(&addr);
3698         return NULL;
3699       }
3700     }
3701     else
3702       key = k_info;
3703
3704     {
3705       const char *s = crypt_fpr (key);
3706
3707       keylist_size += m_strlen(s) + 4 + 1;
3708       p_realloc(&keylist, keylist_size);
3709       sprintf (keylist + keylist_used, "%s0x%s%s",
3710                keylist_used ? " " : "", s, forced_valid ? "!" : "");
3711     }
3712     keylist_used = m_strlen(keylist);
3713
3714     crypt_free_key (&key);
3715     address_list_wipe(&addr);
3716   }
3717   address_list_wipe(&tmp);
3718   return (keylist);
3719 }
3720
3721 char *pgp_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)
3722 {
3723   return find_keys (to, cc, bcc, APPLICATION_PGP);
3724 }
3725
3726 char *smime_gpgme_findkeys (address_t * to, address_t * cc, address_t * bcc)
3727 {
3728   return find_keys (to, cc, bcc, APPLICATION_SMIME);
3729 }
3730
3731 /*
3732  * Implementation of `init'.
3733  */
3734
3735 /* Initialization.  */
3736 static void init_gpgme (void)
3737 {
3738   /* Make sure that gpg-agent is running.  */
3739   if (!getenv ("GPG_AGENT_INFO")) {
3740     mutt_error ("\nUsing GPGME backend, although no gpg-agent is running");
3741     if (mutt_any_key_to_continue (NULL) == -1)
3742       mutt_exit (1);
3743   }
3744 }
3745
3746 void pgp_gpgme_init (void)
3747 {
3748   init_gpgme ();
3749 }
3750
3751 void smime_gpgme_init (void)
3752 {
3753 }
3754
3755 static int gpgme_send_menu (HEADER * msg, int *redraw, int is_smime)
3756 {
3757   crypt_key_t *p;
3758   char input_signas[STRING];
3759   int choice;
3760
3761   if (msg->security & APPLICATION_PGP)
3762     is_smime = 0;
3763   else if (msg->security & APPLICATION_SMIME)
3764     is_smime = 1;
3765
3766   if (is_smime)
3767     choice =
3768       mutt_multi_choice (_
3769                          ("S/MIME (e)ncrypt, (s)ign, sign (a)s, (b)oth, (p)gp or (c)lear?"),
3770                          _("esabpfc"));
3771   else
3772     choice =
3773       mutt_multi_choice (_
3774                          ("PGP (e)ncrypt, (s)ign, sign (a)s, (b)oth, s/(m)ime or (c)lear?"),
3775                          _("esabmfc"));
3776
3777   switch (choice) {
3778   case 1:                      /* (e)ncrypt */
3779     msg->security |= (is_smime ? SMIMEENCRYPT : PGPENCRYPT);