Initial checkin

Imported from subversion report, converted to git. Updated all paths in
scripts and makefiles, reflecting the new directory hierarchy.

1 files changed, 2235 insertions, 0 deletions

diff --git a/gpglib/gpg.c b/gpglib/gpg.c
new file mode 100644
index 0000000..b63214c
--- /dev/null
+++ b/gpglib/gpg.c
@@ -0,0 +1,2235 @@
+/*
+** Copyright 2001-2011 Double Precision, Inc.  See COPYING for
+** distribution information.
+*/
+
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <unistd.h>
+#include <time.h>
+#if	HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+#include <sys/types.h>
+#if	HAVE_SYS_TIME_H
+#include	<sys/time.h>
+#endif
+#if HAVE_SYS_WAIT_H
+#include	<sys/wait.h>
+#endif
+#ifndef WEXITSTATUS
+#define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
+#endif
+#ifndef WIFEXITED
+#define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
+#endif
+
+#include "mimegpgheader.h"
+#include "mimegpgstack.h"
+#include "mimegpgfork.h"
+#include "tempname.h"
+#include "gpglib.h"
+#include "rfc822/encode.h"
+#include "rfc2045/rfc2045.h"
+
+static int my_rewind(FILE *fp)
+{
+	if (fflush(fp) || ferror(fp) || fseek(fp, 0L, SEEK_SET))
+		return (-1);
+	clearerr(fp);
+	return (0);
+}
+
+int libmail_gpg_inputfunc_readfp(char *buf, size_t cnt, void *vp)
+{
+	FILE *fp=(FILE *)vp;
+	size_t i;
+	int c;
+
+	if (cnt == 0)
+		return -1;
+
+	--cnt;
+
+	for (i=0; i<cnt; i++)
+	{
+		if ((c=getc(fp)) == EOF)
+		{
+			if (i == 0)
+				return -1;
+			break;
+		}
+		buf[i]=c;
+
+		if (c == '\n')
+		{
+			++i;
+			break;
+		}
+	}
+	buf[i]=0;
+	return 0;
+}
+
+void libmail_gpg_noexec(int fd)
+{
+#ifdef FD_CLOEXEC
+	fcntl(fd, F_SETFD, FD_CLOEXEC);
+#endif
+}
+
+/*
+** Check if the line just read is a MIME boundary line.  Search the
+** current MIME stack for a matching MIME boundary delimiter.
+*/
+
+static struct mimestack *is_boundary(struct mimestack *s, const char *line,
+				     int *isclosing)
+{
+	struct mimestack *b;
+
+	if (line[0] != '-' || line[1] != '-' ||
+	    (b=libmail_mimestack_search(s, line+2)) == 0)
+		return (NULL);
+
+
+	*isclosing=strncmp(line+2+strlen(b->boundary), "--", 2) == 0;
+	return (b);
+}
+
+static const char *get_boundary(struct mimestack *,
+				const char *,
+				FILE *);
+
+/*
+** Skip until EOF or a MIME boundary delimiter other than a closing MIME
+** boundary delimiter.  After returning from bind_boundary we expect to
+** see MIME headers.  Copy any intermediate lines to fpout.
+*/
+
+static void find_boundary(struct mimestack **stack, int *iseof,
+			  int (*input_func)(char *, size_t, void *vp),
+			  void *input_func_arg,
+			  void (*output_func)(const char *,
+					      size_t,
+					      void *),
+			  void *output_func_arg,
+			  int doappend)
+{
+	char buf[BUFSIZ];
+
+	for (;;)
+	{
+		int is_closing;
+		struct mimestack *b;
+
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			return;
+		}
+
+		if (!(b=is_boundary(*stack, buf, &is_closing)))
+		{
+			if (output_func)
+				(*output_func)(buf, strlen(buf),
+					       output_func_arg);
+
+			while (strchr(buf, '\n') == 0)
+			{
+				if ( (*input_func)(buf, sizeof(buf),
+						   input_func_arg))
+				{
+					*iseof=1;
+					return;
+				}
+				if (output_func)
+					(*output_func)(buf, strlen(buf),
+						       output_func_arg);
+			}
+			continue;
+		}
+
+		if (output_func)
+		{
+			(*output_func)("--", 2, output_func_arg);
+			(*output_func)(b->boundary, strlen(b->boundary),
+				       output_func_arg);
+
+			if (is_closing)
+				(*output_func)("--", 2, output_func_arg);
+
+			(*output_func)("\n", 1, output_func_arg);
+		}
+
+		if (is_closing)
+		{
+			libmail_mimestack_pop_to(stack, b);
+			continue;
+		}
+		break;
+	}
+}
+
+
+/*
+** Read a set of headers.
+*/
+
+static struct header *read_headers(struct mimestack **stack, int *iseof,
+				   int (*input_func)(char *, size_t, void *vp),
+				   void *input_func_arg,
+				   void (*output_func)(const char *,
+						       size_t,
+						       void *),
+				   void *output_func_arg,
+				   int doappend,
+				   int *errflag)
+{
+	char buf[BUFSIZ];
+	struct read_header_context rhc;
+	struct header *h;
+
+	*errflag=0;
+	libmail_readheader_init(&rhc);
+
+	while (!*iseof)
+	{
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+
+		if (READ_START_OF_LINE(rhc))
+		{
+			struct mimestack *b;
+			int is_closing;
+
+			if (strcmp(buf, "\n") == 0
+			    || strcmp(buf, "\r\n") == 0)
+				break;
+
+			b=is_boundary(*stack, buf, &is_closing);
+
+			if (b)
+			{
+				/*
+				** Corrupted MIME message.  We should NOT
+				** see a MIME boundary in the middle of the
+				** headers!
+				**
+				** Ignore this damage.
+				*/
+
+				struct header *p;
+
+				h=libmail_readheader_finish(&rhc);
+
+				for (p=h; p; p=p->next)
+					(*output_func)(p->header,
+						       strlen(p->header),
+						       output_func_arg);
+
+				(*output_func)("--", 2, output_func_arg);
+				(*output_func)(b->boundary,
+					       strlen(b->boundary),
+					       output_func_arg);
+
+				if (is_closing)
+					(*output_func)("--", 2,
+						       output_func_arg);
+
+				(*output_func)("\n", 1, output_func_arg);
+
+				if (is_closing)
+				{
+					libmail_mimestack_pop_to(stack, b);
+					find_boundary(stack, iseof,
+						      input_func,
+						      input_func_arg,
+						      output_func,
+						      output_func_arg,
+						      doappend);
+				}
+				libmail_header_free(h);
+
+				libmail_readheader_init(&rhc);
+				continue; /* From the top */
+			}
+		}
+		if (libmail_readheader(&rhc, buf) < 0)
+		{
+			libmail_header_free(libmail_readheader_finish(&rhc));
+			*errflag= -1;
+			return NULL;
+		}
+	}
+
+	return (libmail_readheader_finish(&rhc));
+}
+
+/*
+** Here we do actual signing/encoding
+*/
+
+static int encode_header(const char *h)
+{
+	if (strncasecmp(h, "content-", 8) == 0)
+		return (1);
+	return (0);
+}
+
+struct gpg_fork_output_info {
+	void (*output_func)(const char *, size_t, void *);
+	void *output_func_arg;
+	struct gpgmime_forkinfo *gpgptr;
+};
+
+static int gpg_fork_output(const char *p, size_t n, void *dummy)
+{
+	struct gpg_fork_output_info *info=(struct gpg_fork_output_info *)dummy;
+
+	(*info->output_func)(p, n, info->output_func_arg);
+	return 0;
+}
+
+
+static int dogpgencrypt(const char *gpghome,
+			const char *passphrase_fd,
+			struct mimestack **stack,
+			struct header *h, int *iseof,
+			int (*input_func)(char *, size_t, void *vp),
+			void *input_func_arg,
+			void (*output_func)(const char *,
+					    size_t,
+					    void *),
+			void *output_func_arg,
+			int argc,
+			char **argv,
+			int dosign,
+			void (*errhandler)(const char *, void *),
+			void *errhandler_arg)
+{
+	struct header *hp;
+	char buf[BUFSIZ];
+	struct gpgmime_forkinfo gpg;
+	int clos_flag=0;
+	struct mimestack *b=0;
+	int rc;
+	const char *boundary;
+	int need_crlf;
+	struct gpg_fork_output_info gfoi;
+
+	boundary=get_boundary(*stack, "", NULL);
+
+	gfoi.output_func=output_func;
+	gfoi.output_func_arg=output_func_arg;
+
+	if (libmail_gpgmime_forksignencrypt(gpghome, passphrase_fd,
+					    (dosign ? GPG_SE_SIGN:0)
+					    | GPG_SE_ENCRYPT,
+					    argc, argv,
+					    &gpg_fork_output, &gfoi,
+					    &gpg))
+	{
+		return -1;
+	}
+
+	for (hp=h; hp; hp=hp->next)
+	{
+		if (encode_header(hp->header))
+			continue;
+
+		(*output_func)(hp->header, strlen(hp->header),
+			       output_func_arg);
+	}
+
+#define C(s) (*output_func)( s, sizeof(s)-1, output_func_arg)
+#define S(s) (*output_func)( s, strlen(s), output_func_arg)
+
+
+	C("Content-Type: multipart/encrypted;\n"
+	  "    boundary=\"");
+
+	S(boundary);
+
+	C("\";\n"
+	  "    protocol=\"application/pgp-encrypted\"\n"
+	  "\n"
+	  "This is a MIME GnuPG-encrypted message.  If you see this text, it means\n"
+	  "that your E-mail or Usenet software does not support MIME encrypted messages.\n"
+	  "The Internet standard for MIME PGP messages, RFC 2015, was published in 1996.\n"
+	  "To open this message correctly you will need to install E-mail or Usenet\n"
+	  "software that supports modern Internet standards.\n"
+	  "\n--");
+
+	S(boundary);
+
+	C("\n"
+	  "Content-Type: application/pgp-encrypted\n"
+	  "Content-Transfer-Encoding: 7bit\n"
+	  "\n"
+	  "Version: 1\n"
+	  "\n--");
+
+	S(boundary);
+
+	C("\n"
+	  "Content-Type: application/octet-stream\n"
+	  "Content-Transfer-Encoding: 7bit\n\n");
+
+#undef C
+#undef S
+
+	/* For Eudora compatiblity */
+        libmail_gpgmime_write(&gpg, "Mime-Version: 1.0\r\n", 19);
+
+	for (hp=h; hp; hp=hp->next)
+	{
+		const char *p;
+
+		if (!encode_header(hp->header))
+			continue;
+
+		for (p=hp->header; *p; p++)
+		{
+			if (*p == '\r')
+				continue;
+
+			if (*p == '\n')
+				libmail_gpgmime_write(&gpg, "\r\n", 2);
+			else
+				libmail_gpgmime_write(&gpg, p, 1);
+		}
+	}
+
+	/*
+	** Chew the content until the next MIME boundary.
+	*/
+	need_crlf=1;
+
+	while (!*iseof)
+	{
+		const char *p;
+
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+
+		if (need_crlf)
+		{
+			if ((b=is_boundary(*stack, buf, &clos_flag)) != NULL)
+				break;
+
+			libmail_gpgmime_write(&gpg, "\r\n", 2);
+		}
+
+		need_crlf=0;
+		for (;;)
+		{
+			for (p=buf; *p; p++)
+			{
+				if (*p == '\r')
+					continue;
+				if (*p == '\n')
+				{
+					need_crlf=1;
+					break;
+				}
+
+				libmail_gpgmime_write(&gpg, p, 1);
+			}
+			if (*p == '\n')
+				break;
+
+			if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+			{
+				*iseof=1;
+				break;
+			}
+		}
+	}
+
+	/*
+	** This needs some 'splainin.  Note that we spit out a newline at
+	** the BEGINNING of each line, above.  This generates the blank
+	** header->body separator line.  Now, if we're NOT doing multiline
+	** content, we need to follow the last line of the content with a
+	** newline.  If we're already doing multiline content, that extra
+	** newline (if it exists) is already there.
+	*/
+
+	if (!*stack)
+	{
+		libmail_gpgmime_write(&gpg, "\r\n", 2);
+	}
+
+	rc=libmail_gpgmime_finish(&gpg);
+
+	if (rc)
+	{
+		(*errhandler)(libmail_gpgmime_getoutput(&gpg), errhandler_arg);
+		return (-1);
+	}
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(boundary, strlen(boundary), output_func_arg);
+	(*output_func)("--\n", 3, output_func_arg);
+
+	if (*iseof)
+		return 0;
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(b->boundary, strlen(b->boundary), output_func_arg);
+	if (clos_flag)
+		(*output_func)("--", 2, output_func_arg);
+	(*output_func)("\n", 1, output_func_arg);
+
+	if (clos_flag)
+	{
+		libmail_mimestack_pop_to(stack, b);
+		find_boundary(stack, iseof, input_func,
+			      input_func_arg, output_func,
+			      output_func_arg, 1);
+	}
+
+	return 0;
+}
+
+static int dogpgsign(const char *gpghome, const char *passphrase_fd,
+		     struct mimestack **stack, struct header *h, int *iseof,
+		     int (*input_func)(char *, size_t, void *vp),
+		     void *input_func_arg,
+		     void (*output_func)(const char *,
+					 size_t,
+					 void *),
+		     void *output_func_arg,
+		     int argc,
+		     char **argv,
+		     void (*errhandler)(const char *, void *),
+		     void *errhandler_arg)
+{
+	struct header *hp;
+	char buf[8192];
+	struct gpgmime_forkinfo gpg;
+	int clos_flag=0;
+	struct mimestack *b=0;
+	int rc=0;
+	char signed_content_name[TEMPNAMEBUFSIZE];
+	int signed_content;
+	FILE *signed_content_fp;
+	const char *boundary;
+	int need_crlf;
+	struct gpg_fork_output_info gfoi;
+
+	for (hp=h; hp; hp=hp->next)
+	{
+		if (encode_header(hp->header))
+			continue;
+		(*output_func)(hp->header, strlen(hp->header),
+			       output_func_arg);
+	}
+
+	signed_content=libmail_tempfile(signed_content_name);
+	if (signed_content < 0 ||
+	    (signed_content_fp=fdopen(signed_content, "w+")) == NULL)
+	{
+		if (signed_content >= 0)
+		{
+			close(signed_content);
+			unlink(signed_content_name);
+		}
+		return -1;
+
+	}
+	libmail_gpg_noexec(fileno(signed_content_fp));
+	unlink(signed_content_name);	/* UNIX semantics */
+
+	for (hp=h; hp; hp=hp->next)
+	{
+		const char *p;
+
+		if (!encode_header(hp->header))
+			continue;
+
+		for (p=hp->header; *p; p++)
+		{
+			if (*p == '\r')
+				continue;
+
+			if (*p == '\n')
+				putc('\r', signed_content_fp);
+			putc(*p, signed_content_fp);
+		}
+	}
+
+	/*
+	** Chew the content until the next MIME boundary.
+	*/
+	need_crlf=1;
+	while (!*iseof)
+	{
+		const char *p;
+
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+
+		if (need_crlf)
+		{
+			if ((b=is_boundary(*stack, buf, &clos_flag)) != NULL)
+				break;
+
+			fprintf(signed_content_fp, "\r\n");
+		}
+
+		need_crlf=0;
+		for (;;)
+		{
+			for (p=buf; *p; p++)
+			{
+				if (*p == '\r')
+					continue;
+				if (*p == '\n')
+				{
+					need_crlf=1;
+					break;
+				}
+
+				putc(*p, signed_content_fp);
+			}
+			if (*p == '\n')
+				break;
+
+			if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+			{
+				*iseof=1;
+				break;
+			}
+		}
+	}
+
+	/*
+	** This needs some 'splainin.  Note that we spit out a newline at
+	** the BEGINNING of each line, above.  This generates the blank
+	** header->body separator line.  Now, if we're NOT doing multiline
+	** content, we need to follow the last line of the content with a
+	** newline.  If we're already doing multiline content, that extra
+	** newline (if it exists) is already there.
+	*/
+
+	if (!*stack)
+	{
+		fprintf(signed_content_fp, "\r\n");
+	}
+
+	if (fflush(signed_content_fp) < 0 || ferror(signed_content_fp))
+	{
+		fclose(signed_content_fp);
+		return (-1);
+	}
+
+	boundary=get_boundary(*stack, "", signed_content_fp);
+
+	if (my_rewind(signed_content_fp) < 0)
+	{
+		fclose(signed_content_fp);
+		return (-1);
+	}
+
+#define C(s) (*output_func)( s, sizeof(s)-1, output_func_arg)
+#define S(s) (*output_func)( s, strlen(s), output_func_arg)
+
+	C("Content-Type: multipart/signed;\n"
+	  "    boundary=\"");
+	S(boundary);
+	C("\";\n"
+	  "    micalg=pgp-sha1;"
+	  " protocol=\"application/pgp-signature\"\n"
+	  "\n"
+	  "This is a MIME GnuPG-signed message.  If you see this text, it means that\n"
+	  "your E-mail or Usenet software does not support MIME signed messages.\n"
+	  "The Internet standard for MIME PGP messages, RFC 2015, was published in 1996.\n"
+	  "To open this message correctly you will need to install E-mail or Usenet\n"
+	  "software that supports modern Internet standards.\n"
+	  "\n--");
+	S(boundary);
+	C("\n");
+
+
+	gfoi.output_func=output_func;
+	gfoi.output_func_arg=output_func_arg;
+	gfoi.gpgptr= &gpg;
+
+	if (libmail_gpgmime_forksignencrypt(gpghome, passphrase_fd,
+					    GPG_SE_SIGN,
+					    argc, argv,
+					    &gpg_fork_output, &gfoi,
+					    &gpg))
+	{
+		fclose(signed_content_fp);
+		return (-1);
+	}
+
+	while (fgets(buf, sizeof(buf), signed_content_fp) != NULL)
+	{
+		char *p;
+		size_t j, k;
+
+		libmail_gpgmime_write(&gpg, buf, strlen(buf));
+
+		p=buf;
+		for (j=k=0; p[j]; j++)
+			if (p[j] != '\r')
+				p[k++]=p[j];
+
+		if (k)
+			(*output_func)(p, k, output_func_arg);
+	}
+
+	C("\n--");
+	S(boundary);
+
+	C("\n"
+	  "Content-Type: application/pgp-signature\n"
+	  "Content-Transfer-Encoding: 7bit\n\n");
+
+#undef C
+#undef S
+
+	if (libmail_gpgmime_finish(&gpg))
+		rc= -1; /* TODO */
+
+	if (rc)
+	{
+		(*errhandler)(libmail_gpgmime_getoutput(&gpg),
+			      errhandler_arg);
+		fclose(signed_content_fp);
+		return -1;
+	}
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(boundary, strlen(boundary), output_func_arg);
+	(*output_func)("--\n", 3, output_func_arg);
+
+	fclose(signed_content_fp);
+	if (*iseof)
+		return 0;
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(b->boundary, strlen(b->boundary), output_func_arg);
+	if (clos_flag)
+		(*output_func)("--", 2, output_func_arg);
+	(*output_func)("\n", 1, output_func_arg);
+
+	if (clos_flag)
+	{
+		libmail_mimestack_pop_to(stack, b);
+		find_boundary(stack, iseof, input_func, input_func_arg,
+			      output_func, output_func_arg, 1);
+	}
+	return 0;
+}
+
+static int isgpg(struct mime_header *);
+static int checksign(const char *gpghome,
+		     const char *passphrase_fd,
+		     struct mimestack **, int *, struct header *,
+		     int (*input_func)(char *, size_t, void *vp),
+		     void *input_func_arg,
+		     void (*)(const char *, size_t, void *),
+		     void *,
+		     int, char **,
+		     int *);
+static int decrypt(const char *gpghome,
+		   const char *passphrase_fd,
+		   struct mimestack **, int *, struct header *,
+		   int (*input_func)(char *, size_t, void *vp),
+		   void *input_func_arg,
+		   void (*)(const char *, size_t, void *),
+		   void *,
+		   int, char **,
+		   int *);
+
+static void print_noncontent_headers(struct header *h,
+				     void (*output_func)(const char *,
+							 size_t,
+							 void *),
+				     void *output_func_arg)
+{
+	struct header *p;
+
+	for (p=h; p; p=p->next)
+	{
+		if (strncasecmp(p->header, "content-", 8) == 0)
+			continue;
+		(*output_func)(p->header, strlen(p->header), output_func_arg);
+	}
+}
+
+static int dosignencode2(int dosign, int doencode, int dodecode,
+			 const char *gpghome,
+			 const char *passphrase_fd,
+			 int (*input_func)(char *, size_t, void *vp),
+			 void *input_func_arg,
+			 void (*output_func)(const char *,
+					     size_t,
+					     void *),
+			 void *output_func_arg,
+			 void (*errhandler_func)(const char *, void *),
+			 void *errhandler_arg,
+			 int argc, char **argv,
+			 int *status)
+{
+	struct mimestack *boundary_stack=0;
+	int iseof=0;
+
+	*status=0;
+
+	while (!iseof)
+	{
+		int errflag;
+
+		static const char ct_s[]="content-type:";
+		struct header *h=read_headers(&boundary_stack, &iseof,
+					      input_func, input_func_arg,
+					      output_func,
+					      output_func_arg,
+					      dodecode ? 0:1,
+					      &errflag),
+			*hct;
+
+		if (errflag)
+			return 1;
+
+		if (iseof && !h)
+			continue;	/* Artifact */
+
+		hct=libmail_header_find(h, ct_s);
+
+		/*
+		** If this is a multipart MIME section, we can keep on
+		** truckin'.
+		**
+		*/
+
+		if (hct)
+		{
+			struct mime_header *mh=
+				libmail_mimeheader_parse(hct->header+
+							 (sizeof(ct_s)-1));
+			const char *bv;
+
+			if (!mh)
+			{
+				libmail_header_free(h);
+				return (-1);
+			}
+
+			if (strcasecmp(mh->header_name, "multipart/x-mimegpg")
+			    == 0)
+			{
+				/* Punt */
+
+				char *buf=malloc(strlen(hct->header)+100);
+				const char *p;
+
+				if (!buf)
+				{
+					libmail_mimeheader_free(mh);
+					libmail_header_free(h);
+					return (-1);
+				}
+				strcpy(buf, "Content-Type: multipart/mixed");
+				p=strchr(hct->header, ';');
+				strcat(buf, p ? p:"");
+				free(hct->header);
+				hct->header=buf;
+
+				libmail_mimeheader_free(mh);
+				mh=libmail_mimeheader_parse(hct->header+
+							    sizeof(ct_s)-1);
+				if (!mh)
+				{
+					libmail_header_free(h);
+					return (-1);
+				}
+			}
+
+			if (strncasecmp(mh->header_name, "multipart/", 10)==0
+			    && (bv=libmail_mimeheader_getattr(mh, "boundary")) != 0
+
+			    && (doencode & LIBMAIL_GPG_ENCAPSULATE) == 0
+
+			    && !dosign
+			    )
+			{
+				struct header *p;
+
+				if (libmail_mimestack_push(&boundary_stack,
+							   bv) < 0)
+				{
+					libmail_header_free(h);
+					return (-1);
+				}
+
+				if (dodecode)
+				{
+					int rc;
+
+					if (strcasecmp(mh->header_name,
+						       "multipart/signed")==0
+					    && (dodecode & LIBMAIL_GPG_CHECKSIGN)
+					    && isgpg(mh))
+					{
+						int errflag;
+
+						print_noncontent_headers(h,
+									 output_func,
+									 output_func_arg
+									 );
+						libmail_mimeheader_free(mh);
+						rc=checksign(gpghome,
+							     passphrase_fd,
+							     &boundary_stack,
+							     &iseof,
+							     h,
+							     input_func,
+							     input_func_arg,
+							     output_func,
+							     output_func_arg,
+							     argc, argv,
+							     &errflag);
+						libmail_header_free(h);
+
+						if (errflag)
+							*status |=
+								LIBMAIL_ERR_VERIFYSIG;
+						if (rc)
+							return -1;
+
+						continue;
+					}
+
+					if (strcasecmp(mh->header_name,
+						       "multipart/encrypted")
+					    ==0
+					    && (dodecode & LIBMAIL_GPG_UNENCRYPT)
+					    && isgpg(mh))
+					{
+						int errflag;
+
+						print_noncontent_headers(h,
+									 output_func,
+									 output_func_arg
+									 );
+						libmail_mimeheader_free(mh);
+						rc=decrypt(gpghome,
+							   passphrase_fd,
+							   &boundary_stack,
+							   &iseof,
+							   h,
+							   input_func,
+							   input_func_arg,
+							   output_func,
+							   output_func_arg,
+							   argc, argv,
+							   &errflag);
+						libmail_header_free(h);
+
+						if (errflag)
+							*status |=
+								LIBMAIL_ERR_DECRYPT;
+						if (rc)
+							return -1;
+						continue;
+					}
+				}
+
+				for (p=h; p; p=p->next)
+				{
+					(*output_func)(p->header,
+						       strlen(p->header),
+						       output_func_arg);
+				}
+
+				(*output_func)("\n", 1, output_func_arg);
+				libmail_header_free(h);
+				libmail_mimeheader_free(mh);
+
+				find_boundary(&boundary_stack, &iseof,
+					      input_func,
+					      input_func_arg,
+					      output_func,
+					      output_func_arg, dodecode ? 0:1);
+				continue;
+			}
+			libmail_mimeheader_free(mh);
+		}
+
+		if (dodecode)
+		{
+			struct header *p;
+			int is_message_rfc822=0;
+
+			for (p=h; p; p=p->next)
+			{
+				(*output_func)(p->header,
+					       strlen(p->header),
+					       output_func_arg);
+			}
+			(*output_func)("\n", 1, output_func_arg);
+
+			/*
+			** If this is a message/rfc822 attachment, we can
+			** resume reading the next set of headers.
+			*/
+
+			hct=libmail_header_find(h, ct_s);
+			if (hct)
+			{
+				struct mime_header *mh=
+					libmail_mimeheader_parse(hct->header+
+								 (sizeof(ct_s)
+								  -1));
+				if (!mh)
+				{
+					libmail_header_free(h);
+					return (-1);
+				}
+
+				if (strcasecmp(mh->header_name,
+					       "message/rfc822") == 0)
+					is_message_rfc822=1;
+				libmail_mimeheader_free(mh);
+			}
+			libmail_header_free(h);
+
+			if (!is_message_rfc822)
+				find_boundary(&boundary_stack, &iseof,
+					      input_func,
+					      input_func_arg,
+					      output_func,
+					      output_func_arg, 0);
+			continue;
+		}
+
+		if (doencode ?
+		    dogpgencrypt(gpghome,
+				 passphrase_fd,
+				 &boundary_stack, h, &iseof,
+				 input_func,
+				 input_func_arg,
+				 output_func,
+				 output_func_arg,
+				 argc, argv, dosign,
+				 errhandler_func, errhandler_arg)
+		    :
+		    dogpgsign(gpghome,
+			      passphrase_fd,
+			      &boundary_stack, h, &iseof,
+			      input_func,
+			      input_func_arg,
+			      output_func,
+			      output_func_arg,
+			      argc, argv,
+			      errhandler_func, errhandler_arg))
+		{
+			libmail_header_free(h);
+			return 1;
+		}
+
+		libmail_header_free(h);
+	}
+
+	return (0);
+}
+
+
+static int isgpg(struct mime_header *mh)
+{
+	const char *attr;
+
+	attr=libmail_mimeheader_getattr(mh, "protocol");
+
+	if (!attr)
+		return (0);
+
+	if (strcasecmp(attr, "application/pgp-encrypted") == 0)
+		return (1);
+
+	if (strcasecmp(attr, "application/pgp-signature") == 0)
+	{
+		return (1);
+	}
+	return (0);
+}
+
+static int nybble(char c)
+{
+	static const char x[]="0123456789ABCDEFabcdef";
+
+	const char *p=strchr(x, c);
+	int n;
+
+	if (!p) p=x;
+
+	n= p-x;
+	if (n >= 16)
+		n -= 6;
+	return (n);
+}
+
+/*
+** Check signature
+*/
+
+static int dochecksign(const char *, const char *,
+		       struct mimestack *,
+		       FILE *,
+		       void (*output_func)(const char *,
+					   size_t,
+					   void *),
+		       void *output_func_arg,
+		       const char *,
+		       const char *,
+		       int, char **, int *);
+
+static int checksign(const char *gpghome,
+		     const char *passphrase_fd,
+		     struct mimestack **stack, int *iseof,
+		     struct header *h,
+		     int (*input_func)(char *, size_t, void *vp),
+		     void *input_func_arg,
+		     void (*output_func)(const char *,
+					 size_t,
+					 void *),
+		     void *output_func_arg,
+		     int argc, char **argv, int *errptr)
+{
+	char buf[BUFSIZ];
+	struct header *h2;
+
+	char signed_content[TEMPNAMEBUFSIZE];
+	char signature[TEMPNAMEBUFSIZE];
+	int signed_file, signature_file;
+	FILE *signed_file_fp, *signature_file_fp;
+	int clos_flag;
+	int need_nl, check_boundary;
+	struct mimestack *b=0;
+	struct mime_header *mh;
+	int qpdecode=0;
+	int errflag;
+
+	*errptr=0;
+
+	signed_file=libmail_tempfile(signed_content);
+
+	if (signed_file < 0 || (signed_file_fp=fdopen(signed_file, "w+")) == 0)
+	{
+		if (signed_file > 0)
+		{
+			close(signed_file);
+			unlink(signed_content);
+		}
+		return -1;
+	}
+	libmail_gpg_noexec(fileno(signed_file_fp));
+
+	find_boundary(stack, iseof, input_func,
+		      input_func_arg, NULL, NULL, 0);
+	if (*iseof)
+		return 0;
+
+	need_nl=0;
+	check_boundary=1;
+
+	while (!*iseof)
+	{
+		const char *p;
+
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			continue;
+		}
+
+		if (check_boundary
+		    && (b=is_boundary(*stack, buf, &clos_flag)) != 0)
+			break;
+		if (need_nl)
+			fprintf(signed_file_fp, "\r\n");
+
+		for (p=buf; *p && *p != '\n'; p++)
+			putc(*p, signed_file_fp);
+		need_nl=check_boundary= *p != 0;
+	}
+
+	if (my_rewind(signed_file_fp) < 0)
+	{
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		return -1;
+	}
+
+	if (clos_flag)
+	{
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		if (b)
+			libmail_mimestack_pop_to(stack, b);
+		find_boundary(stack, iseof, input_func, input_func_arg,
+			      output_func, output_func_arg, 1);
+		return 0;
+	}
+
+	h=read_headers(stack, iseof, input_func, input_func_arg,
+		       output_func, output_func_arg, 0, &errflag);
+
+	if (errflag)
+	{
+		fclose(signed_file_fp);
+		unlink(signed_content);
+
+		return (-1);
+	}
+
+	if (!h || !(h2=libmail_header_find(h, "content-type:")))
+	{
+		if (h)
+			libmail_header_free(h);
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		if (!*iseof)
+			find_boundary(stack, iseof, input_func, input_func_arg,
+				      output_func, output_func_arg, 1);
+		return 0;
+	}
+
+	mh=libmail_mimeheader_parse(h2->header+sizeof("content-type:")-1);
+
+	if (!mh)
+	{
+		libmail_header_free(h);
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		return (-1);
+	}
+
+	if (strcasecmp(mh->header_name, "application/pgp-signature"))
+	{
+		libmail_mimeheader_free(mh);
+		libmail_header_free(h);
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		if (!*iseof)
+			find_boundary(stack, iseof, input_func, input_func_arg,
+				      output_func, output_func_arg, 1);
+		return (0);
+	}
+	libmail_mimeheader_free(mh);
+
+	/*
+	** In rare instances, the signature is qp-encoded.
+	*/
+
+	if ((h2=libmail_header_find(h, "content-transfer-encoding:")) != NULL)
+	{
+		mh=libmail_mimeheader_parse
+			(h2->header+sizeof("content-transfer-encoding:")-1);
+
+		if (!mh)
+		{
+			libmail_header_free(h);
+			fclose(signed_file_fp);
+			unlink(signed_content);
+			return -1;
+		}
+
+		if (strcasecmp(mh->header_name,
+			       "quoted-printable") == 0)
+			qpdecode=1;
+		libmail_mimeheader_free(mh);
+	}
+	libmail_header_free(h);
+
+	signature_file=libmail_tempfile(signature);
+
+	if (signature_file < 0
+	    || (signature_file_fp=fdopen(signature_file, "w+")) == 0)
+	{
+		if (signature_file > 0)
+		{
+			close(signature_file);
+			unlink(signature);
+		}
+		unlink(signed_content);
+		return (-1);
+	}
+
+	while (!*iseof)
+	{
+		const char *p;
+
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			continue;
+		}
+
+		if ((b=is_boundary(*stack, buf, &clos_flag)) != 0)
+			break;
+
+		for (p=buf; *p; p++)
+		{
+			int n;
+
+			if (!qpdecode)
+			{
+				putc(*p, signature_file_fp);
+				continue;
+			}
+
+			if (*p == '=' && p[1] == '\n')
+				break;
+
+			if (*p == '=' && p[1] && p[2])
+			{
+				n=nybble(p[1]) * 16 + nybble(p[2]);
+				if ( (char)n )
+				{
+					putc((char)n, signature_file_fp);
+					p += 2;
+				}
+				p += 2;
+				continue;
+			}
+			putc(*p, signature_file_fp);
+
+			/* If some spits out qp-lines > BUFSIZ, they deserve
+			** this crap.
+			*/
+		}
+	}
+
+	fflush(signature_file_fp);
+	if (ferror(signature_file_fp))
+	{
+		unlink(signature);
+		fclose(signed_file_fp);
+		unlink(signed_content);
+		return -1;
+	}
+	if (fclose(signature_file_fp))
+	{
+		unlink(signature);
+		unlink(signed_content);
+		return -1;
+	}
+
+	errflag=dochecksign(gpghome,
+			    passphrase_fd,
+			    *stack, signed_file_fp,
+			    output_func, output_func_arg, signed_content,
+			    signature,
+			    argc, argv, errptr);
+
+	fclose(signed_file_fp);
+	unlink(signature);
+	unlink(signed_content);
+
+	if (errflag)
+		return -1;
+
+	while (!clos_flag)
+	{
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+		if (!(b=is_boundary(*stack, buf, &clos_flag)))
+			clos_flag=0;
+	}
+	if (b)
+		libmail_mimestack_pop_to(stack, b);
+
+	return 0;
+}
+
+static const char *newboundary()
+{
+	static char buffer[256];
+	static unsigned counter=0;
+	time_t t;
+	char hostnamebuf[256];
+
+	time(&t);
+	hostnamebuf[sizeof(hostnamebuf)-1]=0;
+	if (gethostname(hostnamebuf, sizeof(hostnamebuf)-1) < 0)
+		hostnamebuf[0]=0;
+
+	sprintf(buffer, "=_%-1.30s-%u-%u-%04u",
+		hostnamebuf, (unsigned)getpid(),
+		(unsigned)t, ++counter);
+	return (buffer);
+}
+
+static int good_boundary(const char *boundary,
+			 struct mimestack *m, const char *errmsg, FILE *fp)
+{
+	int dummy;
+	int l=strlen(boundary);
+	const char *p;
+	char buf[BUFSIZ];
+
+	if (is_boundary(m, boundary, &dummy))
+		return (0);
+
+	for (p=errmsg; *p; )
+	{
+		if (*p == '-' && p[1] == '-' && strncasecmp(p+2, boundary, l)
+		    == 0)
+			return (0);
+
+		while (*p)
+			if (*p++ == '\n')
+				break;
+	}
+
+	if (fp)
+	{
+		if (my_rewind(fp) < 0)
+			return 0;
+
+		while (fgets(buf, sizeof(buf), fp))
+		{
+			if (buf[0] == '-' && buf[1] == '-' &&
+			    strncasecmp(buf+2, boundary, l) == 0)
+				return (0);
+		}
+	}
+	return (1);
+}
+
+static const char *get_boundary(struct mimestack *m,
+				const char *errmsg,
+				FILE *fp)
+{
+	const char *p;
+
+	do
+	{
+		p=newboundary();
+	} while (!good_boundary(p, m, errmsg, fp));
+	return (p);
+}
+
+static const char *encoding_str(const char *p)
+{
+	while (*p)
+	{
+		if (*p <= 0 || *p >= 0x7F)
+			return ("8bit");
+		++p;
+	}
+	return ("7bit");
+}
+
+
+static int copyfp(FILE *t,
+		  void (*output_func)(const char *,
+				      size_t,
+				      void *),
+		  void *output_func_arg,
+		  int stripcr)
+{
+	char buf[BUFSIZ];
+	int rc=0;
+
+	while ((rc=fread(buf, 1, sizeof(buf), t)) > 0)
+	{
+		if (stripcr)
+		{
+			int i, j;
+
+			for (i=j=0; i<rc; ++i)
+			{
+				if (buf[i] != '\r')
+					buf[j++]=buf[i];
+			}
+			rc=j;
+		}
+		(*output_func)(buf, rc, output_func_arg);
+	}
+
+	return rc;
+}
+
+static void open_result_multipart(void (*)(const char *, size_t, void *),
+				  void *,
+				  int, const char *, const char *,
+				  const char *);
+
+static int dochecksign(const char *gpghome,
+		       const char *passphrase_fd,
+		       struct mimestack *stack,
+		       FILE *content_fp,
+		       void (*output_func)(const char *,
+					   size_t,
+					   void *),
+		       void *output_func_arg,
+		       const char *content_filename,
+		       const char *signature_filename,
+		       int argc,
+		       char **argv, int *errptr)
+{
+	struct gpgmime_forkinfo gpg;
+	int i;
+	const char *new_boundary;
+	const char *output;
+
+	if (libmail_gpgmime_forkchecksign(gpghome, passphrase_fd,
+				  content_filename,
+				  signature_filename,
+				  argc, argv,
+				  &gpg))
+	{
+		return -1;
+	}
+
+	*errptr=i=libmail_gpgmime_finish(&gpg);
+
+	output=libmail_gpgmime_getoutput(&gpg);
+
+	new_boundary=get_boundary(stack, output, content_fp);
+
+	open_result_multipart(output_func, output_func_arg,
+			      i, new_boundary, output,
+			      libmail_gpgmime_getcharset(&gpg));
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(new_boundary, strlen(new_boundary), output_func_arg);
+	(*output_func)("\n", 1, output_func_arg);
+
+	if (my_rewind(content_fp) < 0)
+	{
+		return -1;
+	}
+
+	if (copyfp(content_fp, output_func, output_func_arg, 1))
+		return -1;
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(new_boundary, strlen(new_boundary), output_func_arg);
+	(*output_func)("--\n", 3, output_func_arg);
+	return 0;
+}
+
+static void open_result_multipart(void (*output_func)(const char *,
+						      size_t,
+						      void *),
+				  void *output_func_arg,
+				  int rc,
+				  const char *new_boundary,
+				  const char *err_str,
+				  const char *err_charset)
+{
+#define C(s) (*output_func)( s, sizeof(s)-1, output_func_arg)
+#define S(s) (*output_func)( s, strlen(s), output_func_arg)
+
+	char n[10];
+	const char *p;
+
+	sprintf(n, "%d", rc);
+
+	C("Content-Type: multipart/x-mimegpg; xpgpstatus=");
+
+	S(n);
+
+	C("; boundary=\"");
+
+	S(new_boundary);
+
+	C("\"\n"
+	  "\nThis is a MIME GnuPG-processed message.  If you see this text, it means\n"
+	  "that your E-mail or Usenetsoftware does not support MIME-formatted messages.\n\n"
+	  "--");
+
+	S(new_boundary);
+	C("\nContent-Type: text/x-gpg-output; charset=");
+	S(err_charset);
+	C("\nContent-Transfer-Encoding: ");
+
+	p=encoding_str(err_str);
+	S(p);
+	C("\n\n");
+	S(err_str);
+#undef C
+#undef S
+}
+
+static void close_mime(struct mimestack **stack, int *iseof,
+		       int (*input_func)(char *, size_t, void *vp),
+		       void *input_func_arg,
+		       void (*output_func)(const char *,
+					   size_t,
+					   void *),
+		       void *output_func_arg)
+{
+	char buf[BUFSIZ];
+	int is_closing;
+	struct mimestack *b;
+
+	for (;;)
+	{
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+
+		(*output_func)(buf, strlen(buf), output_func_arg);
+		if (!(b=is_boundary(*stack, buf, &is_closing)))
+			continue;
+		if (!is_closing)
+			continue;
+
+		libmail_mimestack_pop_to(stack, b);
+		break;
+	}
+}
+
+static int dodecrypt(const char *, const char *,
+		     struct mimestack **, int *,
+		     int (*input_func)(char *, size_t, void *vp),
+		     void *input_func_arg,
+		     FILE *, int, char **, const char *,
+		     void (*)(const char *,
+			      size_t,
+			      void *),
+		     void *,
+		     int *);
+
+static void write_temp_fp(const char *p, size_t n, void *vp)
+{
+	if (fwrite(p, n, 1, (FILE *)vp) != 1)
+		; /* ignored */
+}
+
+static int decrypt(const char *gpghome,
+		   const char *passphrase_fd,
+		   struct mimestack **stack, int *iseof,
+		   struct header *h,
+		   int (*input_func)(char *, size_t, void *vp),
+		   void *input_func_arg,
+		   void (*output_func)(const char *,
+				       size_t,
+				       void *),
+		   void *output_func_arg,
+		   int argc, char **argv,
+		   int *errptr)
+{
+	struct header *p, *q;
+	char temp_file[TEMPNAMEBUFSIZE];
+	int temp_fd;
+	FILE *temp_fp;
+	struct mime_header *mh;
+	int flag;
+	int errflag;
+
+	*errptr=0;
+	temp_fd=libmail_tempfile(temp_file);
+	if (temp_fd < 0 || (temp_fp=fdopen(temp_fd, "w+")) == 0)
+	{
+		if (temp_fd >= 0)
+			close(temp_fd);
+		return -1;
+	}
+
+	for (p=h; p; p=p->next)
+	{
+		fprintf(temp_fp, "%s", p->header);
+	}
+	putc('\n', temp_fp);
+
+	find_boundary(stack, iseof, input_func, input_func_arg,
+		      write_temp_fp, temp_fp, 0);
+	if (*iseof)
+	{
+		fclose(temp_fp);
+		unlink(temp_file);
+		return (0);
+	}
+
+	p=read_headers(stack, iseof, input_func, input_func_arg, write_temp_fp,
+		       temp_fp, 0, &errflag);
+
+	if (*iseof || errflag)
+	{
+		libmail_header_free(p);
+		fclose(temp_fp);
+		unlink(temp_file);
+
+		if (errflag)
+			return -1;
+		return 0;
+	}
+
+	q=libmail_header_find(p, "content-type:");
+
+	flag=0;
+
+	if (q)
+	{
+		mh=libmail_mimeheader_parse(q->header+13);
+		if (!mh)
+		{
+			libmail_header_free(p);
+			fclose(temp_fp);
+			unlink(temp_file);
+			return -1;
+		}
+
+		if (strcasecmp(mh->header_name, "application/pgp-encrypted")
+		    == 0)
+			flag=1;
+		libmail_mimeheader_free(mh);
+	}
+
+	for (q=p; q; q=q->next)
+	{
+		fprintf(temp_fp, "%s", q->header);
+	}
+	libmail_header_free(p);
+	putc('\n', temp_fp);
+
+	p=read_headers(stack, iseof, input_func, input_func_arg,
+		       write_temp_fp, temp_fp, 0,
+		       &errflag);
+
+	if (*iseof || errflag)
+	{
+		libmail_header_free(p);
+		fclose(temp_fp);
+		unlink(temp_file);
+
+		if (errflag)
+			return -1;
+
+		return 0;
+	}
+
+	q=libmail_header_find(p, "version:");
+
+	if (flag)
+	{
+		if (!q || atoi(p->header + 8) != 1)
+			flag=0;
+	}
+	for (q=p; q; q=q->next)
+	{
+		fprintf(temp_fp, "%s", q->header);
+	}
+	libmail_header_free(p);
+	putc('\n', temp_fp);
+
+	find_boundary(stack, iseof, input_func, input_func_arg,
+		      write_temp_fp, temp_fp, 0);
+
+	if (*iseof)
+	{
+		fclose(temp_fp);
+		unlink(temp_file);
+		return 0;
+	}
+
+	p=read_headers(stack, iseof, input_func, input_func_arg, write_temp_fp,
+		       temp_fp, 0, &errflag);
+
+	if (*iseof || errflag)
+	{
+		libmail_header_free(p);
+		fclose(temp_fp);
+		unlink(temp_file);
+
+		if (errflag)
+			return -1;
+
+		return 0;
+	}
+
+	q=libmail_header_find(p, "content-type:");
+
+	if (q && flag)
+	{
+		flag=0;
+		mh=libmail_mimeheader_parse(q->header+13);
+		if (!mh)
+		{
+			libmail_header_free(p);
+			fclose(temp_fp);
+			unlink(temp_file);
+			return -1;
+		}
+
+		if (strcasecmp(mh->header_name, "application/octet-stream")
+		    == 0)
+			flag=1;
+		libmail_mimeheader_free(mh);
+
+		q=libmail_header_find(p, "content-transfer-encoding:");
+		if (q && flag)
+		{
+			flag=0;
+			mh=libmail_mimeheader_parse(strchr(q->header, ':')+1);
+			if (!mh)
+			{
+				libmail_header_free(p);
+				fclose(temp_fp);
+				unlink(temp_file);
+				return -1;
+			}
+
+			if (strcasecmp(mh->header_name, "7bit") == 0 ||
+			    strcasecmp(mh->header_name, "8bit") == 0)
+				flag=1;
+			libmail_mimeheader_free(mh);
+		}
+	}
+
+	for (q=p; q; q=q->next)
+	{
+		fprintf(temp_fp, "%s", q->header);
+	}
+	libmail_header_free(p);
+	putc('\n', temp_fp);
+
+	if (fflush(temp_fp) || ferror(temp_fp) || my_rewind(temp_fp) < 0)
+	{
+		fclose(temp_fp);
+		unlink(temp_file);
+		return -1;
+	}
+
+	if (!flag)
+	{
+		int c=copyfp(temp_fp, output_func, output_func_arg, 0);
+
+		fclose(temp_fp);
+		unlink(temp_file);
+		close_mime(stack, iseof, input_func, input_func_arg,
+			   output_func, output_func_arg);
+		return (c);
+	}
+
+	fclose(temp_fp);
+	if ((temp_fp=fopen(temp_file, "w+")) == NULL)
+	{
+		unlink(temp_file);
+		return (-1);
+	}
+	libmail_gpg_noexec(fileno(temp_fp));
+	errflag=dodecrypt(gpghome, passphrase_fd,
+			  stack, iseof, input_func, input_func_arg,
+			  temp_fp, argc, argv, temp_file,
+			  output_func, output_func_arg, errptr);
+	fclose(temp_fp);
+	unlink(temp_file);
+	return errflag;
+}
+
+static int dumpdecrypt(const char *c, size_t n, void *vp)
+{
+	FILE *fp=(FILE *)vp;
+
+	if (n == 0)
+		return 0;
+
+	if (fwrite(c, n, 1, fp) != 1)
+		return -1;
+	return (0);
+}
+
+static int dodecrypt(const char *gpghome,
+		     const char *passphrase_fd,
+		     struct mimestack **stack, int *iseof,
+		     int (*input_func)(char *, size_t, void *vp),
+		     void *input_func_arg,
+		     FILE *fpout, int argc, char **argv,
+		     const char *temp_file,
+		     void (*output_func)(const char *,
+			      size_t,
+			      void *),
+		     void *output_func_arg,
+		     int *errptr)
+{
+	struct gpgmime_forkinfo gpg;
+	char buf[BUFSIZ];
+	int is_closing;
+	struct mimestack *b=NULL;
+	int dowrite=1;
+	int rc;
+	const char *new_boundary;
+	const char *output;
+
+	if (libmail_gpgmime_forkdecrypt(gpghome,
+				passphrase_fd,
+				argc, argv, &dumpdecrypt, fpout, &gpg))
+		return -1;
+
+	for (;;)
+	{
+		if ( (*input_func)(buf, sizeof(buf), input_func_arg))
+		{
+			*iseof=1;
+			break;
+		}
+
+		if (dowrite)
+			libmail_gpgmime_write(&gpg, buf, strlen(buf));
+
+		if (!(b=is_boundary(*stack, buf, &is_closing)))
+			continue;
+		dowrite=0;
+		if (!is_closing)
+			continue;
+		break;
+	}
+
+	rc=libmail_gpgmime_finish(&gpg);
+	if (fflush(fpout) || ferror(fpout) || my_rewind(fpout) < 0)
+	{
+		fclose(fpout);
+		unlink(temp_file);
+		return -1;
+	}
+
+	if (*iseof)
+		return 0;
+
+	output=libmail_gpgmime_getoutput(&gpg),
+
+	new_boundary=get_boundary(*stack, output, rc ? NULL:fpout);
+
+	open_result_multipart(output_func,
+			      output_func_arg, rc, new_boundary,
+			      output,
+			      libmail_gpgmime_getcharset(&gpg));
+
+	*errptr=rc;
+
+#if 0
+
+	/*
+	** gnupg returns non-zero exit even if succesfully unencrypted, when
+	** just the signature is bad.
+	*/
+	if (rc == 0)
+#endif
+	{
+		if (fseek(fpout, 0L, SEEK_SET) < 0)
+		{
+			fclose(fpout);
+			unlink(temp_file);
+			return -1;
+		}
+
+		(*output_func)("\n--", 3, output_func_arg);
+		(*output_func)(new_boundary, strlen(new_boundary),
+			       output_func_arg);
+		(*output_func)("\n", 1, output_func_arg);
+
+		if (copyfp(fpout, output_func, output_func_arg, 1))
+		    return -1;
+	}
+
+	(*output_func)("\n--", 3, output_func_arg);
+	(*output_func)(new_boundary, strlen(new_boundary),
+		       output_func_arg);
+	(*output_func)("--\n", 3, output_func_arg);
+
+	libmail_mimestack_pop_to(stack, b);
+	return 0;
+}
+
+struct libmail_gpg_errhandler {
+
+	struct libmail_gpg_info *options;
+	int err_flag;
+};
+
+static void libmail_gpg_errfunc(const char *errmsg, void *vp)
+{
+	struct libmail_gpg_errhandler *eh=(struct libmail_gpg_errhandler *)vp;
+
+	if (!eh->err_flag)
+	{
+		eh->err_flag=1;
+
+		(*eh->options->errhandler_func)(errmsg,
+						eh->options->errhandler_arg);
+	}
+}
+ 
+static int input_func_from_fp(char *buf, size_t cnt, void *vp)
+{
+	if (fgets(buf, cnt, (FILE *)vp) == NULL)
+		return (-1);
+	return (0);
+}
+
+/*
+** When signing, but not encoding, signed text must be 7bit, as per RFC.
+**
+** Use rfc2045's rewriter to do this.
+*/
+
+static int dosignencode(int dosign, int doencode, int dodecode,
+			const char *gpghome,
+			const char *passphrase_fd,
+			int (*input_func)(char *, size_t, void *vp),
+			void *input_func_arg,
+			void (*output_func)(const char *,
+					    size_t,
+					    void *),
+			void *output_func_arg,
+			void (*errhandler_func)(const char *, void *),
+			void *errhandler_arg,
+			int argc, char **argv,
+			int *status)
+{
+	char temp_decode_name[TEMPNAMEBUFSIZE];
+	int fdin;
+	int fdout;
+	FILE *fdin_fp;
+	char buffer[8192];
+	struct rfc2045src *src;
+	struct rfc2045 *rfcp;
+	int rc;
+
+	if (!dosign || doencode)
+		return dosignencode2(dosign, doencode, dodecode,
+				     gpghome,
+				     passphrase_fd,
+				     input_func,
+				     input_func_arg,
+				     output_func,
+				     output_func_arg,
+				     errhandler_func,
+				     errhandler_arg,
+				     argc, argv, status);
+
+	/* Save the message into a temp file, first */
+
+	fdin=libmail_tempfile(temp_decode_name);
+
+	if (fdin < 0 ||
+	    (fdin_fp=fdopen(fdin, "w+")) == NULL)
+	{
+		if (fdin >= 0)
+			close(fdin);
+
+		(*errhandler_func)("Cannot create temporary file",
+				   errhandler_arg);
+		return (-1);
+	}
+
+	unlink(temp_decode_name);
+
+	if (!(rfcp=rfc2045_alloc_ac()))
+	{
+		(*errhandler_func)(strerror(errno), errhandler_arg);
+		fclose(fdin_fp);
+		return (-1);
+	}
+
+	while ( (*input_func)(buffer, sizeof(buffer), input_func_arg) == 0)
+	{
+		size_t l=strlen(buffer);
+
+		if (fwrite(buffer, l, 1, fdin_fp) != 1)
+		{
+			(*errhandler_func)(strerror(errno), errhandler_arg);
+			fclose(fdin_fp);
+			rfc2045_free(rfcp);
+			return (-1);
+		}
+
+		/* Parse the message at the same time it's being saved */
+
+		rfc2045_parse(rfcp, buffer, l);
+	}
+
+	if (fseek(fdin_fp, 0L, SEEK_SET) < 0)
+	{
+		(*errhandler_func)(strerror(errno), errhandler_arg);
+		fclose(fdin_fp);
+		rfc2045_free(rfcp);
+		return (-1);
+	}
+
+	if (!rfc2045_ac_check(rfcp, RFC2045_RW_7BIT))
+	{
+		rfc2045_free(rfcp);
+
+		/* No need to rewrite, just do this */
+
+		rc=dosignencode2(dosign, doencode, dodecode,
+				     gpghome,
+				     passphrase_fd,
+				     input_func_from_fp,
+				     fdin_fp,
+				     output_func,
+				     output_func_arg,
+				     errhandler_func,
+				     errhandler_arg,
+				     argc, argv, status);
+
+		fclose(fdin_fp);
+
+		return rc;
+	}
+
+	/* Rewrite the message into another temp file */
+
+	fdout=libmail_tempfile(temp_decode_name);
+
+	src=rfc2045src_init_fd(fileno(fdin_fp));
+
+	if (fdout < 0 || src == NULL ||
+	    rfc2045_rewrite(rfcp, src, fdout, "mimegpg") < 0 ||
+	    lseek(fdout, 0L, SEEK_SET) < 0)
+	{
+		if (fdout >= 0)
+			close(fdout);
+		if (src)
+			rfc2045src_deinit(src);
+
+		(*errhandler_func)(strerror(errno), errhandler_arg);
+		rfc2045_free(rfcp);
+		fclose(fdin_fp);
+		return (-1);
+	}
+	fclose(fdin_fp);
+	rfc2045_free(rfcp);
+	rfc2045src_deinit(src);
+
+	/* Now, read the converted message, from the temp file */
+
+	if ((fdin_fp=fdopen(fdout, "w+")) == NULL)
+	{
+		close(fdout);
+
+		(*errhandler_func)("Cannot create temporary file",
+				   errhandler_arg);
+		return (-1);
+	}
+
+	rc=dosignencode2(dosign, doencode, dodecode,
+			 gpghome,
+			 passphrase_fd,
+			 input_func_from_fp,
+			 fdin_fp,
+			 output_func,
+			 output_func_arg,
+			 errhandler_func,
+			 errhandler_arg,
+			 argc, argv, status);
+	fclose(fdin_fp);
+	return rc;
+}
+
+int libmail_gpg_signencode(int dosign,
+			   int doencode,
+			   /*
+			   ** One of LIBMAIL_GPG_INDIVIDUAL or
+			   ** LIBMAIL_GPG_ENCAPSULATE
+			   */
+			   struct libmail_gpg_info *options)
+{
+	int rc;
+	struct libmail_gpg_errhandler eh;
+
+	eh.options=options;
+	eh.err_flag=0;
+
+	if (doencode != LIBMAIL_GPG_INDIVIDUAL &&
+	    doencode != LIBMAIL_GPG_ENCAPSULATE)
+		doencode=0;
+
+	if (!dosign && !doencode)
+	{
+		(*options->errhandler_func)("Invalid arguments to"
+					    " libmail_gpg_signencode",
+					    options->errhandler_arg);
+		return -1;
+	}
+
+	rc=dosignencode(dosign, doencode, 0,
+			options->gnupghome,
+			options->passphrase_fd,
+			options->input_func,
+			options->input_func_arg,
+			options->output_func,
+			options->output_func_arg,
+			&libmail_gpg_errfunc,
+			&eh,
+			options->argc,
+			options->argv,
+			&options->errstatus);
+
+	if (rc && !eh.err_flag)
+		(*options->errhandler_func)(strerror(errno),
+					    options->errhandler_arg);
+	return rc;
+}
+
+int libmail_gpg_decode(int mode,
+		       /*
+		       ** LIBMAIL_GPG_UNENCRYPT OR LIBMAIL_GPG_CHECKSIGN
+		       */
+		       struct libmail_gpg_info *options)
+{
+	int rc;
+	struct libmail_gpg_errhandler eh;
+
+	eh.options=options;
+	eh.err_flag=0;
+
+	if ((mode & (LIBMAIL_GPG_UNENCRYPT|LIBMAIL_GPG_CHECKSIGN)) == 0)
+	{
+		(*options->errhandler_func)("Invalid arguments to"
+					    " libmail_gpg_decode",
+					    options->errhandler_arg);
+		return -1;
+	}
+
+	rc=dosignencode(0, 0, mode,
+			options->gnupghome,
+			options->passphrase_fd,
+			options->input_func,
+			options->input_func_arg,
+			options->output_func,
+			options->output_func_arg,
+			&libmail_gpg_errfunc,
+			&eh,
+			options->argc,
+			options->argv,
+			&options->errstatus);
+
+	if (rc && !eh.err_flag)
+		(*options->errhandler_func)(strerror(errno),
+					    options->errhandler_arg);
+	return rc;
+}