0aa4fd2df835acd8183176ffed5eb763b2a99799
[claws.git] / src / rfc2015.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001 Werner Koch (dd9jn)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #if USE_GPGME
25
26 #include "defs.h"
27
28 #include <glib.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include <locale.h>
32 #include <ctype.h>
33
34 #include <gpgme.h>
35
36 #include "intl.h"
37 #include "procmime.h"
38 #include "procheader.h"
39 #include "base64.h"
40 #include "uuencode.h"
41 #include "unmime.h"
42 #include "codeconv.h"
43 #include "utils.h"
44 #include "prefs_common.h"
45 #include "passphrase.h"
46 #include "select-keys.h"
47 #include "sigstatus.h"
48 #include "rfc2015.h"
49 #include "alertpanel.h"
50
51 #define DIM(v)     (sizeof(v)/sizeof((v)[0]))
52
53 static char *content_names[] = {
54     "Content-Type",
55     "Content-Disposition",
56     "Content-Transfer-Encoding",
57     NULL
58 };
59
60 static char *mime_version_name[] = {
61     "Mime-Version",
62     NULL
63 };
64
65 static void sig_expiration_check        (GString        *str,
66                                          GpgmeCtx        ctx,
67                                          GpgmeKey        key, 
68                                          GpgmeSigStat    status,
69                                          int             idx);
70 static void sig_expired                 (GString        *str,
71                                          GpgmeCtx        ctx,
72                                          int             idx);
73 static void sig_key_expired             (GString        *str,
74                                          GpgmeKey        key,
75                                          int             idx);
76
77 #if 0
78 static void dump_mimeinfo (const char *text, MimeInfo *x)
79 {
80     debug_print ("MimeInfo[%s] %p  level=%d\n",
81                text, x, x? x->level:0 );
82     if (!x)
83         return;
84
85     debug_print ("      enc=`%s' enc_type=%d mime_type=%d\n",
86                x->encoding, x->encoding_type, x->mime_type );
87     debug_print ("      cont_type=`%s' cs=`%s' name=`%s' bnd=`%s'\n",
88                x->content_type, x->charset, x->name, x->boundary );
89     debug_print ("      cont_disp=`%s' fname=`%s' fpos=%ld size=%u, lvl=%d\n",
90                x->content_disposition, x->filename, x->fpos, x->size,
91                x->level );
92     dump_mimeinfo (".main", x->main );
93     dump_mimeinfo (".sub", x->sub );
94     dump_mimeinfo (".next", x->next );
95     debug_print ("MimeInfo[.parent] %p\n", x ); 
96     dump_mimeinfo (".children", x->children );
97     dump_mimeinfo (".plaintext", x->plaintext );
98 }
99
100 static void dump_part ( MimeInfo *mimeinfo, FILE *fp )
101 {
102     unsigned int size = mimeinfo->size;
103     int c;
104
105     if (fseek (fp, mimeinfo->fpos, SEEK_SET)) {
106         debug_print ("dump_part: fseek error\n");
107         return;
108     }
109
110     debug_print ("--- begin dump_part ----\n");
111     while (size-- && (c = getc (fp)) != EOF) 
112         putc (c, stderr);
113     if (ferror (fp))
114         debug_print ("dump_part: read error\n");
115     debug_print ("--- end dump_part ----\n");
116 }
117 #endif
118
119 void
120 rfc2015_secure_remove (const char *fname)
121 {
122     if (!fname)
123         return;
124     /* fixme: overwrite the file first */
125     remove (fname);
126 }
127
128
129 /*
130  * Copy a gpgme data object to a temporary file and
131  * return this filename 
132  */
133 #if 0
134 static char *
135 copy_gpgmedata_to_temp (GpgmeData data, guint *length)
136 {
137     static int id;
138     char *tmp;
139     FILE *fp;
140     char buf[100];
141     size_t nread;
142     GpgmeError err;
143     
144     tmp = g_strdup_printf("%s%cgpgtmp.%08x",
145                           get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id );
146
147     if ((fp = fopen(tmp, "wb")) == NULL) {
148         FILE_OP_ERROR(tmp, "fopen");
149         g_free(tmp);
150         return NULL;
151     }
152
153     err = gpgme_data_rewind ( data );
154     if (err)
155         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
156
157     while (!(err = gpgme_data_read (data, buf, 100, &nread))) {
158         fwrite ( buf, nread, 1, fp );
159     }
160
161     if (err != GPGME_EOF)
162         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
163
164     fclose (fp);
165     *length = nread;
166
167     return tmp;
168 }
169 #endif
170
171 static GpgmeData
172 pgp_decrypt (MimeInfo *partinfo, FILE *fp)
173 {
174     GpgmeCtx ctx = NULL;
175     GpgmeError err;
176     GpgmeData cipher = NULL, plain = NULL;
177     struct passphrase_cb_info_s info;
178
179     memset (&info, 0, sizeof info);
180
181     err = gpgme_new (&ctx);
182     if (err) {
183         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
184         goto leave;
185     }
186
187     err = gpgme_data_new_from_filepart (&cipher, NULL, fp,
188                                         partinfo->offset, partinfo->length);
189     if (err) {
190         debug_print ("gpgme_data_new_from_filepart failed: %s\n",
191                      gpgme_strerror (err));
192         goto leave;
193     }
194
195     err = gpgme_data_new (&plain);
196     if (err) {
197         debug_print ("gpgme_new failed: %s\n", gpgme_strerror (err));
198         goto leave;
199     }
200
201     if (!getenv("GPG_AGENT_INFO")) {
202         info.c = ctx;
203         gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);
204     } 
205
206     err = gpgme_op_decrypt (ctx, cipher, plain);
207
208 leave:
209     gpgme_data_release (cipher);
210     if (err) {
211         gpgmegtk_free_passphrase();
212         debug_print ("decryption failed: %s\n", gpgme_strerror (err));
213         gpgme_data_release (plain);
214         plain = NULL;
215     }
216     else
217         debug_print ("** decryption succeeded\n");
218
219     gpgme_release (ctx);
220     return plain;
221 }
222
223 int rfc2015_is_encrypted (MimeInfo *mimeinfo)
224 {
225     if (!mimeinfo || mimeinfo->type != MIMETYPE_MULTIPART)
226         return 0;
227     if (g_strcasecmp (mimeinfo->subtype, "encrypted"))
228         return 0;
229     /* fixme: we should check the protocol parameter */
230     return 1;
231 }
232
233 gboolean rfc2015_msg_is_encrypted (const gchar *file)
234 {
235         FILE *fp;
236         MimeInfo *mimeinfo;
237         int ret = 0;
238
239 #if 0   /* FIXME */
240         if ((fp = fopen(file, "rb")) == NULL)
241                 return FALSE;
242
243         mimeinfo = procmime_scan_mime_header(fp);
244         if(!mimeinfo) {
245                 fclose(fp);
246                 return FALSE;
247         }
248
249         ret = rfc2015_is_encrypted(mimeinfo);
250         procmime_mimeinfo_free_all(mimeinfo);
251 #endif
252         return ret != 0 ? TRUE : FALSE;
253 }
254
255 static int
256 name_cmp(const char *a, const char *b)
257 {
258     for( ; *a && *b; a++, b++) {
259         if(*a != *b
260            && toupper(*(unsigned char *)a) != toupper(*(unsigned char *)b))
261             return 1;
262     }
263
264     return *a != *b;
265 }
266
267 static int
268 headerp(char *p, char **names)
269 {
270     int i, c;
271     char *p2;
272
273     p2 = strchr(p, ':');
274     if(!p2 || p == p2) {
275         return 0;
276     }
277     if(p2[-1] == ' ' || p2[-1] == '\t') {
278         return 0;
279     }
280
281     if(!names[0])
282         return 1;  
283
284     c = *p2;
285     *p2 = 0;
286     for(i = 0 ; names[i] != NULL; i++) {
287         if(!name_cmp (names[i], p))
288             break;
289     }
290     *p2 = c;
291
292     return names[i] != NULL;
293 }
294
295
296 #define DECRYPTION_ABORT() \
297 { \
298     procmime_mimeinfo_free_all(tmpinfo); \
299     msginfo->decryption_failed = 1; \
300     return; \
301 }
302
303 void rfc2015_decrypt_message (MsgInfo *msginfo, MimeInfo *mimeinfo, FILE *fp)
304 {
305     static int id;
306     MimeInfo *tmpinfo, *partinfo;
307     int ver_ok = 0;
308     char *fname;
309     GpgmeData plain;
310     FILE *dstfp;
311     size_t nread;
312     char buf[BUFFSIZE];
313     int in_cline;
314     GpgmeError err;
315
316     g_return_if_fail (msginfo != NULL);
317     g_return_if_fail (mimeinfo != NULL);
318     g_return_if_fail (fp != NULL);
319     g_return_if_fail (mimeinfo->type == MIMETYPE_MULTIPART);
320
321     debug_print ("** decrypting multipart/encrypted message\n");
322
323 #if 0 /* FIXME */
324
325     /* skip headers */
326     if (fseek(fp, mimeinfo->offset, SEEK_SET) < 0)
327         perror("fseek");
328     tmpinfo = procmime_scan_mime_header(fp);
329     if (!tmpinfo || tmpinfo->type != MIMETYPE_MULTIPART) {
330         DECRYPTION_ABORT();
331     }
332
333     procmime_scan_message(tmpinfo);
334
335     /* check that we have the 2 parts */
336     partinfo = tmpinfo->children;
337     if (!partinfo || !partinfo->next) {
338         DECRYPTION_ABORT();
339     }
340     if ((partinfo->type == MIMETYPE_APPLICATION) && !g_strcasecmp(partinfo->subtype, "pgp-encrypted")) {
341         /* Fixme: check that the version is 1 */
342         ver_ok = 1;
343     }
344     partinfo = partinfo->next;
345     if (ver_ok && (partinfo->type == MIMETYPE_APPLICATION) &&
346         !g_strcasecmp (partinfo->subtype, "octet-stream")) {
347         if (partinfo->next)
348             g_warning ("oops: pgp_encrypted with more than 2 parts");
349     }
350     else {
351         DECRYPTION_ABORT();
352     }
353
354     debug_print ("** yep, it is pgp encrypted\n");
355
356     plain = pgp_decrypt (partinfo, fp);
357     if (!plain) {
358         DECRYPTION_ABORT();
359     }
360
361     fname = g_strdup_printf("%s%cplaintext.%08x",
362                             get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id);
363
364     if ((dstfp = fopen(fname, "wb")) == NULL) {
365         FILE_OP_ERROR(fname, "fopen");
366         g_free(fname);
367         DECRYPTION_ABORT();
368     }
369
370     /* write the orginal header to the new file */
371     if (fseek(fp, tmpinfo->offset, SEEK_SET) < 0)
372         perror("fseek");
373
374     in_cline = 0;
375     while (fgets(buf, sizeof(buf), fp)) {
376         if (headerp (buf, content_names)) {
377             in_cline = 1;
378             continue;
379         }
380         if (in_cline) {
381             if (buf[0] == ' ' || buf[0] == '\t')
382                 continue;
383             in_cline = 0;
384         }
385         if (buf[0] == '\r' || buf[0] == '\n')
386             break;
387         fputs (buf, dstfp);
388     }
389
390     err = gpgme_data_rewind (plain);
391     if (err)
392         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
393
394     while (!(err = gpgme_data_read (plain, buf, sizeof(buf), &nread))) {
395         fwrite (buf, nread, 1, dstfp);
396     }
397
398     if (err != GPGME_EOF) {
399         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
400     }
401
402     fclose (dstfp);
403     procmime_mimeinfo_free_all(tmpinfo);
404
405     msginfo->plaintext_file = fname;
406     msginfo->decryption_failed = 0;
407
408 #endif
409 }
410
411 #undef DECRYPTION_ABORT
412
413
414 /*
415  * plain contains an entire mime object.
416  * Encrypt it and return an GpgmeData object with the encrypted version of
417  * the file or NULL in case of error.
418  */
419 static GpgmeData
420 pgp_encrypt ( GpgmeData plain, GpgmeRecipients rset )
421 {
422     GpgmeCtx ctx = NULL;
423     GpgmeError err;
424     GpgmeData cipher = NULL;
425
426     err = gpgme_new (&ctx);
427     if (!err)
428         err = gpgme_data_new (&cipher);
429     if (!err) {
430         gpgme_set_armor (ctx, 1);
431         err = gpgme_op_encrypt (ctx, rset, plain, cipher);
432     }
433
434     if (err) {
435         debug_print ("encryption failed: %s\n", gpgme_strerror (err));
436         gpgme_data_release (cipher);
437         cipher = NULL;
438     }
439     else {
440         debug_print ("** encryption succeeded\n");
441     }
442
443     gpgme_release (ctx);
444     return cipher;
445 }
446
447 /*
448  * Create and return a list of keys matching a key id
449  */
450
451 GSList *rfc2015_create_signers_list (const char *keyid)
452 {
453         GSList *key_list = NULL;
454         GpgmeCtx list_ctx = NULL;
455         GSList *p;
456         GpgmeError err;
457         GpgmeKey key;
458
459         err = gpgme_new (&list_ctx);
460         if (err)
461                 goto leave;
462         err = gpgme_op_keylist_start (list_ctx, keyid, 1);
463         if (err)
464                 goto leave;
465         while ( !(err = gpgme_op_keylist_next (list_ctx, &key)) ) {
466                 key_list = g_slist_append (key_list, key);
467         }
468         if (err != GPGME_EOF)
469                 goto leave;
470         err = 0;
471         if (key_list == NULL) {
472                 debug_print ("no keys found for keyid \"%s\"\n", keyid);
473         }
474
475 leave:
476         if (err) {
477                 debug_print ("rfc2015_create_signers_list failed: %s\n", gpgme_strerror (err));
478                 for (p = key_list; p != NULL; p = p->next)
479                         gpgme_key_unref ((GpgmeKey) p->data);
480                 g_slist_free (key_list);
481         }
482         if (list_ctx)
483                 gpgme_release (list_ctx);
484         return err ? NULL : key_list;
485 }
486
487 /*
488  * Encrypt the file by extracting all recipients and finding the
489  * encryption keys for all of them.  The file content is then replaced
490  * by the encrypted one.  */
491 int
492 rfc2015_encrypt (const char *file, GSList *recp_list, gboolean ascii_armored)
493 {
494     FILE *fp = NULL;
495     char buf[BUFFSIZE];
496     int i, clineidx, saved_last;
497     char *clines[3] = {NULL};
498     GpgmeError err;
499     GpgmeData header = NULL;
500     GpgmeData plain = NULL;
501     GpgmeData cipher = NULL;
502     GpgmeRecipients rset = NULL;
503     size_t nread;
504     int mime_version_seen = 0;
505     char *boundary;
506
507     boundary = generate_mime_boundary ("Encrypt");
508
509     /* Create the list of recipients */
510     rset = gpgmegtk_recipient_selection (recp_list);
511     if (!rset) {
512         debug_print ("error creating recipient list\n" );
513         goto failure;
514     }
515
516     /* Open the source file */
517     if ((fp = fopen(file, "rb")) == NULL) {
518         FILE_OP_ERROR(file, "fopen");
519         goto failure;
520     }
521
522     err = gpgme_data_new (&header);
523     if (!err)
524         err = gpgme_data_new (&plain);
525     if (err) {
526         debug_print ("gpgme_data_new failed: %s\n", gpgme_strerror (err));
527         goto failure;
528     }
529
530     /* get the content header lines from the source */
531     clineidx = 0;
532     saved_last = 0;
533     while (!err && fgets(buf, sizeof(buf), fp)) {
534         /* fixme: check for overlong lines */
535         if (headerp (buf, content_names)) {
536             if (clineidx >= DIM (clines)) {
537                 debug_print ("rfc2015_encrypt: too many content lines\n");
538                 goto failure;
539             }
540             clines[clineidx++] = g_strdup (buf);
541             saved_last = 1;
542             continue;
543         }
544         if (saved_last) {
545             if (*buf == ' ' || *buf == '\t') {
546                 char *last = clines[clineidx - 1];
547                 clines[clineidx - 1] = g_strconcat (last, buf, NULL);
548                 g_free (last);
549                 continue;
550             }
551             saved_last = 0;
552         }
553
554         if (headerp (buf, mime_version_name)) 
555             mime_version_seen = 1;
556
557         if (buf[0] == '\r' || buf[0] == '\n')
558             break;
559         err = gpgme_data_write (header, buf, strlen (buf));
560     }
561     if (ferror (fp)) {
562         FILE_OP_ERROR (file, "fgets");
563         goto failure;
564     }
565
566     /* write them to the temp data and add the rest of the message */
567     for (i = 0; !err && i < clineidx; i++) {
568         debug_print ("%% %s:%d: cline=`%s'", __FILE__ ,__LINE__, clines[i]);
569         err = gpgme_data_write (plain, clines[i], strlen (clines[i]));
570     }
571     if (!err)
572         err = gpgme_data_write (plain, "\r\n", 2);
573     while (!err && fgets(buf, sizeof(buf), fp)) {
574         err = gpgme_data_write (plain, buf, strlen (buf));
575     }
576     if (ferror (fp)) {
577         FILE_OP_ERROR (file, "fgets");
578         goto failure;
579     }
580     if (err) {
581         debug_print ("gpgme_data_write failed: %s\n", gpgme_strerror (err));
582         goto failure;
583     }
584
585     cipher = pgp_encrypt (plain, rset);
586     gpgme_data_release (plain); plain = NULL;
587     gpgme_recipients_release (rset); rset = NULL;
588     if (!cipher)
589         goto failure;
590
591     /* we have the encrypted message available in cipher and now we
592      * are going to rewrite the source file. To be sure that file has
593      * been truncated we use an approach which should work everywhere:
594      * close the file and then reopen it for writing. It is important
595      * that this works, otherwise it may happen that parts of the
596      * plaintext are still in the file (The encrypted stuff is, due to
597      * compression, usually shorter than the plaintext). 
598      * 
599      * Yes, there is a race condition here, but everyone, who is so
600      * stupid to store the temp file with the plaintext in a public
601      * directory has to live with this anyway. */
602     if (fclose (fp)) {
603         FILE_OP_ERROR(file, "fclose");
604         goto failure;
605     }
606     if ((fp = fopen(file, "wb")) == NULL) {
607         FILE_OP_ERROR(file, "fopen");
608         goto failure;
609     }
610
611     /* Write the header, append new content lines, part 1 and part 2 header */
612     err = gpgme_data_rewind (header);
613     if (err) {
614         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
615         goto failure;
616     }
617     while (!(err = gpgme_data_read (header, buf, BUFFSIZE, &nread))) {
618         fwrite (buf, nread, 1, fp);
619     }
620     if (err != GPGME_EOF) {
621         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
622         goto failure;
623     }
624     if (ferror (fp)) {
625         FILE_OP_ERROR (file, "fwrite");
626         goto failure;
627     }
628     gpgme_data_release (header); header = NULL;
629     
630     if (!mime_version_seen) 
631         fputs ("MIME-Version: 1\r\n", fp);
632
633     if (ascii_armored) {
634         fprintf(fp, 
635             "Content-Type: text/plain; charset=US-ASCII\r\n"
636             "Content-Transfer-Encoding: 7bit\r\n"  
637             "\r\n");
638     } else {
639         fprintf (fp,
640                 "Content-Type: multipart/encrypted;"
641                 " protocol=\"application/pgp-encrypted\";\r\n"
642                 " boundary=\"%s\"\r\n"
643                 "\r\n"
644                 "--%s\r\n"
645                 "Content-Type: application/pgp-encrypted\r\n"
646                 "\r\n"
647                 "Version: 1\r\n"
648                 "\r\n"
649                 "--%s\r\n"
650                 "Content-Type: application/octet-stream\r\n"
651                 "\r\n",
652                 boundary, boundary, boundary);
653     }
654
655     /* append the encrypted stuff */
656     err = gpgme_data_rewind (cipher);
657     if (err) {
658         debug_print ("** gpgme_data_rewind on cipher failed: %s\n",
659                    gpgme_strerror (err));
660         goto failure;
661     }
662
663     while (!(err = gpgme_data_read (cipher, buf, BUFFSIZE, &nread))) {
664         fwrite (buf, nread, 1, fp);
665     }
666     if (err != GPGME_EOF) {
667         debug_print ("** gpgme_data_read failed: %s\n", gpgme_strerror (err));
668         goto failure;
669     }
670
671     /* and the final boundary */
672     if (!ascii_armored) {
673         fprintf (fp,
674                  "\r\n"
675                  "--%s--\r\n",
676                  boundary);
677     }
678     fflush (fp);
679     if (ferror (fp)) {
680         FILE_OP_ERROR (file, "fwrite");
681         goto failure;
682     }
683     fclose (fp);
684     gpgme_data_release (cipher);
685     return 0;
686
687 failure:
688     if (fp) 
689         fclose (fp);
690     gpgme_data_release (header);
691     gpgme_data_release (plain);
692     gpgme_data_release (cipher);
693     gpgme_recipients_release (rset);
694     g_free (boundary);
695     return -1; /* error */
696 }
697
698 /* 
699  * plain contains an entire mime object.  Sign it and return an
700  * GpgmeData object with the signature of it or NULL in case of error.
701  * r_siginfo returns an XML object with information about the signature.
702  */
703 static GpgmeData
704 pgp_sign (GpgmeData plain, GSList *key_list, gboolean clearsign,
705           char **r_siginfo)
706 {
707     GSList *p;
708     GpgmeCtx ctx = NULL;
709     GpgmeError err;
710     GpgmeData sig = NULL;
711     struct passphrase_cb_info_s info;
712
713     *r_siginfo = NULL;
714     memset (&info, 0, sizeof info);
715
716     err = gpgme_new (&ctx);
717     if (err)
718         goto leave;
719     err = gpgme_data_new (&sig);
720     if (err)
721         goto leave;
722
723     if (!getenv("GPG_AGENT_INFO")) {
724         info.c = ctx;
725         gpgme_set_passphrase_cb (ctx, gpgmegtk_passphrase_cb, &info);
726     }
727     gpgme_set_textmode (ctx, 1);
728     gpgme_set_armor (ctx, 1);
729     gpgme_signers_clear (ctx);
730     for (p = key_list; p != NULL; p = p->next) {
731         err = gpgme_signers_add (ctx, (GpgmeKey) p->data);
732         if (err)
733             goto leave;
734     }
735     for (p = key_list; p != NULL; p = p->next)
736         gpgme_key_unref ((GpgmeKey) p->data);
737     g_slist_free (key_list);
738
739     if (err)
740         goto leave;
741     err = gpgme_op_sign
742         (ctx, plain, sig,
743          clearsign ? GPGME_SIG_MODE_CLEAR : GPGME_SIG_MODE_DETACH);
744     if (!err)
745         *r_siginfo = gpgme_get_op_info (ctx, 0);
746
747 leave:
748     if (err) {
749         gpgmegtk_free_passphrase();
750         debug_print ("signing failed: %s\n", gpgme_strerror (err));
751         gpgme_data_release (sig);
752         sig = NULL;
753     }
754     else {
755         debug_print ("signing succeeded\n");
756     }
757
758     gpgme_release (ctx);
759     return sig;
760 }
761
762 /*
763  * Find TAG in XML and return a pointer into xml set just behind the
764  * closing angle.  Return NULL if not found. 
765  */
766 static const char *
767 find_xml_tag (const char *xml, const char *tag)
768 {
769     int taglen = strlen (tag);
770     const char *s = xml;
771  
772     while ( (s = strchr (s, '<')) ) {
773         s++;
774         if (!strncmp (s, tag, taglen)) {
775             const char *s2 = s + taglen;
776             if (*s2 == '>' || isspace (*(const unsigned char*)s2) ) {
777                 /* found */
778                 while (*s2 && *s2 != '>') /* skip attributes */
779                     s2++;
780                 /* fixme: do need to handle angles inside attribute vallues? */
781                 return *s2? (s2+1):NULL;
782             }
783         }
784         while (*s && *s != '>') /* skip to end of tag */
785             s++;
786     }
787     return NULL;
788 }
789
790
791 /*
792  * Extract the micalg from an GnupgOperationInfo XML container.
793  */
794 static char *
795 extract_micalg (char *xml)
796 {
797     const char *s;
798
799     s = find_xml_tag (xml, "GnupgOperationInfo");
800     if (s) {
801         const char *s_end = find_xml_tag (s, "/GnupgOperationInfo");
802         s = find_xml_tag (s, "signature");
803         if (s && s_end && s < s_end) {
804             const char *s_end2 = find_xml_tag (s, "/signature");
805             if (s_end2 && s_end2 < s_end) {
806                 s = find_xml_tag (s, "micalg");
807                 if (s && s < s_end2) {
808                     s_end = strchr (s, '<');
809                     if (s_end) {
810                         char *p = g_malloc (s_end - s + 1);
811                         memcpy (p, s, s_end - s);
812                         p[s_end-s] = 0;
813                         return p;
814                     }
815                 }
816             }
817         }
818     }
819     return NULL;
820 }
821
822
823 /*
824  * Sign the file and replace its content with the signed one.
825  */
826 int
827 rfc2015_sign (const char *file, GSList *key_list)
828 {
829     FILE *fp = NULL;
830     char buf[BUFFSIZE];
831     int i, clineidx, saved_last;
832     char *clines[3] = {NULL};
833     GpgmeError err;
834     GpgmeData header = NULL;
835     GpgmeData plain = NULL;
836     GpgmeData sigdata = NULL;
837     size_t nread;
838     int mime_version_seen = 0;
839     char *boundary;
840     char *micalg = NULL;
841     char *siginfo;
842
843     boundary = generate_mime_boundary ("Signature");
844
845     /* Open the source file */
846     if ((fp = fopen(file, "rb")) == NULL) {
847         FILE_OP_ERROR(file, "fopen");
848         goto failure;
849     }
850
851     err = gpgme_data_new (&header);
852     if (!err)
853         err = gpgme_data_new (&plain);
854     if (err) {
855         debug_print ("gpgme_data_new failed: %s\n", gpgme_strerror (err));
856         goto failure;
857     }
858
859     /* get the content header lines from the source */
860     clineidx = 0;
861     saved_last = 0;
862     while (!err && fgets(buf, sizeof(buf), fp)) {
863         /* fixme: check for overlong lines */
864         if (headerp (buf, content_names)) {
865             if (clineidx >= DIM (clines)) {
866                 debug_print ("rfc2015_sign: too many content lines\n");
867                 goto failure;
868             }
869             clines[clineidx++] = g_strdup (buf);
870             saved_last = 1;
871             continue;
872         }
873         if (saved_last) {
874             if (*buf == ' ' || *buf == '\t') {
875                 char *last = clines[clineidx - 1];
876                 clines[clineidx - 1] = g_strconcat (last, buf, NULL);
877                 g_free (last);
878                 continue;
879             }
880             saved_last = 0;
881         }
882
883         if (headerp (buf, mime_version_name)) 
884             mime_version_seen = 1;
885
886         if (buf[0] == '\r' || buf[0] == '\n')
887             break;
888         err = gpgme_data_write (header, buf, strlen (buf));
889     }
890     if (ferror (fp)) {
891         FILE_OP_ERROR (file, "fgets");
892         goto failure;
893     }
894
895     /* write them to the temp data and add the rest of the message */
896     for (i = 0; !err && i < clineidx; i++) {
897         err = gpgme_data_write (plain, clines[i], strlen (clines[i]));
898     }
899     if (!err)
900         err = gpgme_data_write (plain, "\r\n", 2 );
901     while (!err && fgets(buf, sizeof(buf), fp)) {
902         err = gpgme_data_write (plain, buf, strlen (buf));
903     }
904     if (ferror (fp)) {
905         FILE_OP_ERROR (file, "fgets");
906         goto failure;
907     }
908     if (err) {
909         debug_print ("gpgme_data_write failed: %s\n", gpgme_strerror (err));
910         goto failure;
911     }
912
913     sigdata = pgp_sign (plain, key_list, FALSE, &siginfo); 
914     if (siginfo) {
915         micalg = extract_micalg (siginfo);
916         free (siginfo);
917     }
918     if (!sigdata) 
919         goto failure;
920
921     /* we have the signed message available in sigdata and now we are
922      * going to rewrite the original file. To be sure that file has
923      * been truncated we use an approach which should work everywhere:
924      * close the file and then reopen it for writing. */
925     if (fclose (fp)) {
926         FILE_OP_ERROR(file, "fclose");
927         goto failure;
928     }
929     if ((fp = fopen(file, "wb")) == NULL) {
930         FILE_OP_ERROR(file, "fopen");
931         goto failure;
932     }
933
934     /* Write the rfc822 header and add new content lines */
935     err = gpgme_data_rewind (header);
936     if (err)
937         debug_print ("gpgme_data_rewind failed: %s\n", gpgme_strerror (err));
938     while (!(err = gpgme_data_read (header, buf, BUFFSIZE, &nread))) {
939         fwrite (buf, nread, 1, fp);
940     }
941     if (err != GPGME_EOF) {
942         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
943         goto failure;
944     }
945     if (ferror (fp)) {
946         FILE_OP_ERROR (file, "fwrite");
947         goto failure;
948     }
949     gpgme_data_release (header);
950     header = NULL;
951
952     if (!mime_version_seen) 
953         fputs ("MIME-Version: 1.0\r\n", fp);
954     fprintf (fp, "Content-Type: multipart/signed; "
955              "protocol=\"application/pgp-signature\";\r\n");
956     if (micalg)
957         fprintf (fp, " micalg=\"%s\";\r\n", micalg);
958     fprintf (fp, " boundary=\"%s\"\r\n", boundary);
959
960     /* Part 1: signed material */
961     fprintf (fp, "\r\n"
962                  "--%s\r\n",
963                  boundary);
964     err = gpgme_data_rewind (plain);
965     if (err) {
966         debug_print ("gpgme_data_rewind on plain failed: %s\n",
967                    gpgme_strerror (err));
968         goto failure;
969     }
970     while (!(err = gpgme_data_read (plain, buf, BUFFSIZE, &nread))) {
971         fwrite (buf, nread, 1, fp);   
972     }
973     if (err != GPGME_EOF) {
974         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
975         goto failure;
976     }
977
978     /* Part 2: signature */
979     fprintf (fp, "\r\n"
980                  "--%s\r\n",
981                  boundary);
982     fputs ("Content-Type: application/pgp-signature\r\n"
983            "\r\n", fp);
984
985     err = gpgme_data_rewind (sigdata);
986     if (err) {
987         debug_print ("gpgme_data_rewind on sigdata failed: %s\n",
988                    gpgme_strerror (err));
989         goto failure;
990     }
991
992     while (!(err = gpgme_data_read (sigdata, buf, BUFFSIZE, &nread))) {
993         fwrite (buf, nread, 1, fp);
994     }
995     if (err != GPGME_EOF) {
996         debug_print ("gpgme_data_read failed: %s\n", gpgme_strerror (err));
997         goto failure;
998     }
999
1000     /* Final boundary */
1001     fprintf (fp, "\r\n"
1002                  "--%s--\r\n",
1003                  boundary);
1004     fflush (fp);
1005     if (ferror (fp)) {
1006         FILE_OP_ERROR (file, "fwrite");
1007         goto failure;
1008     }
1009     fclose (fp);
1010     gpgme_data_release (header);
1011     gpgme_data_release (plain);
1012     gpgme_data_release (sigdata);
1013     g_free (boundary);
1014     g_free (micalg);
1015     return 0;
1016
1017 failure:
1018     if (fp) 
1019         fclose (fp);
1020     gpgme_data_release (header);
1021     gpgme_data_release (plain);
1022     gpgme_data_release (sigdata);
1023     g_free (boundary);
1024     g_free (micalg);
1025     return -1; /* error */
1026 }
1027
1028
1029 /*
1030  * Sign the file with clear text and replace its content with the signed one.
1031  */
1032 gint
1033 rfc2015_clearsign (const gchar *file, GSList *key_list)
1034 {
1035     FILE *fp;
1036     gchar buf[BUFFSIZE];
1037     GpgmeError err;
1038     GpgmeData text = NULL;
1039     GpgmeData sigdata = NULL;
1040     size_t nread;
1041     gchar *siginfo;
1042
1043     if ((fp = fopen(file, "rb")) == NULL) {
1044         FILE_OP_ERROR(file, "fopen");
1045         goto failure;
1046     }
1047
1048     err = gpgme_data_new(&text);
1049     if (err) {
1050         debug_print("gpgme_data_new failed: %s\n", gpgme_strerror(err));
1051         goto failure;
1052     }
1053
1054     while (!err && fgets(buf, sizeof(buf), fp)) {
1055         err = gpgme_data_write(text, buf, strlen(buf));
1056     }
1057     if (ferror(fp)) {
1058         FILE_OP_ERROR(file, "fgets");
1059         goto failure;
1060     }
1061     if (err) {
1062         debug_print("gpgme_data_write failed: %s\n", gpgme_strerror(err));
1063         goto failure;
1064     }
1065
1066     sigdata = pgp_sign(text, key_list, TRUE, &siginfo);
1067     if (siginfo) {
1068         g_free(siginfo);
1069     }
1070     if (!sigdata)
1071         goto failure;
1072
1073     if (fclose(fp) == EOF) {
1074         FILE_OP_ERROR(file, "fclose");
1075         fp = NULL;
1076         goto failure;
1077     }
1078     if ((fp = fopen(file, "wb")) == NULL) {
1079         FILE_OP_ERROR(file, "fopen");
1080         goto failure;
1081     }
1082
1083     err = gpgme_data_rewind(sigdata);
1084     if (err) {
1085         debug_print("gpgme_data_rewind on sigdata failed: %s\n",
1086                     gpgme_strerror(err));
1087         goto failure;
1088     }
1089
1090     while (!(err = gpgme_data_read(sigdata, buf, sizeof(buf), &nread))) {
1091         fwrite(buf, nread, 1, fp);
1092     }
1093     if (err != GPGME_EOF) {
1094         debug_print("gpgme_data_read failed: %s\n", gpgme_strerror(err));
1095         goto failure;
1096     }
1097
1098     if (fclose(fp) == EOF) {
1099         FILE_OP_ERROR(file, "fclose");
1100         fp = NULL;
1101         goto failure;
1102     }
1103     gpgme_data_release(text);
1104     gpgme_data_release(sigdata);
1105     return 0;
1106
1107 failure:
1108     if (fp)
1109         fclose(fp);
1110     gpgme_data_release(text);
1111     gpgme_data_release(sigdata);
1112     return -1;
1113 }
1114
1115 #endif /* USE_GPGME */