Git initHEAD2.0_alphamaster2.0alpha1.0_post

18 files changed, 3046 insertions, 0 deletions

diff --git a/include/ChangeLog b/include/ChangeLog
new file mode 100644
index 0000000..b73f0cb
--- /dev/null
+++ b/include/ChangeLog
@@ -0,0 +1,588 @@
+2006-12-04  Werner Koch  <wk@g10code.com>
+
+	* iobuf.h (iobuf_t): New.  That is the name we use in 2.0.
+
+2006-09-28  David Shaw  <dshaw@jabberwocky.com>
+
+	* compat.h: Move strsep prototype and ascii_isspace macro to from
+	util.h.
+
+	* compat.h: New, used for libcompat.a functions.
+
+	* util.h: Includes compat.h.
+
+2006-04-20  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add dsa2_generate();
+
+2006-04-19  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add SHA-224.
+
+2006-03-16  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Handle the fixed IPGP type with fingerprint.
+
+2006-02-14  Werner Koch  <wk@gnupg.org>
+
+	* errors.h (G10ERR_NO_DATA): New.
+
+2005-12-23  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Prototype get_cert().
+
+2005-07-27  Werner Koch  <wk@g10code.com>
+
+	* memory.h (m_free, m_alloc, m_realloc, m_strdup): Removed and
+	replaced all over by xfoo functions.  This is to ease porting to
+	gnupg 1.9.
+	(xmalloc_secure) [M_DEBUG]: Correctly map to m_debug_alloc_secure.
+
+2005-06-23  David Shaw  <dshaw@jabberwocky.com>
+
+	* http.h: Fix prototypes for http_open_document and http_open
+	again, to handle the new different auth for regular files and
+	proxies.
+
+2005-06-21  David Shaw  <dshaw@jabberwocky.com>
+
+	* http.h: Fix prototypes for http_open_document and http_open to
+	pass in auth and proxyauth.
+
+2005-05-19  Werner Koch  <wk@g10code.com>
+
+	* util.h: Add definitions for membuf functions.
+
+2005-05-05  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Remove add_days_to_timestamp as unused.
+
+2005-04-22  David Shaw  <dshaw@jabberwocky.com>
+
+	* distfiles: Add assuan.h.
+
+2005-04-04  Werner Koch  <wk@g10code.com>
+
+	* memory.h (xcalloc, xcalloc_secure): Replaced macros by functions.
+
+2005-03-31  Werner Koch  <wk@g10code.com>
+
+	* assuan.h: New.  Taken from libassuan 0.6.9.
+
+2005-03-18  David Shaw  <dshaw@jabberwocky.com>
+
+	* ttyio.h: Prototype tty_enable_completion(), and
+	tty_disable_completion().
+
+2005-02-09  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add a flag for a symmetric DEK.
+
+2004-12-16  David Shaw  <dshaw@jabberwocky.com>
+
+	* memory.h: Return a flag to indicate whether we got the lock.
+
+2004-11-29  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add PUBKEY_USAGE_UNKNOWN.
+
+2004-11-03  Timo Schulz  <twoaday@g10code.com>
+
+        * errors.h: Add w32_strerror prototype.
+	* dynload.h: Use w32_strerror.
+	
+2004-10-27  Werner Koch  <wk@g10code.com>
+
+	* dynload.h: Always use it for _WIN32.
+
+2004-10-21  Werner Koch  <wk@g10code.com>
+
+	* util.h [!HAVE_VASPRINTF]: Removed prototype.
+
+2004-10-15  Werner Koch  <wk@g10code.com>
+
+	* util.h [!HAVE_VASPRINTF]: Add asprintf prototype.
+
+2004-10-13  David Shaw  <dshaw@jabberwocky.com>
+
+	* keyserver.h: Add KEYSERVER_TIMEOUT.
+
+2004-09-30  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Prototype destroy_dotlock().  From Werner on stable
+	branch.
+
+2004-09-10  David Shaw  <dshaw@jabberwocky.com>
+
+	* http.h: Add auth field for a parsed_uri to allow for basic auth.
+
+2004-09-09  Werner Koch  <wk@g10code.com>
+
+	* errors.h (G10ERR_NO_CARD, G10ERR_CANCELED): New error codes.
+
+2004-04-27  Werner Koch  <wk@gnupg.org>
+
+	* mpi.h: Renamed prototype parameter name to avoid gcc warnings.
+
+2004-03-04  David Shaw  <dshaw@jabberwocky.com>
+
+	* iobuf.h: Remove iobuf_set_block_mode() and
+	iobuf_in_block_mode().
+
+2004-02-21  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Prototype for hextobyte().
+
+2004-01-16  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Remove the old CIPHER_ALGO_RINJDAEL values.
+	is_ELGAMAL() now only matches type 16 and not type 20.
+
+2004-01-15  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add prototype for print_string2().
+
+2003-12-28  David Shaw  <dshaw@jabberwocky.com>
+
+	* http.h: Pass the http proxy from outside rather than pulling it
+	from the evironment.
+
+2003-12-28  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Removal of unnecessary RISC OS stuff.
+
+2003-12-17  David Shaw  <dshaw@jabberwocky.com>
+
+	* mpi.h (gcry_mpi, mpi_get_opaque, mpi_set_opaque): Make nbits and
+	the length of an opaque MPI unsigned.
+
+	* cipher.h (pubkey_verify): Remove old unused code.
+
+2003-12-03  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Make cipher list match 2440bis-09.
+
+2003-11-20  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add prototype for match_multistr().
+
+2003-10-31  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add COMPRESS_ALGO_BZIP2.
+
+2003-10-04  Timo Schulz  <twoaday@freakmail.de>
+
+	* dynload [WIN32] (dlclose): Do not use CloseHandle but FreeLibrary.
+	
+2003-09-29  Werner Koch  <wk@gnupg.org>
+
+	* cipher.h (PUBKEY_USAGE_AUTH): New.
+
+2003-09-28  Timo Schulz  <twoaday@freakmail.de>
+
+	* util.h [WIN32]: Prototype for asprintf.
+	* dynload.h [WIN32]: Define RTLD_LAZY.
+	
+2003-09-28  Werner Koch  <wk@gnupg.org>
+
+	* util.h: Add the atoi_* and xtoi_* suite of macros from 1.9.
+	* dynload.h: New.  Taken from 1.9.
+
+2003-09-27  Werner Koch  <wk@gnupg.org>
+
+	* memory.h (xmalloc): Define xmalloc macros in terms of m_alloc.
+
+2003-09-04  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Drop TIGER/192 support.
+
+2003-08-28  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: s/__MINGW32__/_WIN32/ to help building on native Windows
+	compilers.  Requested by Brian Gladman.  From Werner on stable
+	branch.
+
+2003-07-10  David Shaw  <dshaw@jabberwocky.com>
+
+	* types.h: Prefer using uint64_t when creating a 64-bit unsigned
+	type. This avoids a warning on compilers that support but complain
+	about unsigned long long.
+
+	* util.h (ascii_isspace): New variation on isspace() that is
+	immune from locale changes.
+
+	* util.h: Make sure that only ascii is passed to isfoo
+	functions. (From Werner on stable branch).
+
+2003-05-24  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h, i18n.h, iobuf.h, memory.h, mpi.h, types.h, util.h:
+	Edit all preprocessor instructions to remove whitespace before the
+	'#'.  This is not required by C89, but there are some compilers
+	out there that don't like it.
+
+2003-05-14  David Shaw  <dshaw@jabberwocky.com>
+
+	* types.h: Add initializer macros for 64-bit unsigned type.
+
+2003-05-02  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add constants for compression algorithms.
+
+2003-03-11  David Shaw  <dshaw@jabberwocky.com>
+
+	* http.h: Add HTTP_FLAG_TRY_SRV.
+
+2003-02-11  David Shaw  <dshaw@jabberwocky.com>
+
+	* types.h: Try and use uint64_t for a 64-bit type.
+
+2003-02-04  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add constants for new SHAs.
+
+2002-11-13  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h [__CYGWIN32__]: Don't need the registry prototypes.  From
+	Werner on stable branch.
+
+2002-11-06  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add wipememory2() macro (same as wipememory, but can
+	specify the byte to wipe with).
+
+2002-10-31  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Prefixed all RISC OS prototypes with
+	riscos_*
+
+	* zlib-riscos.h: New. This is macro magic in order to make the
+	zlib library calls indeed call the RISC OS ZLib module.
+
+2002-10-31  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add wipememory() macro.
+
+2002-10-29  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h: Added parameter argument to make_basename() needed for
+	filetype support.
+	[__riscos__]: Added prototype.
+
+2002-10-28  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Added prototypes for new filetype support.
+
+2002-10-19  David Shaw  <dshaw@jabberwocky.com>
+
+	* distfiles, _regex.h: Add _regex.h from glibc 2.3.1.
+
+2002-10-14  David Shaw  <dshaw@jabberwocky.com>
+
+	* keyserver.h: Go to KEYSERVER_PROTO_VERSION 1.
+
+2002-10-08  David Shaw  <dshaw@jabberwocky.com>
+
+	* keyserver.h: Add new error code KEYSERVER_UNREACHABLE.
+
+2002-10-03  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add new log_warning logger command which can be switched
+	between log_info and log_error via log_set_strict.
+
+2002-09-24  David Shaw  <dshaw@jabberwocky.com>
+
+	* keyserver.h: Add some new error codes for better GPA support.
+
+2002-09-10  Werner Koch  <wk@gnupg.org>
+
+	* mpi.h (mpi_is_protected, mpi_set_protect_flag)
+	(mpi_clear_protect_flag): Removed.
+	(mpi_get_nbit_info, mpi_set_nbit_info): Removed.
+
+2002-08-13  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add AES aliases for RIJNDAEL algo numbers.
+
+2002-08-07  David Shaw  <dshaw@jabberwocky.com>
+
+	* cipher.h: Add md_algo_present().
+
+2002-08-06  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Added riscos_getchar().
+
+2002-06-21  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Further moving away of RISC OS specific
+	stuff from general code.
+
+2002-06-20  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Added riscos_set_filetype().
+
+2002-06-14  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: Add pop_strlist() from strgutil.c.
+
+2002-06-07  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: RISC OS needs strings.h for strcasecmp()
+	and strncasecmp().
+
+2002-05-22  Werner Koch  <wk@gnupg.org>
+
+	* util.h: Add strncasecmp.  Removed stricmp and memicmp.
+
+2002-05-10  Stefan Bellon  <sbellon@sbellon.de>
+
+	* mpi.h: New function mpi_debug_alloc_like for M_DEBUG.
+
+	* util.h [__riscos__]: Make use of __func__ that later
+	Norcroft compiler provides.
+
+	* memory.h: Fixed wrong definition of m_alloc_secure_clear.
+
+2002-04-23  David Shaw  <dshaw@jabberwocky.com>
+
+	* util.h: New function answer_is_yes_no_default() to give a
+	default answer.
+
+2002-04-22  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Removed riscos_open, riscos_fopen and
+	riscos_fstat as those special versions aren't needed anymore.
+
+2002-02-19  David Shaw  <dshaw@jabberwocky.com>
+
+	* keyserver.h: Add KEYSERVER_NOT_SUPPORTED for unsupported actions
+	(say, a keyserver that has no way to search, or a readonly
+	keyserver that has no way to add).
+
+2002-01-02  Stefan Bellon  <sbellon@sbellon.de>
+
+	* util.h [__riscos__]: Updated prototype list.
+
+	* types.h [__riscos__]: Changed comment wording.
+
+2001-12-27  David Shaw  <dshaw@jabberwocky.com>
+
+	* KEYSERVER_SCHEME_NOT_FOUND should be 127 to match the POSIX
+	system() (via /bin/sh) way of signaling this.
+	
+	* Added G10ERR_KEYSERVER
+
+2001-12-27  Werner Koch  <wk@gnupg.org>
+
+	* util.h [MINGW32]: Fixed name of include file.
+
+2001-12-22  Timo Schulz <ts@winpt.org>
+
+        * util.h (is_file_compressed): New.
+
+2001-12-19  Werner Koch  <wk@gnupg.org>
+
+	* util.h [CYGWIN32]: Allow this as an alias for MINGW32. Include
+	stdarg.h becuase we use the va_list type.  By Disastry.
+
+2001-09-28  Werner Koch  <wk@gnupg.org>
+
+	* cipher.h (PUBKEY_USAGE_CERT): New.
+
+2001-09-07  Werner Koch  <wk@gnupg.org>
+
+	* util.h: Add strsep().
+
+2001-08-30  Werner Koch  <wk@gnupg.org>
+
+	* cipher.h (DEK): Added use_mdc.
+
+2001-08-24  Werner Koch  <wk@gnupg.org>
+
+	* cipher.h (md_write): Made buf arg const. 
+
+2001-08-20  Werner Koch  <wk@gnupg.org>
+
+	* cipher.h (DEK): Added algo_info_printed;
+
+	* util.h [__riscos__]: Added prototypes and made sure that we
+	never use __attribute__.
+	* cipher.h, iobuf.h, memory.h, mpi.h [__riscos__]: extern hack.
+	* i18n.h [__riscos__]: Use another include file
+	
+2001-05-30  Werner Koch  <wk@gnupg.org>
+
+	* ttyio.h (tty_printf): Add missing parenthesis for non gcc.
+	* http.h: Removed trailing comma to make old ccs happy.  Both are
+	by Albert Chin.
+
+2001-05-25  Werner Koch  <wk@gnupg.org>
+
+	* ttyio.h (tty_printf): Add printf attribute.
+
+2001-04-23  Werner Koch  <wk@gnupg.org>
+
+	* http.h: New flag HTTP_FLAG_NO_SHUTDOWN.
+
+2001-04-13  Werner Koch  <wk@gnupg.org>
+
+	* iobuf.h: Removed iobuf_fopen.
+
+2001-03-01  Werner Koch  <wk@gnupg.org>
+
+	* errors.h (G10ERR_UNU_SECKEY,G10ERR_UNU_PUBKEY): New
+
+2000-11-30  Werner Koch  <wk@gnupg.org>
+
+	* iobuf.h (iobuf_translate_file_handle): Add prototype.
+
+2000-11-11  Paul Eggert  <eggert@twinsun.com>
+
+        * iobuf.h (iobuf_get_filelength): Now returns off_t, not u32.
+        (struct iobuf_struct, iobuf_set_limit,
+        iobuf_tell, iobuf_seek): Use off_t, not ulong, for file offsets.
+
+2000-10-12  Werner Koch  <wk@gnupg.org>
+
+	* mpi.h: Changed the way mpi_limb_t is defined.
+
+Wed Sep  6 17:55:47 CEST 2000  Werner Koch  <wk@openit.de>
+
+        * iobuf.c (IOBUF_FILELENGTH_LIMIT): New.
+
+2000-03-14 14:03:43  Werner Koch  (wk@habibti.openit.de)
+
+	* types.h (HAVE_U64_TYPEDEF): Defined depending on configure test.
+
+Thu Jan 13 19:31:58 CET 2000  Werner Koch  <wk@gnupg.de>
+
+	* types.h (HAVE_U64_TYPEDEF): Add a test for _LONGLONG which fixes
+	this long living SGI bug.  Reported by Alec Habig.
+
+Sat Dec  4 12:30:28 CET 1999  Werner Koch  <wk@gnupg.de>
+
+	* iobuf.h (IOBUFCTRL_CANCEL): Nww.
+
+Mon Oct  4 21:23:04 CEST 1999  Werner Koch  <wk@gnupg.de>
+
+	* errors.h (G10ERR_NOT_PROCESSED): New.
+
+Wed Sep 15 16:22:17 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+
+	* i18n.h: Add support for simple-gettext.
+
+Tue Jun 29 21:44:25 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+
+	* util.h (stricmp): Use strcasecmp as replacement.
+
+Sat Jun 26 12:15:59 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+
+	* cipher.h (MD_HANDLE): Assigned a structure name.
+
+Fri Apr  9 12:26:25 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* cipher.h (BLOWFISH160): Removed.
+
+Tue Apr  6 19:58:12 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* cipher.h (DEK): increased max. key length to 32 bytes
+
+
+Sat Feb 20 21:40:49 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* g10lib.h: Removed file and changed all files that includes this.
+
+Tue Feb 16 14:10:02 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* types.h (STRLIST): Add field flags.
+
+Wed Feb 10 17:15:39 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* cipher.h (CIPHER_ALGO_TWOFISH): Chnaged ID to 10 and renamed
+	the old experimenatl algorithm to xx_OLD.
+
+Thu Jan  7 18:00:58 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* cipher.h (MD_BUFFER_SIZE): Removed.
+
+Mon Dec 14 21:18:49 CET 1998  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* types.h: fix for SUNPRO_C
+
+Tue Dec  8 13:15:16 CET 1998  Werner Koch  <wk@isil.d.shuttle.de>
+
+	* mpi.h (MPI): Changed the structure name to gcry_mpi and
+	changed all users.
+
+Tue Oct 20 11:40:00 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* iobuf.h (iobuf_get_temp_buffer): New.
+
+Tue Oct 13 12:40:48 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* iobuf.h (iobuf_get): Now uses .nofast
+	(iobuf_get2): Removed.
+
+Mon Sep 14 09:17:22 1998  Werner Koch  (wk@(none))
+
+	* util.h (HAVE_ATEXIT): New.
+	(HAVE_RAISE): New.
+
+Mon Jul  6 10:41:55 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h (PUBKEY_USAGE_): New.
+
+Mon Jul  6 09:49:51 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* iobuf.h (iobuf_set_error): New.
+	(iobuf_error): New.
+
+Sat Jun 13 17:31:32 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* g10lib.h: New as interface for the g10lib.
+
+Mon Jun  8 22:14:48 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h (CIPHER_ALGO_CAST5): Changed name from .. CAST
+
+Thu May 21 13:25:51 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h: removed ROT 5 and changed one id and add dummy
+
+Tue May 19 18:09:05 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h (DIGEST_ALGO_TIGER): Chnaged id from 101 to 6.
+
+Mon May  4 16:37:17 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h (PUBKEY_ALGO_ELGAMAL_E): New, with value of the
+	old one.
+	* (is_ELGAMAL, is_RSA): New macros
+
+Sun Apr 26 14:35:24 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* types.h: New type u64
+
+Mon Mar  9 12:59:55 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h: Included dsa.h.
+
+Tue Mar  3 15:11:21 1998  Werner Koch  (wk@isil.d.shuttle.de)
+
+	* cipher.h (random.h): Add new header and move all relevalt
+	functions to this header.
+
+
+ Copyright 1998, 1999, 2000, 2001, 2002, 2003,
+	   2004, 2005 Free Software Foundation, Inc.
+
+ This file is free software; as a special exception the author gives
+ unlimited permission to copy and/or distribute it, with or without
+ modifications, as long as this notice is preserved.
+
+ This file is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
diff --git a/include/_regex.h b/include/_regex.h
new file mode 100644
index 0000000..88acc35
--- /dev/null
+++ b/include/_regex.h
@@ -0,0 +1,574 @@
+/* Definitions for data structures and routines for the regular
+   expression library.
+   Copyright (C) 1985,1989-93,1995-98,2000,2001,2002
+   Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02110-1301 USA.  */
+
+#ifndef _REGEX_H
+#define _REGEX_H 1
+
+/* Allow the use in C++ code.  */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* POSIX says that <sys/types.h> must be included (by the caller) before
+   <regex.h>.  */
+
+#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
+/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
+   should be there.  */
+# include <stddef.h>
+#endif
+
+/* The following two types have to be signed and unsigned integer type
+   wide enough to hold a value of a pointer.  For most ANSI compilers
+   ptrdiff_t and size_t should be likely OK.  Still size of these two
+   types is 2 for Microsoft C.  Ugh... */
+typedef long int s_reg_t;
+typedef unsigned long int active_reg_t;
+
+/* The following bits are used to determine the regexp syntax we
+   recognize.  The set/not-set meanings are chosen so that Emacs syntax
+   remains the value 0.  The bits are given in alphabetical order, and
+   the definitions shifted by one from the previous bit; thus, when we
+   add or remove a bit, only one other definition need change.  */
+typedef unsigned long int reg_syntax_t;
+
+/* If this bit is not set, then \ inside a bracket expression is literal.
+   If set, then such a \ quotes the following character.  */
+#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)
+
+/* If this bit is not set, then + and ? are operators, and \+ and \? are
+     literals.
+   If set, then \+ and \? are operators and + and ? are literals.  */
+#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)
+
+/* If this bit is set, then character classes are supported.  They are:
+     [:alpha:], [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
+     [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
+   If not set, then character classes are not supported.  */
+#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)
+
+/* If this bit is set, then ^ and $ are always anchors (outside bracket
+     expressions, of course).
+   If this bit is not set, then it depends:
+        ^  is an anchor if it is at the beginning of a regular
+           expression or after an open-group or an alternation operator;
+        $  is an anchor if it is at the end of a regular expression, or
+           before a close-group or an alternation operator.
+
+   This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
+   POSIX draft 11.2 says that * etc. in leading positions is undefined.
+   We already implemented a previous draft which made those constructs
+   invalid, though, so we haven't changed the code back.  */
+#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)
+
+/* If this bit is set, then special characters are always special
+     regardless of where they are in the pattern.
+   If this bit is not set, then special characters are special only in
+     some contexts; otherwise they are ordinary.  Specifically,
+     * + ? and intervals are only special when not after the beginning,
+     open-group, or alternation operator.  */
+#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)
+
+/* If this bit is set, then *, +, ?, and { cannot be first in an re or
+     immediately after an alternation or begin-group operator.  */
+#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)
+
+/* If this bit is set, then . matches newline.
+   If not set, then it doesn't.  */
+#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)
+
+/* If this bit is set, then . doesn't match NUL.
+   If not set, then it does.  */
+#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)
+
+/* If this bit is set, nonmatching lists [^...] do not match newline.
+   If not set, they do.  */
+#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)
+
+/* If this bit is set, either \{...\} or {...} defines an
+     interval, depending on RE_NO_BK_BRACES.
+   If not set, \{, \}, {, and } are literals.  */
+#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)
+
+/* If this bit is set, +, ? and | aren't recognized as operators.
+   If not set, they are.  */
+#define RE_LIMITED_OPS (RE_INTERVALS << 1)
+
+/* If this bit is set, newline is an alternation operator.
+   If not set, newline is literal.  */
+#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)
+
+/* If this bit is set, then `{...}' defines an interval, and \{ and \}
+     are literals.
+  If not set, then `\{...\}' defines an interval.  */
+#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)
+
+/* If this bit is set, (...) defines a group, and \( and \) are literals.
+   If not set, \(...\) defines a group, and ( and ) are literals.  */
+#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)
+
+/* If this bit is set, then \<digit> matches <digit>.
+   If not set, then \<digit> is a back-reference.  */
+#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)
+
+/* If this bit is set, then | is an alternation operator, and \| is literal.
+   If not set, then \| is an alternation operator, and | is literal.  */
+#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)
+
+/* If this bit is set, then an ending range point collating higher
+     than the starting range point, as in [z-a], is invalid.
+   If not set, then when ending range point collates higher than the
+     starting range point, the range is ignored.  */
+#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)
+
+/* If this bit is set, then an unmatched ) is ordinary.
+   If not set, then an unmatched ) is invalid.  */
+#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)
+
+/* If this bit is set, succeed as soon as we match the whole pattern,
+   without further backtracking.  */
+#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)
+
+/* If this bit is set, do not process the GNU regex operators.
+   If not set, then the GNU regex operators are recognized. */
+#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)
+
+/* If this bit is set, turn on internal regex debugging.
+   If not set, and debugging was on, turn it off.
+   This only works if regex.c is compiled -DDEBUG.
+   We define this bit always, so that all that's needed to turn on
+   debugging is to recompile regex.c; the calling code can always have
+   this bit set, and it won't affect anything in the normal case. */
+#define RE_DEBUG (RE_NO_GNU_OPS << 1)
+
+/* If this bit is set, a syntactically invalid interval is treated as
+   a string of ordinary characters.  For example, the ERE 'a{1' is
+   treated as 'a\{1'.  */
+#define RE_INVALID_INTERVAL_ORD (RE_DEBUG << 1)
+
+/* If this bit is set, then ignore case when matching.
+   If not set, then case is significant.  */
+#define RE_ICASE (RE_INVALID_INTERVAL_ORD << 1)
+
+/* This global variable defines the particular regexp syntax to use (for
+   some interfaces).  When a regexp is compiled, the syntax used is
+   stored in the pattern buffer, so changing this does not affect
+   already-compiled regexps.  */
+extern reg_syntax_t re_syntax_options;
+
+/* Define combinations of the above bits for the standard possibilities.
+   (The [[[ comments delimit what gets put into the Texinfo file, so
+   don't delete them!)  */
+/* [[[begin syntaxes]]] */
+#define RE_SYNTAX_EMACS 0
+
+#define RE_SYNTAX_AWK							\
+  (RE_BACKSLASH_ESCAPE_IN_LISTS   | RE_DOT_NOT_NULL			\
+   | RE_NO_BK_PARENS              | RE_NO_BK_REFS			\
+   | RE_NO_BK_VBAR                | RE_NO_EMPTY_RANGES			\
+   | RE_DOT_NEWLINE		  | RE_CONTEXT_INDEP_ANCHORS		\
+   | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)
+
+#define RE_SYNTAX_GNU_AWK						\
+  ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG)	\
+   & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS		\
+       | RE_CONTEXT_INVALID_OPS ))
+
+#define RE_SYNTAX_POSIX_AWK 						\
+  (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS		\
+   | RE_INTERVALS	    | RE_NO_GNU_OPS)
+
+#define RE_SYNTAX_GREP							\
+  (RE_BK_PLUS_QM              | RE_CHAR_CLASSES				\
+   | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS				\
+   | RE_NEWLINE_ALT)
+
+#define RE_SYNTAX_EGREP							\
+  (RE_CHAR_CLASSES        | RE_CONTEXT_INDEP_ANCHORS			\
+   | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE			\
+   | RE_NEWLINE_ALT       | RE_NO_BK_PARENS				\
+   | RE_NO_BK_VBAR)
+
+#define RE_SYNTAX_POSIX_EGREP						\
+  (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES			\
+   | RE_INVALID_INTERVAL_ORD)
+
+/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff.  */
+#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC
+
+#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC
+
+/* Syntax bits common to both basic and extended POSIX regex syntax.  */
+#define _RE_SYNTAX_POSIX_COMMON						\
+  (RE_CHAR_CLASSES | RE_DOT_NEWLINE      | RE_DOT_NOT_NULL		\
+   | RE_INTERVALS  | RE_NO_EMPTY_RANGES)
+
+#define RE_SYNTAX_POSIX_BASIC						\
+  (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)
+
+/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
+   RE_LIMITED_OPS, i.e., \? \+ \| are not recognized.  Actually, this
+   isn't minimal, since other operators, such as \`, aren't disabled.  */
+#define RE_SYNTAX_POSIX_MINIMAL_BASIC					\
+  (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)
+
+#define RE_SYNTAX_POSIX_EXTENDED					\
+  (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS			\
+   | RE_CONTEXT_INDEP_OPS   | RE_NO_BK_BRACES				\
+   | RE_NO_BK_PARENS        | RE_NO_BK_VBAR				\
+   | RE_CONTEXT_INVALID_OPS | RE_UNMATCHED_RIGHT_PAREN_ORD)
+
+/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INDEP_OPS is
+   removed and RE_NO_BK_REFS is added.  */
+#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED				\
+  (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS			\
+   | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES				\
+   | RE_NO_BK_PARENS        | RE_NO_BK_REFS				\
+   | RE_NO_BK_VBAR	    | RE_UNMATCHED_RIGHT_PAREN_ORD)
+/* [[[end syntaxes]]] */
+
+/* Maximum number of duplicates an interval can allow.  Some systems
+   (erroneously) define this in other header files, but we want our
+   value, so remove any previous define.  */
+#ifdef RE_DUP_MAX
+# undef RE_DUP_MAX
+#endif
+/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows.  */
+#define RE_DUP_MAX (0x7fff)
+
+
+/* POSIX `cflags' bits (i.e., information for `regcomp').  */
+
+/* If this bit is set, then use extended regular expression syntax.
+   If not set, then use basic regular expression syntax.  */
+#define REG_EXTENDED 1
+
+/* If this bit is set, then ignore case when matching.
+   If not set, then case is significant.  */
+#define REG_ICASE (REG_EXTENDED << 1)
+
+/* If this bit is set, then anchors do not match at newline
+     characters in the string.
+   If not set, then anchors do match at newlines.  */
+#define REG_NEWLINE (REG_ICASE << 1)
+
+/* If this bit is set, then report only success or fail in regexec.
+   If not set, then returns differ between not matching and errors.  */
+#define REG_NOSUB (REG_NEWLINE << 1)
+
+
+/* POSIX `eflags' bits (i.e., information for regexec).  */
+
+/* If this bit is set, then the beginning-of-line operator doesn't match
+     the beginning of the string (presumably because it's not the
+     beginning of a line).
+   If not set, then the beginning-of-line operator does match the
+     beginning of the string.  */
+#define REG_NOTBOL 1
+
+/* Like REG_NOTBOL, except for the end-of-line.  */
+#define REG_NOTEOL (1 << 1)
+
+
+/* If any error codes are removed, changed, or added, update the
+   `re_error_msg' table in regex.c.  */
+typedef enum
+{
+#ifdef _XOPEN_SOURCE
+  REG_ENOSYS = -1,	/* This will never happen for this implementation.  */
+#endif
+
+  REG_NOERROR = 0,	/* Success.  */
+  REG_NOMATCH,		/* Didn't find a match (for regexec).  */
+
+  /* POSIX regcomp return error codes.  (In the order listed in the
+     standard.)  */
+  REG_BADPAT,		/* Invalid pattern.  */
+  REG_ECOLLATE,		/* Not implemented.  */
+  REG_ECTYPE,		/* Invalid character class name.  */
+  REG_EESCAPE,		/* Trailing backslash.  */
+  REG_ESUBREG,		/* Invalid back reference.  */
+  REG_EBRACK,		/* Unmatched left bracket.  */
+  REG_EPAREN,		/* Parenthesis imbalance.  */
+  REG_EBRACE,		/* Unmatched \{.  */
+  REG_BADBR,		/* Invalid contents of \{\}.  */
+  REG_ERANGE,		/* Invalid range end.  */
+  REG_ESPACE,		/* Ran out of memory.  */
+  REG_BADRPT,		/* No preceding re for repetition op.  */
+
+  /* Error codes we've added.  */
+  REG_EEND,		/* Premature end.  */
+  REG_ESIZE,		/* Compiled pattern bigger than 2^16 bytes.  */
+  REG_ERPAREN		/* Unmatched ) or \); not returned from regcomp.  */
+} reg_errcode_t;
+
+/* This data structure represents a compiled pattern.  Before calling
+   the pattern compiler, the fields `buffer', `allocated', `fastmap',
+   `translate', and `no_sub' can be set.  After the pattern has been
+   compiled, the `re_nsub' field is available.  All other fields are
+   private to the regex routines.  */
+
+#ifndef RE_TRANSLATE_TYPE
+# define RE_TRANSLATE_TYPE char *
+#endif
+
+struct re_pattern_buffer
+{
+/* [[[begin pattern_buffer]]] */
+	/* Space that holds the compiled pattern.  It is declared as
+          `unsigned char *' because its elements are
+           sometimes used as array indexes.  */
+  unsigned char *buffer;
+
+	/* Number of bytes to which `buffer' points.  */
+  unsigned long int allocated;
+
+	/* Number of bytes actually used in `buffer'.  */
+  unsigned long int used;
+
+        /* Syntax setting with which the pattern was compiled.  */
+  reg_syntax_t syntax;
+
+        /* Pointer to a fastmap, if any, otherwise zero.  re_search uses
+           the fastmap, if there is one, to skip over impossible
+           starting points for matches.  */
+  char *fastmap;
+
+        /* Either a translate table to apply to all characters before
+           comparing them, or zero for no translation.  The translation
+           is applied to a pattern when it is compiled and to a string
+           when it is matched.  */
+  RE_TRANSLATE_TYPE translate;
+
+	/* Number of subexpressions found by the compiler.  */
+  size_t re_nsub;
+
+        /* Zero if this pattern cannot match the empty string, one else.
+           Well, in truth it's used only in `re_search_2', to see
+           whether or not we should use the fastmap, so we don't set
+           this absolutely perfectly; see `re_compile_fastmap' (the
+           `duplicate' case).  */
+  unsigned can_be_null : 1;
+
+        /* If REGS_UNALLOCATED, allocate space in the `regs' structure
+             for `max (RE_NREGS, re_nsub + 1)' groups.
+           If REGS_REALLOCATE, reallocate space if necessary.
+           If REGS_FIXED, use what's there.  */
+#define REGS_UNALLOCATED 0
+#define REGS_REALLOCATE 1
+#define REGS_FIXED 2
+  unsigned regs_allocated : 2;
+
+        /* Set to zero when `regex_compile' compiles a pattern; set to one
+           by `re_compile_fastmap' if it updates the fastmap.  */
+  unsigned fastmap_accurate : 1;
+
+        /* If set, `re_match_2' does not return information about
+           subexpressions.  */
+  unsigned no_sub : 1;
+
+        /* If set, a beginning-of-line anchor doesn't match at the
+           beginning of the string.  */
+  unsigned not_bol : 1;
+
+        /* Similarly for an end-of-line anchor.  */
+  unsigned not_eol : 1;
+
+        /* If true, an anchor at a newline matches.  */
+  unsigned newline_anchor : 1;
+
+/* [[[end pattern_buffer]]] */
+};
+
+typedef struct re_pattern_buffer regex_t;
+
+/* Type for byte offsets within the string.  POSIX mandates this.  */
+typedef int regoff_t;
+
+
+/* This is the structure we store register match data in.  See
+   regex.texinfo for a full description of what registers match.  */
+struct re_registers
+{
+  unsigned num_regs;
+  regoff_t *start;
+  regoff_t *end;
+};
+
+
+/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
+   `re_match_2' returns information about at least this many registers
+   the first time a `regs' structure is passed.  */
+#ifndef RE_NREGS
+# define RE_NREGS 30
+#endif
+
+
+/* POSIX specification for registers.  Aside from the different names than
+   `re_registers', POSIX uses an array of structures, instead of a
+   structure of arrays.  */
+typedef struct
+{
+  regoff_t rm_so;  /* Byte offset from string's start to substring's start.  */
+  regoff_t rm_eo;  /* Byte offset from string's start to substring's end.  */
+} regmatch_t;
+
+/* Declarations for routines.  */
+
+/* To avoid duplicating every routine declaration -- once with a
+   prototype (if we are ANSI), and once without (if we aren't) -- we
+   use the following macro to declare argument types.  This
+   unfortunately clutters up the declarations a bit, but I think it's
+   worth it.  */
+
+#if __STDC__
+
+# define _RE_ARGS(args) args
+
+#else /* not __STDC__ */
+
+# define _RE_ARGS(args) ()
+
+#endif /* not __STDC__ */
+
+/* Sets the current default syntax to SYNTAX, and return the old syntax.
+   You can also simply assign to the `re_syntax_options' variable.  */
+extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
+
+/* Compile the regular expression PATTERN, with length LENGTH
+   and syntax given by the global `re_syntax_options', into the buffer
+   BUFFER.  Return NULL if successful, and an error string if not.  */
+extern const char *re_compile_pattern
+  _RE_ARGS ((const char *pattern, size_t length,
+             struct re_pattern_buffer *buffer));
+
+
+/* Compile a fastmap for the compiled pattern in BUFFER; used to
+   accelerate searches.  Return 0 if successful and -2 if was an
+   internal error.  */
+extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
+
+
+/* Search in the string STRING (with length LENGTH) for the pattern
+   compiled into BUFFER.  Start searching at position START, for RANGE
+   characters.  Return the starting position of the match, -1 for no
+   match, or -2 for an internal error.  Also return register
+   information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
+extern int re_search
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+            int length, int start, int range, struct re_registers *regs));
+
+
+/* Like `re_search', but search in the concatenation of STRING1 and
+   STRING2.  Also, stop searching at index START + STOP.  */
+extern int re_search_2
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+             int length1, const char *string2, int length2,
+             int start, int range, struct re_registers *regs, int stop));
+
+
+/* Like `re_search', but return how many characters in STRING the regexp
+   in BUFFER matched, starting at position START.  */
+extern int re_match
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+             int length, int start, struct re_registers *regs));
+
+
+/* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
+extern int re_match_2
+  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+             int length1, const char *string2, int length2,
+             int start, struct re_registers *regs, int stop));
+
+
+/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
+   ENDS.  Subsequent matches using BUFFER and REGS will use this memory
+   for recording register information.  STARTS and ENDS must be
+   allocated with malloc, and must each be at least `NUM_REGS * sizeof
+   (regoff_t)' bytes long.
+
+   If NUM_REGS == 0, then subsequent matches should allocate their own
+   register data.
+
+   Unless this function is called, the first search or match using
+   PATTERN_BUFFER will allocate its own register data, without
+   freeing the old data.  */
+extern void re_set_registers
+  _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
+             unsigned num_regs, regoff_t *starts, regoff_t *ends));
+
+#if defined _REGEX_RE_COMP || defined _LIBC
+# ifndef _CRAY
+/* 4.2 bsd compatibility.  */
+extern char *re_comp _RE_ARGS ((const char *));
+extern int re_exec _RE_ARGS ((const char *));
+# endif
+#endif
+
+/* GCC 2.95 and later have "__restrict"; C99 compilers have
+   "restrict", and "configure" may have defined "restrict".  */
+#ifndef __restrict
+# if ! (2 < __GNUC__ || (2 == __GNUC__ && 95 <= __GNUC_MINOR__))
+#  if defined restrict || 199901L <= __STDC_VERSION__
+#   define __restrict restrict
+#  else
+#   define __restrict
+#  endif
+# endif
+#endif
+/* gcc 3.1 and up support the [restrict] syntax.  */
+#ifndef __restrict_arr
+# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1)
+#  define __restrict_arr __restrict
+# else
+#  define __restrict_arr
+# endif
+#endif
+
+/* POSIX compatibility.  */
+extern int regcomp _RE_ARGS ((regex_t *__restrict __preg,
+			      const char *__restrict __pattern,
+			      int __cflags));
+
+extern int regexec _RE_ARGS ((const regex_t *__restrict __preg,
+			      const char *__restrict __string, size_t __nmatch,
+			      regmatch_t __pmatch[__restrict_arr],
+			      int __eflags));
+
+extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
+				  char *__errbuf, size_t __errbuf_size));
+
+extern void regfree _RE_ARGS ((regex_t *__preg));
+
+
+#ifdef __cplusplus
+}
+#endif	/* C++ */
+
+#endif /* regex.h */
+
+/*
+Local variables:
+make-backup-files: t
+version-control: t
+trim-versions-without-asking: nil
+End:
+*/
diff --git a/include/assuan.h b/include/assuan.h
new file mode 100644
index 0000000..683f55b
--- /dev/null
+++ b/include/assuan.h
@@ -0,0 +1,262 @@
+/* assuan.c - Definitions for the Assuan protocol
+ *	Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+ *	Copyright (C) 2005 Free Software Foundation, Inc.
+ *
+ * This file is part of Assuan.
+ *
+ * Assuan is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * Assuan is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA. 
+ */
+
+/* Please note that this is a stripped down and modified version of
+   the orginal Assuan code from libassuan.  For the standalone version
+   of gnupg we only need the ability to connect to a server, so we
+   dropped everything else and maintain this separate copy. */
+
+#ifndef ASSUAN_H
+#define ASSUAN_H
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+typedef enum
+{
+  ASSUAN_No_Error = 0,
+  ASSUAN_General_Error = 1,
+  ASSUAN_Out_Of_Core = 2,
+  ASSUAN_Invalid_Value = 3,
+  ASSUAN_Timeout = 4,
+  ASSUAN_Read_Error = 5,
+  ASSUAN_Write_Error = 6,
+  ASSUAN_Problem_Starting_Server = 7,
+  ASSUAN_Not_A_Server = 8,
+  ASSUAN_Not_A_Client = 9,
+  ASSUAN_Nested_Commands = 10,
+  ASSUAN_Invalid_Response = 11,
+  ASSUAN_No_Data_Callback = 12,
+  ASSUAN_No_Inquire_Callback = 13,
+  ASSUAN_Connect_Failed = 14,
+  ASSUAN_Accept_Failed = 15,
+
+  /* Error codes above 99 are meant as status codes */
+  ASSUAN_Not_Implemented = 100,
+  ASSUAN_Server_Fault    = 101,
+  ASSUAN_Invalid_Command = 102,
+  ASSUAN_Unknown_Command = 103,
+  ASSUAN_Syntax_Error    = 104,
+  ASSUAN_Parameter_Error = 105,
+  ASSUAN_Parameter_Conflict = 106,
+  ASSUAN_Line_Too_Long = 107,
+  ASSUAN_Line_Not_Terminated = 108,
+  ASSUAN_No_Input = 109,
+  ASSUAN_No_Output = 110,
+  ASSUAN_Canceled = 111,
+  ASSUAN_Unsupported_Algorithm = 112,
+  ASSUAN_Server_Resource_Problem = 113,
+  ASSUAN_Server_IO_Error = 114,
+  ASSUAN_Server_Bug = 115,
+  ASSUAN_No_Data_Available = 116,
+  ASSUAN_Invalid_Data = 117,
+  ASSUAN_Unexpected_Command = 118,
+  ASSUAN_Too_Much_Data = 119,
+  ASSUAN_Inquire_Unknown = 120,
+  ASSUAN_Inquire_Error = 121,
+  ASSUAN_Invalid_Option = 122,
+  ASSUAN_Invalid_Index = 123,
+  ASSUAN_Unexpected_Status = 124,
+  ASSUAN_Unexpected_Data = 125,
+  ASSUAN_Invalid_Status = 126,
+  ASSUAN_Locale_Problem = 127,
+  ASSUAN_Not_Confirmed = 128,
+
+  /* Error codes in the range 1000 to 9999 may be used by applications
+     at their own discretion. */
+  ASSUAN_USER_ERROR_FIRST = 1000,
+  ASSUAN_USER_ERROR_LAST = 9999
+
+} assuan_error_t;
+
+
+#define ASSUAN_LINELENGTH 1002 /* 1000 + [CR,]LF */
+
+struct assuan_context_s;
+typedef struct assuan_context_s *assuan_context_t;
+
+/*-- assuan-handler.c --*/
+int assuan_register_command (assuan_context_t ctx,
+                             const char *cmd_string,
+                             int (*handler)(assuan_context_t, char *));
+int assuan_register_bye_notify (assuan_context_t ctx,
+                                void (*fnc)(assuan_context_t));
+int assuan_register_reset_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t));
+int assuan_register_cancel_notify (assuan_context_t ctx,
+                                   void (*fnc)(assuan_context_t));
+int assuan_register_input_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t, const char *));
+int assuan_register_output_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t, const char *));
+
+int assuan_register_option_handler (assuan_context_t ctx,
+                                    int (*fnc)(assuan_context_t,
+                                               const char*, const char*));
+
+int assuan_process (assuan_context_t ctx);
+int assuan_process_next (assuan_context_t ctx);
+int assuan_get_active_fds (assuan_context_t ctx, int what,
+                           int *fdarray, int fdarraysize);
+
+
+FILE *assuan_get_data_fp (assuan_context_t ctx);
+assuan_error_t assuan_set_okay_line (assuan_context_t ctx, const char *line);
+assuan_error_t assuan_write_status (assuan_context_t ctx,
+                                    const char *keyword, const char *text);
+
+/* Negotiate a file descriptor.  If LINE contains "FD=N", returns N
+   assuming a local file descriptor.  If LINE contains "FD" reads a
+   file descriptor via CTX and stores it in *RDF (the CTX must be
+   capable of passing file descriptors).  */
+assuan_error_t assuan_command_parse_fd (assuan_context_t ctx, char *line,
+				     int *rfd);
+
+/*-- assuan-listen.c --*/
+assuan_error_t assuan_set_hello_line (assuan_context_t ctx, const char *line);
+assuan_error_t assuan_accept (assuan_context_t ctx);
+int assuan_get_input_fd (assuan_context_t ctx);
+int assuan_get_output_fd (assuan_context_t ctx);
+assuan_error_t assuan_close_input_fd (assuan_context_t ctx);
+assuan_error_t assuan_close_output_fd (assuan_context_t ctx);
+
+
+/*-- assuan-pipe-server.c --*/
+int assuan_init_pipe_server (assuan_context_t *r_ctx, int filedes[2]);
+void assuan_deinit_server (assuan_context_t ctx);
+
+/*-- assuan-socket-server.c --*/
+int assuan_init_socket_server (assuan_context_t *r_ctx, int listen_fd);
+int assuan_init_connected_socket_server (assuan_context_t *r_ctx, int fd);
+
+
+/*-- assuan-pipe-connect.c --*/
+assuan_error_t assuan_pipe_connect (assuan_context_t *ctx, const char *name,
+                                 char *const argv[], int *fd_child_list);
+assuan_error_t assuan_pipe_connect2 (assuan_context_t *ctx, const char *name,
+                                     char *const argv[], int *fd_child_list,
+                                     void (*atfork) (void*, int),
+                                     void *atforkvalue);
+/*-- assuan-socket-connect.c --*/
+assuan_error_t assuan_socket_connect (assuan_context_t *ctx, const char *name,
+                                      pid_t server_pid);
+
+/*-- assuan-domain-connect.c --*/
+
+/* Connect to a Unix domain socket server.  RENDEZVOUSFD is
+   bidirectional file descriptor (normally returned via socketpair)
+   which the client can use to rendezvous with the server.  SERVER s
+   the server's pid.  */
+assuan_error_t assuan_domain_connect (assuan_context_t *r_ctx,
+				   int rendezvousfd,
+				   pid_t server);
+
+/*-- assuan-domain-server.c --*/
+
+/* RENDEZVOUSFD is a bidirectional file descriptor (normally returned
+   via socketpair) that the domain server can use to rendezvous with
+   the client.  CLIENT is the client's pid.  */
+assuan_error_t assuan_init_domain_server (assuan_context_t *r_ctx,
+				       int rendezvousfd,
+				       pid_t client);
+
+
+/*-- assuan-connect.c --*/
+void assuan_disconnect (assuan_context_t ctx);
+pid_t assuan_get_pid (assuan_context_t ctx);
+
+/*-- assuan-client.c --*/
+assuan_error_t 
+assuan_transact (assuan_context_t ctx,
+                 const char *command,
+                 assuan_error_t (*data_cb)(void *, const void *, size_t),
+                 void *data_cb_arg,
+                 assuan_error_t (*inquire_cb)(void*, const char *),
+                 void *inquire_cb_arg,
+                 assuan_error_t (*status_cb)(void*, const char *),
+                 void *status_cb_arg);
+assuan_error_t 
+assuan_transact2 (assuan_context_t ctx,
+                  const char *command,
+                  assuan_error_t (*data_cb)(void *, const void *, size_t),
+                  void *data_cb_arg,
+                  assuan_error_t (*inquire_cb)(void*, const char *),
+                  void *inquire_cb_arg,
+                  assuan_error_t (*status_cb)(void*, const char *),
+                  void *status_cb_arg,
+                  assuan_error_t (*okay_cb)(void*, const char *),
+                  void *okay_cb_arg);
+
+
+/*-- assuan-inquire.c --*/
+assuan_error_t assuan_inquire (assuan_context_t ctx, const char *keyword,
+                            unsigned char **r_buffer, size_t *r_length,
+                            size_t maxlen);
+
+/*-- assuan-buffer.c --*/
+assuan_error_t assuan_read_line (assuan_context_t ctx,
+                              char **line, size_t *linelen);
+int assuan_pending_line (assuan_context_t ctx);
+assuan_error_t assuan_write_line (assuan_context_t ctx, const char *line );
+assuan_error_t assuan_send_data (assuan_context_t ctx,
+                              const void *buffer, size_t length);
+
+/*-- assuan-util.c --*/
+void assuan_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
+                               void *(*new_realloc_func)(void *p, size_t n),
+                               void (*new_free_func)(void*) );
+void assuan_set_log_stream (assuan_context_t ctx, FILE *fp);
+int assuan_set_error (assuan_context_t ctx, int err, const char *text);
+void assuan_set_pointer (assuan_context_t ctx, void *pointer);
+void *assuan_get_pointer (assuan_context_t ctx);
+
+void assuan_begin_confidential (assuan_context_t ctx);
+void assuan_end_confidential (assuan_context_t ctx);
+
+/*-- assuan-errors.c (built) --*/
+const char *assuan_strerror (assuan_error_t err);
+
+/*-- assuan-logging.c --*/
+
+/* Set the stream to which assuan should log message not associated
+   with a context.  By default, this is stderr.  The default value
+   will be changed when the first log stream is associated with a
+   context.  Note, that this function is not thread-safe and should
+   in general be used right at startup. */
+extern void assuan_set_assuan_log_stream (FILE *fp);
+
+/* Return the stream which is currently being using for global logging.  */
+extern FILE *assuan_get_assuan_log_stream (void);
+
+/* Set the prefix to be used at the start of a line emitted by assuan
+   on the log stream.  The default is the empty string.  Note, that
+   this function is not thread-safe and should in general be used
+   right at startup. */
+void assuan_set_assuan_log_prefix (const char *text);
+
+/* Return a prefix to be used at the start of a line emitted by assuan
+   on the log stream.  The default implementation returns the empty
+   string, i.e. ""  */
+const char *assuan_get_assuan_log_prefix (void);
+
+#endif /* ASSUAN_H */
diff --git a/include/cipher.h b/include/cipher.h
new file mode 100644
index 0000000..5b531cc
--- /dev/null
+++ b/include/cipher.h
@@ -0,0 +1,209 @@
+/* cipher.h
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+ *               2006 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+#ifndef G10_CIPHER_H
+#define G10_CIPHER_H
+
+#define DBG_CIPHER g10c_debug_mode
+
+#include "mpi.h"
+#include "../cipher/random.h"
+
+
+#define CIPHER_ALGO_NONE	 0
+#define CIPHER_ALGO_IDEA	 1
+#define CIPHER_ALGO_3DES	 2
+#define CIPHER_ALGO_CAST5	 3
+#define CIPHER_ALGO_BLOWFISH	 4  /* blowfish 128 bit key */
+/* 5 & 6 are reserved */
+#define CIPHER_ALGO_AES          7
+#define CIPHER_ALGO_AES192       8
+#define CIPHER_ALGO_AES256       9
+#define CIPHER_ALGO_TWOFISH 	10  /* twofish 256 bit */
+#define CIPHER_ALGO_DUMMY      110  /* no encryption at all */
+
+#define PUBKEY_ALGO_RSA        1
+#define PUBKEY_ALGO_RSA_E      2     /* RSA encrypt only */
+#define PUBKEY_ALGO_RSA_S      3     /* RSA sign only */
+#define PUBKEY_ALGO_ELGAMAL_E 16     /* encrypt only ElGamal (but not for v3)*/
+#define PUBKEY_ALGO_DSA       17
+#define PUBKEY_ALGO_ELGAMAL   20     /* sign and encrypt elgamal */
+
+#define PUBKEY_USAGE_SIG     1	    /* key is good for signatures */
+#define PUBKEY_USAGE_ENC     2	    /* key is good for encryption */
+#define PUBKEY_USAGE_CERT    4      /* key is also good to certify other keys*/
+#define PUBKEY_USAGE_AUTH    8      /* key is good for authentication */
+#define PUBKEY_USAGE_UNKNOWN 128    /* key has an unknown usage bit */
+
+#define DIGEST_ALGO_MD5       1
+#define DIGEST_ALGO_SHA1      2
+#define DIGEST_ALGO_RMD160    3
+/* 4, 5, 6, and 7 are reserved */
+#define DIGEST_ALGO_SHA256    8
+#define DIGEST_ALGO_SHA384    9
+#define DIGEST_ALGO_SHA512   10
+#define DIGEST_ALGO_SHA224   11
+
+#define COMPRESS_ALGO_NONE   0
+#define COMPRESS_ALGO_ZIP    1
+#define COMPRESS_ALGO_ZLIB   2
+#define COMPRESS_ALGO_BZIP2  3
+
+#define is_RSA(a)     ((a)==PUBKEY_ALGO_RSA || (a)==PUBKEY_ALGO_RSA_E \
+		       || (a)==PUBKEY_ALGO_RSA_S )
+#define is_ELGAMAL(a) ((a)==PUBKEY_ALGO_ELGAMAL_E)
+#define is_DSA(a)     ((a)==PUBKEY_ALGO_DSA)
+
+typedef struct
+{
+  int algo;
+  int keylen;
+  int algo_info_printed;
+  int use_mdc;
+  int symmetric;
+  byte key[32]; /* this is the largest used keylen (256 bit) */
+} DEK;
+
+struct cipher_handle_s;
+typedef struct cipher_handle_s *CIPHER_HANDLE;
+
+
+#define CIPHER_MODE_ECB       1
+#define CIPHER_MODE_CFB       2
+#define CIPHER_MODE_PHILS_CFB 3
+#define CIPHER_MODE_AUTO_CFB  4
+#define CIPHER_MODE_DUMMY     5  /* used with algo DUMMY for no encryption */
+#define CIPHER_MODE_CBC       6
+
+struct md_digest_list_s;
+
+struct gcry_md_context {
+    int  secure;
+    FILE  *debug;
+    int finalized;
+    struct md_digest_list_s *list;
+    int  bufcount;
+    int  bufsize;
+    byte buffer[1];
+};
+
+typedef struct gcry_md_context *MD_HANDLE;
+
+#ifndef EXTERN_UNLESS_MAIN_MODULE
+#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
+#define EXTERN_UNLESS_MAIN_MODULE extern
+#else
+#define EXTERN_UNLESS_MAIN_MODULE 
+#endif
+#endif
+EXTERN_UNLESS_MAIN_MODULE int g10c_debug_mode;
+EXTERN_UNLESS_MAIN_MODULE int g10_opt_verbose;
+EXTERN_UNLESS_MAIN_MODULE const char *g10_opt_homedir;
+
+
+/*-- dynload.c --*/
+void register_cipher_extension( const char *mainpgm, const char *fname );
+
+/*-- md.c --*/
+int string_to_digest_algo( const char *string );
+const char * digest_algo_to_string( int algo );
+int check_digest_algo( int algo );
+MD_HANDLE md_open( int algo, int secure );
+void md_enable( MD_HANDLE hd, int algo );
+MD_HANDLE md_copy( MD_HANDLE a );
+void md_reset( MD_HANDLE a );
+void md_close(MD_HANDLE a);
+void md_write( MD_HANDLE a, const byte *inbuf, size_t inlen);
+void md_final(MD_HANDLE a);
+byte *md_read( MD_HANDLE a, int algo );
+int md_digest( MD_HANDLE a, int algo, byte *buffer, int buflen );
+int md_get_algo( MD_HANDLE a );
+int md_algo_present( MD_HANDLE a, int algo );
+int md_digest_length( int algo );
+const byte *md_asn_oid( int algo, size_t *asnlen, size_t *mdlen );
+void md_start_debug( MD_HANDLE a, const char *suffix );
+void md_stop_debug( MD_HANDLE a );
+#define md_is_secure(a) ((a)->secure)
+#define md_putc(h,c)  \
+	    do {					    \
+		if( (h)->bufcount == (h)->bufsize )	    \
+		    md_write( (h), NULL, 0 );		    \
+		(h)->buffer[(h)->bufcount++] = (c) & 0xff;  \
+	    } while(0)
+
+void rmd160_hash_buffer (char *outbuf, const char *buffer, size_t length);
+
+
+/*-- cipher.c --*/
+int string_to_cipher_algo( const char *string );
+const char * cipher_algo_to_string( int algo );
+void disable_cipher_algo( int algo );
+int check_cipher_algo( int algo );
+unsigned cipher_get_keylen( int algo );
+unsigned cipher_get_blocksize( int algo );
+CIPHER_HANDLE cipher_open( int algo, int mode, int secure );
+void cipher_close( CIPHER_HANDLE c );
+int  cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen );
+void cipher_setiv( CIPHER_HANDLE c, const byte *iv, unsigned ivlen );
+void cipher_encrypt( CIPHER_HANDLE c, byte *out, byte *in, unsigned nbytes );
+void cipher_decrypt( CIPHER_HANDLE c, byte *out, byte *in, unsigned nbytes );
+void cipher_sync( CIPHER_HANDLE c );
+
+/*-- pubkey.c --*/
+#define PUBKEY_MAX_NPKEY  4
+#define PUBKEY_MAX_NSKEY  6
+#define PUBKEY_MAX_NSIG   2
+#define PUBKEY_MAX_NENC   2
+
+int string_to_pubkey_algo( const char *string );
+const char * pubkey_algo_to_string( int algo );
+void disable_pubkey_algo( int algo );
+int check_pubkey_algo( int algo );
+int check_pubkey_algo2( int algo, unsigned use );
+int pubkey_get_npkey( int algo );
+int pubkey_get_nskey( int algo );
+int pubkey_get_nsig( int algo );
+int pubkey_get_nenc( int algo );
+unsigned pubkey_nbits( int algo, MPI *pkey );
+int pubkey_generate( int algo, unsigned nbits, MPI *skey, MPI **retfactors );
+int dsa2_generate( int algo, unsigned nbits, unsigned qbits,
+		   MPI *skey, MPI **retfactors );
+int pubkey_check_secret_key( int algo, MPI *skey );
+int pubkey_encrypt( int algo, MPI *resarr, MPI data, MPI *pkey );
+int pubkey_decrypt( int algo, MPI *result, MPI *data, MPI *skey );
+int pubkey_sign( int algo, MPI *resarr, MPI hash, MPI *skey );
+int pubkey_verify( int algo, MPI hash, MPI *data, MPI *pkey );
+
+/*-- smallprime.c --*/
+extern ushort small_prime_numbers[];
+
+/*-- primegen.c --*/
+void register_primegen_progress ( void (*cb)( void *, int), void *cb_data );
+MPI generate_secret_prime( unsigned nbits );
+MPI generate_public_prime( unsigned nbits );
+MPI generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
+					   MPI g, MPI **factors );
+
+/*-- elsewhere --*/
+void register_pk_dsa_progress ( void (*cb)( void *, int), void *cb_data );
+void register_pk_elg_progress ( void (*cb)( void *, int), void *cb_data );
+
+#endif /*G10_CIPHER_H*/
diff --git a/include/compat.h b/include/compat.h
new file mode 100644
index 0000000..f971ffa
--- /dev/null
+++ b/include/compat.h
@@ -0,0 +1,14 @@
+#ifndef _COMPAT_H_
+#define _COMPAT_H_
+
+/* Note this isn't identical to a C locale isspace() without \f and
+   \v, but works for the purposes used here. */
+#define ascii_isspace(a) ((a)==' ' || (a)=='\n' || (a)=='\r' || (a)=='\t')
+
+int hextobyte( const char *s );
+
+#ifndef HAVE_STRSEP
+char *strsep (char **stringp, const char *delim);
+#endif
+
+#endif /* !_COMPAT_H_ */
diff --git a/include/distfiles b/include/distfiles
new file mode 100644
index 0000000..1f85370
--- /dev/null
+++ b/include/distfiles
@@ -0,0 +1,18 @@
+cipher.h
+errors.h
+iobuf.h
+memory.h
+mpi.h
+ttyio.h
+types.h
+util.h
+i18n.h
+host2net.h
+http.h
+keyserver.h
+_regex.h
+dynload.h
+assuan.h
+compat.h
+
+ChangeLog
diff --git a/include/dynload.h b/include/dynload.h
new file mode 100644
index 0000000..acdf5c8
--- /dev/null
+++ b/include/dynload.h
@@ -0,0 +1,72 @@
+/* dlfcn.h - W32 functions for run-time dynamic loading
+ *      Copyright (C) 2003 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef GNUPG_DYNLOAD_H
+#define GNUPG_DYNLOAD_H
+#if defined (ENABLE_CARD_SUPPORT) || defined(_WIN32)
+#ifndef _WIN32
+#include <dlfcn.h>
+#else
+#include <windows.h>
+
+#define RTLD_LAZY 0
+
+static __inline__ void *
+dlopen (const char * name, int flag)
+{
+  void * hd = LoadLibrary (name);
+  return hd;
+}
+
+static __inline__ void *
+dlsym (void * hd, const char * sym)
+{
+  if (hd && sym)
+    {
+      void * fnc = GetProcAddress (hd, sym);
+      if (!fnc)
+        return NULL;
+      return fnc;
+    }
+  return NULL;
+}
+
+
+static __inline__ const char *
+dlerror (void)
+{
+  return w32_strerror (0);
+}
+
+
+static __inline__ int
+dlclose (void * hd)
+{
+  if (hd)
+    {
+      FreeLibrary (hd);
+      return 0;
+    }
+  return -1;
+}  
+#endif /*_WIN32*/
+#endif /*ENABLE_CARD_SUPPORT||_WIN32*/
+#endif /*GNUPG_DYNLOAD_H*/
diff --git a/include/errors.h b/include/errors.h
new file mode 100644
index 0000000..177353b
--- /dev/null
+++ b/include/errors.h
@@ -0,0 +1,91 @@
+/* errors.h - erro code
+ *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+#ifndef G10_ERRORS_H
+#define G10_ERRORS_H
+
+#define G10ERR_GENERAL	       1
+#define G10ERR_UNKNOWN_PACKET  2
+#define G10ERR_UNKNOWN_VERSION 3 /* Unknown version (in packet) */
+#define G10ERR_PUBKEY_ALGO     4 /* Unknown pubkey algorithm */
+#define G10ERR_DIGEST_ALGO     5 /* Unknown digest algorithm */
+#define G10ERR_BAD_PUBKEY      6 /* Bad public key */
+#define G10ERR_BAD_SECKEY      7 /* Bad secret key */
+#define G10ERR_BAD_SIGN        8 /* Bad signature */
+#define G10ERR_NO_PUBKEY       9 /* public key not found */
+#define G10ERR_CHECKSUM       10 /* checksum error */
+#define G10ERR_BAD_PASS       11 /* Bad passphrase */
+#define G10ERR_CIPHER_ALGO    12 /* Unknown cipher algorithm */
+#define G10ERR_KEYRING_OPEN   13
+#define G10ERR_INVALID_PACKET 14
+#define G10ERR_INVALID_ARMOR  15
+#define G10ERR_NO_USER_ID     16
+#define G10ERR_NO_SECKEY      17 /* secret key not available */
+#define G10ERR_WRONG_SECKEY   18 /* wrong seckey used */
+#define G10ERR_UNSUPPORTED    19
+#define G10ERR_BAD_KEY	      20 /* bad (session) key */
+#define G10ERR_READ_FILE      21
+#define G10ERR_WRITE_FILE     22
+#define G10ERR_COMPR_ALGO     23 /* Unknown compress algorithm */
+#define G10ERR_OPEN_FILE      24
+#define G10ERR_CREATE_FILE    25
+#define G10ERR_PASSPHRASE     26 /* invalid passphrase */
+#define G10ERR_NI_PUBKEY      27
+#define G10ERR_NI_CIPHER      28
+#define G10ERR_SIG_CLASS      29
+#define G10ERR_BAD_MPI	      30
+#define G10ERR_RESOURCE_LIMIT 31
+#define G10ERR_INV_KEYRING    32
+#define G10ERR_TRUSTDB	      33 /* a problem with the trustdb */
+#define G10ERR_BAD_CERT       34 /* bad certicate */
+#define G10ERR_INV_USER_ID    35
+#define G10ERR_CLOSE_FILE     36
+#define G10ERR_RENAME_FILE    37
+#define G10ERR_DELETE_FILE    38
+#define G10ERR_UNEXPECTED     39
+#define G10ERR_TIME_CONFLICT  40
+#define G10ERR_WR_PUBKEY_ALGO 41 /* unusabe pubkey algo */
+#define G10ERR_FILE_EXISTS    42
+#define G10ERR_WEAK_KEY       43 /* NOTE: hardcoded into the cipher modules */
+#define G10ERR_WRONG_KEYLEN   44 /* NOTE: hardcoded into the cipher modules */
+#define G10ERR_INV_ARG	      45
+#define G10ERR_BAD_URI	      46  /* syntax error in URI */
+#define G10ERR_INVALID_URI    47  /* e.g. unsupported scheme */
+#define G10ERR_NETWORK	      48  /* general network error */
+#define G10ERR_UNKNOWN_HOST   49
+#define G10ERR_SELFTEST_FAILED 50
+#define G10ERR_NOT_ENCRYPTED  51
+#define G10ERR_NOT_PROCESSED  52
+#define G10ERR_UNU_PUBKEY     53
+#define G10ERR_UNU_SECKEY     54
+#define G10ERR_KEYSERVER      55
+#define G10ERR_CANCELED       56
+#define G10ERR_NO_CARD        57
+#define G10ERR_NO_DATA        58
+
+#ifndef HAVE_STRERROR
+char *strerror (int n);
+#endif
+
+#ifdef _WIN32
+const char * w32_strerror (int w32_errno);
+#endif
+
+#endif /*G10_ERRORS_H*/
diff --git a/include/host2net.h b/include/host2net.h
new file mode 100644
index 0000000..d72b828
--- /dev/null
+++ b/include/host2net.h
@@ -0,0 +1,44 @@
+/* host2net.h - Some macros
+ *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_HOST2NET_H
+#define G10_HOST2NET_H
+
+#include "types.h"
+
+#define buftoulong( p )  ((*(byte*)(p) << 24) | (*((byte*)(p)+1)<< 16) | \
+		       (*((byte*)(p)+2) << 8) | (*((byte*)(p)+3)))
+#define buftoushort( p )  ((*((byte*)(p)) << 8) | (*((byte*)(p)+1)))
+#define ulongtobuf( p, a ) do { 			  \
+			    ((byte*)p)[0] = a >> 24;	\
+			    ((byte*)p)[1] = a >> 16;	\
+			    ((byte*)p)[2] = a >>  8;	\
+			    ((byte*)p)[3] = a	   ;	\
+			} while(0)
+#define ushorttobuf( p, a ) do {			   \
+			    ((byte*)p)[0] = a >>  8;	\
+			    ((byte*)p)[1] = a	   ;	\
+			} while(0)
+#define buftou32( p)	buftoulong( (p) )
+#define u32tobuf( p, a) ulongtobuf( (p), (a) )
+
+
+#endif /*G10_HOST2NET_H*/
diff --git a/include/http.h b/include/http.h
new file mode 100644
index 0000000..060b5b8
--- /dev/null
+++ b/include/http.h
@@ -0,0 +1,87 @@
+/* http.h  -  HTTP protocol handler
+ * Copyright (C) 1999, 2000, 2001, 2003, 2004,
+ *               2005 Free Software Foundation, Inc.
+ *
+ * This file is part of GnuPG.
+ *
+ * GnuPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GnuPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_HTTP_H
+#define G10_HTTP_H 1
+
+#include "iobuf.h"
+
+struct uri_tuple {
+    struct uri_tuple *next;
+    const char *name;	/* a pointer into name */
+    char  *value;	/* a pointer to value (a Nul is always appended) */
+    size_t valuelen;	/* and the real length of the value */
+			/* because the value may contain embedded Nuls */
+};
+typedef struct uri_tuple *URI_TUPLE;
+
+struct parsed_uri {
+    /* all these pointers point into buffer; most stuff is not escaped */
+    char *scheme;	/* pointer to the scheme string (lowercase) */
+    char *auth;         /* username/password for basic auth */
+    char *host; 	/* host (converted to lowercase) */
+    ushort port;	/* port (always set if the host is set) */
+    char *path; 	/* the path */
+    URI_TUPLE params;	/* ";xxxxx" */
+    URI_TUPLE query;	/* "?xxx=yyy" */
+    char buffer[1];	/* buffer which holds a (modified) copy of the URI */
+};
+typedef struct parsed_uri *PARSED_URI;
+
+typedef enum {
+    HTTP_REQ_GET  = 1,
+    HTTP_REQ_HEAD = 2,
+    HTTP_REQ_POST = 3
+} HTTP_REQ_TYPE;
+
+/* put flag values into an enum, so that gdb can display them */
+enum
+  { 
+    HTTP_FLAG_NO_SHUTDOWN = 1,
+    HTTP_FLAG_TRY_SRV = 2
+  };
+
+struct http_context {
+    int initialized;
+    unsigned int status_code;
+    int sock;
+    int in_data;
+    IOBUF fp_read;
+    IOBUF fp_write;
+    int is_http_0_9;
+    PARSED_URI uri;
+    HTTP_REQ_TYPE req_type;
+    byte *buffer;	   /* line buffer */
+    unsigned buffer_size;
+    unsigned int flags;
+};
+typedef struct http_context *HTTP_HD;
+
+int http_open( HTTP_HD hd, HTTP_REQ_TYPE reqtype, const char *url,
+	       char *auth, unsigned int flags, const char *proxy );
+void http_start_data( HTTP_HD hd );
+int  http_wait_response( HTTP_HD hd, unsigned int *ret_status );
+void http_close( HTTP_HD hd );
+int http_open_document( HTTP_HD hd, const char *document, char *auth,
+			unsigned int flags, const char *proxy );
+
+#endif /*G10_HTTP_H*/
diff --git a/include/i18n.h b/include/i18n.h
new file mode 100644
index 0000000..6abd2dc
--- /dev/null
+++ b/include/i18n.h
@@ -0,0 +1,55 @@
+/* i18n.h
+ *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_I18N_H
+#define G10_I18N_H
+
+#ifdef USE_SIMPLE_GETTEXT
+int set_gettext_file( const char *filename, const char *regkey );
+const char *gettext( const char *msgid );
+
+#define _(a) gettext (a)
+#define N_(a) (a)
+
+#else
+#ifdef HAVE_LOCALE_H
+#include <locale.h>	/* suggested by Ernst Molitor */
+#endif
+
+#ifdef ENABLE_NLS
+#ifndef __riscos__
+#include <libintl.h>
+#else
+#include "libgettext.h"
+#endif /* __riscos__ */
+#define _(a) gettext (a)
+#ifdef gettext_noop
+#define N_(a) gettext_noop (a)
+#else
+#define N_(a) (a)
+#endif
+#else
+#define _(a) (a)
+#define N_(a) (a)
+#endif
+#endif /* !USE_SIMPLE_GETTEXT */
+
+#endif /*G10_I18N_H*/
diff --git a/include/iobuf.h b/include/iobuf.h
new file mode 100644
index 0000000..a1d58c9
--- /dev/null
+++ b/include/iobuf.h
@@ -0,0 +1,163 @@
+/* iobuf.h - I/O buffer
+ * Copyright (C) 1998, 1999, 2000, 2001, 2004 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_IOBUF_H
+#define G10_IOBUF_H
+
+#include "types.h"
+
+
+#define DBG_IOBUF   iobuf_debug_mode
+
+#define IOBUFCTRL_INIT	    1
+#define IOBUFCTRL_FREE	    2
+#define IOBUFCTRL_UNDERFLOW 3
+#define IOBUFCTRL_FLUSH     4
+#define IOBUFCTRL_DESC	    5
+#define IOBUFCTRL_CANCEL    6
+#define IOBUFCTRL_USER	    16
+
+typedef struct iobuf_struct *IOBUF;
+typedef struct iobuf_struct *iobuf_t;
+
+/* fixme: we should hide most of this stuff */
+struct iobuf_struct {
+    int use;	       /* 1 input , 2 output, 3 temp */
+    off_t nlimit;
+    off_t nbytes;      /* used together with nlimit */
+    off_t ntotal;      /* total bytes read (position of stream) */
+    int nofast; 	/* used by the iobuf_get() */
+    void *directfp;
+    struct {
+	size_t size;   /* allocated size */
+	size_t start;  /* number of invalid bytes at the begin of the buffer */
+	size_t len;    /* currently filled to this size */
+	byte *buf;
+    } d;
+    int filter_eof;
+    int error;
+    int (*filter)( void *opaque, int control,
+		   IOBUF chain, byte *buf, size_t *len);
+    void *filter_ov;	/* value for opaque */
+    int filter_ov_owner;
+    char *real_fname;
+    IOBUF chain;	/* next iobuf used for i/o if any (passed to filter) */
+    int no, subno;
+    const char *desc;
+    void *opaque;      /* can be used to hold any information	 */
+		       /* this value is copied to all instances */
+    struct {
+	size_t size;   /* allocated size */
+	size_t start;  /* number of invalid bytes at the begin of the buffer */
+	size_t len;    /* currently filled to this size */
+	byte *buf;
+    } unget;
+};
+
+#ifndef EXTERN_UNLESS_MAIN_MODULE
+#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
+#define EXTERN_UNLESS_MAIN_MODULE extern
+#else
+#define EXTERN_UNLESS_MAIN_MODULE 
+#endif
+#endif
+EXTERN_UNLESS_MAIN_MODULE int iobuf_debug_mode;
+
+void  iobuf_enable_special_filenames ( int yes );
+int   iobuf_is_pipe_filename (const char *fname);
+IOBUF iobuf_alloc(int use, size_t bufsize);
+IOBUF iobuf_temp(void);
+IOBUF iobuf_temp_with_content( const char *buffer, size_t length );
+IOBUF iobuf_open( const char *fname );
+IOBUF iobuf_fdopen( int fd, const char *mode );
+IOBUF iobuf_sockopen( int fd, const char *mode );
+IOBUF iobuf_create( const char *fname );
+IOBUF iobuf_append( const char *fname );
+IOBUF iobuf_openrw( const char *fname );
+int   iobuf_ioctl ( IOBUF a, int cmd, int intval, void *ptrval );
+int   iobuf_close( IOBUF iobuf );
+int   iobuf_cancel( IOBUF iobuf );
+
+int iobuf_push_filter( IOBUF a, int (*f)(void *opaque, int control,
+		       IOBUF chain, byte *buf, size_t *len), void *ov );
+int iobuf_push_filter2( IOBUF a,
+		    int (*f)(void *opaque, int control,
+		    IOBUF chain, byte *buf, size_t *len),
+		    void *ov, int rel_ov );
+int iobuf_flush(IOBUF a);
+void iobuf_clear_eof(IOBUF a);
+#define iobuf_set_error(a)    do { (a)->error = 1; } while(0)
+#define iobuf_error(a)	      ((a)->error)
+
+void iobuf_set_limit( IOBUF a, off_t nlimit );
+
+off_t iobuf_tell( IOBUF a );
+int   iobuf_seek( IOBUF a, off_t newpos );
+
+int  iobuf_readbyte(IOBUF a);
+int  iobuf_read(IOBUF a, byte *buf, unsigned buflen );
+unsigned iobuf_read_line( IOBUF a, byte **addr_of_buffer,
+			  unsigned *length_of_buffer, unsigned *max_length );
+int  iobuf_peek(IOBUF a, byte *buf, unsigned buflen );
+int  iobuf_writebyte(IOBUF a, unsigned c);
+int  iobuf_write(IOBUF a, byte *buf, unsigned buflen );
+int  iobuf_writestr(IOBUF a, const char *buf );
+
+void iobuf_flush_temp( IOBUF temp );
+int  iobuf_write_temp( IOBUF a, IOBUF temp );
+size_t iobuf_temp_to_buffer( IOBUF a, byte *buffer, size_t buflen );
+void iobuf_unget_and_close_temp( IOBUF a, IOBUF temp );
+
+int  iobuf_get_fd (IOBUF a);
+off_t iobuf_get_filelength (IOBUF a, int *overflow);
+#define IOBUF_FILELENGTH_LIMIT 0xffffffff
+const char *iobuf_get_real_fname( IOBUF a );
+const char *iobuf_get_fname( IOBUF a );
+
+void iobuf_set_partial_block_mode( IOBUF a, size_t len );
+
+int iobuf_translate_file_handle ( int fd, int for_write );
+
+/* Get a byte form the iobuf; must check for eof prior to this function.
+ * This function returns values in the range 0 .. 255 or -1 to indicate EOF
+ * iobuf_get_noeof() does not return -1 to indicate EOF, but masks the
+ * returned value to be in the range 0..255.
+ */
+#define iobuf_get(a)  \
+     (	((a)->nofast || (a)->d.start >= (a)->d.len )?  \
+	iobuf_readbyte((a)) : ( (a)->nbytes++, (a)->d.buf[(a)->d.start++] ) )
+#define iobuf_get_noeof(a)    (iobuf_get((a))&0xff)
+
+/* write a byte to the iobuf and return true on write error
+ * This macro does only write the low order byte
+ */
+#define iobuf_put(a,c)	iobuf_writebyte(a,c)
+
+#define iobuf_where(a)	"[don't know]"
+#define iobuf_id(a)	((a)->no)
+
+#define iobuf_get_temp_buffer(a) ( (a)->d.buf )
+#define iobuf_get_temp_length(a) ( (a)->d.len )
+#define iobuf_is_temp(a)	 ( (a)->use == 3 )
+
+void iobuf_skip_rest (IOBUF a, unsigned long n, int partial);
+
+#endif /*G10_IOBUF_H*/
diff --git a/include/keyserver.h b/include/keyserver.h
new file mode 100644
index 0000000..8900dbe
--- /dev/null
+++ b/include/keyserver.h
@@ -0,0 +1,44 @@
+/* keyserver.h
+ * Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef _KEYSERVER_H_
+#define _KEYSERVER_H_
+
+#define KEYSERVER_PROTO_VERSION    1
+
+/* These are usable for return codes for the gpgkeys_ process, and
+   also KEY FAILED codes. */
+#define KEYSERVER_OK               0 /* not an error */
+#define KEYSERVER_INTERNAL_ERROR   1 /* gpgkeys_ internal error */
+#define KEYSERVER_NOT_SUPPORTED    2 /* operation not supported */
+#define KEYSERVER_VERSION_ERROR    3 /* VERSION mismatch */
+#define KEYSERVER_GENERAL_ERROR    4 /* keyserver internal error */
+#define KEYSERVER_NO_MEMORY        5 /* out of memory */
+#define KEYSERVER_KEY_NOT_FOUND    6 /* key not found */
+#define KEYSERVER_KEY_EXISTS       7 /* key already exists */
+#define KEYSERVER_KEY_INCOMPLETE   8 /* key incomplete (EOF) */
+#define KEYSERVER_UNREACHABLE      9 /* unable to contact keyserver */
+#define KEYSERVER_TIMEOUT         10 /* timeout while accessing keyserver */
+
+/* Must be 127 due to shell internal magic. */
+#define KEYSERVER_SCHEME_NOT_FOUND 127
+
+#endif /* !_KEYSERVER_H_ */
diff --git a/include/memory.h b/include/memory.h
new file mode 100644
index 0000000..895d8a7
--- /dev/null
+++ b/include/memory.h
@@ -0,0 +1,101 @@
+/* memory.h - memory allocation
+ * Copyright (C) 1998, 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_MEMORY_H
+#define G10_MEMORY_H
+
+#ifdef M_DEBUG
+#ifndef STR
+#define STR(v) #v
+#endif
+#ifndef __riscos__
+#define M_DBGINFO(a)	    __FUNCTION__ "["__FILE__ ":"  STR(a) "]"
+#else /* __riscos__ */
+#define M_DBGINFO(a)	     "["__FILE__ ":"  STR(a) "]"
+#endif /* __riscos__ */
+#define xmalloc(n)		m_debug_alloc((n), M_DBGINFO( __LINE__ ) )
+#define xmalloc_clear(n)	m_debug_alloc_clear((n), M_DBGINFO(__LINE__) )
+#define xmalloc_secure(n)	m_debug_alloc_secure(n), M_DBGINFO(__LINE__) )
+#define xmalloc_secure_clear(n) m_debug_alloc_secure_clear((n), M_DBGINFO(__LINE__) )
+#define xrealloc(n,m)		m_debug_realloc((n),(m), M_DBGINFO(__LINE__) )
+#define xfree(n)		m_debug_free((n), M_DBGINFO(__LINE__) )
+#define m_check(n)		m_debug_check((n), M_DBGINFO(__LINE__) )
+/*#define m_copy(a)		  m_debug_copy((a), M_DBGINFO(__LINE__) )*/
+#define xstrdup(a)		m_debug_strdup((a), M_DBGINFO(__LINE__) )
+
+void *m_debug_alloc( size_t n, const char *info );
+void *m_debug_alloc_clear( size_t n, const char *info  );
+void *m_debug_alloc_secure( size_t n, const char *info	);
+void *m_debug_alloc_secure_clear( size_t n, const char *info  );
+void *m_debug_realloc( void *a, size_t n, const char *info  );
+void m_debug_free( void *p, const char *info  );
+void m_debug_check( const void *a, const char *info );
+/*void *m_debug_copy( const void *a, const char *info );*/
+char *m_debug_strdup( const char *a, const char *info );
+
+#else
+void *xmalloc( size_t n );
+void *xmalloc_clear( size_t n );
+void *xmalloc_secure( size_t n );
+void *xmalloc_secure_clear( size_t n );
+void *xrealloc( void *a, size_t n );
+void xfree( void *p );
+void m_check( const void *a );
+/*void *m_copy( const void *a );*/
+char *xstrdup( const char * a);
+#endif
+
+size_t m_size( const void *a );
+void m_print_stats(const char *prefix);
+
+/* The follwing functions should be preferred over xmalloc_clear. */
+void *xcalloc (size_t n, size_t m);
+void *xcalloc_secure (size_t n, size_t m);
+
+
+/*-- secmem.c --*/
+int secmem_init( size_t npool );
+void secmem_term( void );
+void *secmem_malloc( size_t size );
+void *secmexrealloc( void *a, size_t newsize );
+void secmem_free( void *a );
+int  m_is_secure( const void *p );
+void secmem_dump_stats(void);
+void secmem_set_flags( unsigned flags );
+unsigned secmem_get_flags(void);
+
+
+#define DBG_MEMORY    memory_debug_mode
+#define DBG_MEMSTAT   memory_stat_debug_mode
+
+#ifndef EXTERN_UNLESS_MAIN_MODULE
+#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
+#define EXTERN_UNLESS_MAIN_MODULE extern
+#else
+#define EXTERN_UNLESS_MAIN_MODULE 
+#endif
+#endif
+EXTERN_UNLESS_MAIN_MODULE int memory_debug_mode;
+EXTERN_UNLESS_MAIN_MODULE int memory_stat_debug_mode;
+
+
+
+#endif /*G10_MEMORY_H*/
diff --git a/include/mpi.h b/include/mpi.h
new file mode 100644
index 0000000..bec37ce
--- /dev/null
+++ b/include/mpi.h
@@ -0,0 +1,197 @@
+/* mpi.h  -  Multi Precision Integers
+ *	Copyright (C) 1994, 1996, 1998, 1999,
+ *                    2000, 2001 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ *
+ * Note: This code is heavily based on the GNU MP Library.
+ *	 Actually it's the same code with only minor changes in the
+ *	 way the data is stored; this is to support the abstraction
+ *	 of an optional secure memory allocation which may be used
+ *	 to avoid revealing of sensitive data due to paging etc.
+ *	 The GNU MP Library itself is published under the LGPL;
+ *	 however I decided to publish this code under the plain GPL.
+ */
+
+#ifndef G10_MPI_H
+#define G10_MPI_H
+
+#include <config.h>
+#include <stdio.h>
+#include "iobuf.h"
+#include "types.h"
+#include "memory.h"
+
+#if BYTES_PER_MPI_LIMB == SIZEOF_UNSIGNED_INT
+  typedef unsigned int mpi_limb_t;
+  typedef   signed int mpi_limb_signed_t;
+#elif BYTES_PER_MPI_LIMB == SIZEOF_UNSIGNED_LONG
+  typedef unsigned long int mpi_limb_t;
+  typedef   signed long int mpi_limb_signed_t;
+#elif BYTES_PER_MPI_LIMB == SIZEOF_UNSIGNED_LONG_LONG
+  typedef unsigned long long int mpi_limb_t;
+  typedef   signed long long int mpi_limb_signed_t;
+#elif BYTES_PER_MPI_LIMB == SIZEOF_UNSIGNED_SHORT
+  typedef unsigned short int mpi_limb_t;
+  typedef   signed short int mpi_limb_signed_t;
+#else
+#error BYTES_PER_MPI_LIMB does not match any C type
+#endif
+#define BITS_PER_MPI_LIMB    (8*BYTES_PER_MPI_LIMB)
+
+#ifndef EXTERN_UNLESS_MAIN_MODULE
+#if defined (__riscos__) && !defined (INCLUDED_BY_MAIN_MODULE)
+#define EXTERN_UNLESS_MAIN_MODULE extern
+#else
+#define EXTERN_UNLESS_MAIN_MODULE 
+#endif
+#endif
+
+#define DBG_MPI     mpi_debug_mode
+EXTERN_UNLESS_MAIN_MODULE int mpi_debug_mode;
+
+
+struct gcry_mpi {
+    int alloced;    /* array size (# of allocated limbs) */
+    int nlimbs;     /* number of valid limbs */
+    unsigned int nbits; /* the real number of valid bits (info only) */
+    int sign;	    /* indicates a negative number */
+    unsigned flags; /* bit 0: array must be allocated in secure memory space */
+		    /* bit 1: not used */
+		    /* bit 2: the limb is a pointer to some xmalloced data */
+    mpi_limb_t *d;  /* array with the limbs */
+};
+
+typedef struct gcry_mpi *MPI;
+
+#define MPI_NULL NULL
+
+#define mpi_get_nlimbs(a)     ((a)->nlimbs)
+#define mpi_is_neg(a)	      ((a)->sign)
+
+/*-- mpiutil.c --*/
+
+#ifdef M_DEBUG
+#define mpi_alloc(n)	      mpi_debug_alloc((n), M_DBGINFO( __LINE__ ) )
+#define mpi_alloc_secure(n) mpi_debug_alloc_secure((n), M_DBGINFO( __LINE__ ) )
+#define mpi_alloc_like(n)   mpi_debug_alloc_like((n), M_DBGINFO( __LINE__ ) )
+#define mpi_free(a)	      mpi_debug_free((a), M_DBGINFO(__LINE__) )
+#define mpi_resize(a,b)     mpi_debug_resize((a),(b), M_DBGINFO(__LINE__) )
+#define mpi_copy(a)	      mpi_debug_copy((a), M_DBGINFO(__LINE__) )
+MPI mpi_debug_alloc( unsigned nlimbs, const char *info );
+MPI mpi_debug_alloc_secure( unsigned nlimbs, const char *info );
+MPI mpi_debug_alloc_like( MPI a, const char *info );
+void mpi_debug_free( MPI a, const char *info );
+void mpi_debug_resize( MPI a, unsigned nlimbs, const char *info );
+MPI  mpi_debug_copy( MPI a, const char *info	);
+#else
+MPI mpi_alloc( unsigned nlimbs );
+MPI mpi_alloc_secure( unsigned nlimbs );
+MPI mpi_alloc_like( MPI a );
+void mpi_free( MPI a );
+void mpi_resize( MPI a, unsigned nlimbs );
+MPI  mpi_copy( MPI a );
+#endif
+#define mpi_is_opaque(a) ((a) && ((a)->flags&4))
+MPI mpi_set_opaque( MPI a, void *p, unsigned int len );
+void *mpi_get_opaque( MPI a, unsigned int *len );
+#define mpi_is_secure(a) ((a) && ((a)->flags&1))
+void mpi_set_secure( MPI a );
+void mpi_clear( MPI a );
+void mpi_set( MPI w, MPI u);
+void mpi_set_ui( MPI w, ulong u);
+MPI  mpi_alloc_set_ui( unsigned long u);
+void mpi_m_check( MPI a );
+void mpi_swap( MPI a, MPI b);
+
+/*-- mpicoder.c --*/
+int mpi_write( IOBUF out, MPI a );
+#ifdef M_DEBUG
+#define mpi_read(a,b,c)   mpi_debug_read((a),(b),(c),  M_DBGINFO( __LINE__ ) )
+MPI mpi_debug_read(IOBUF inp, unsigned *nread, int secure, const char *info);
+#else
+MPI mpi_read(IOBUF inp, unsigned *nread, int secure);
+#endif
+MPI mpi_read_from_buffer(byte *buffer, unsigned *ret_nread, int secure);
+int mpi_fromstr(MPI val, const char *str);
+int mpi_print( FILE *fp, MPI a, int mode );
+void g10_log_mpidump( const char *text, MPI a );
+u32 mpi_get_keyid( MPI a, u32 *keyid );
+byte *mpi_get_buffer( MPI a, unsigned *nbytes, int *sign );
+byte *mpi_get_secure_buffer( MPI a, unsigned *nbytes, int *sign );
+void  mpi_set_buffer( MPI a, const byte *buffer, unsigned nbytes, int sign );
+
+#define log_mpidump g10_log_mpidump
+
+/*-- mpi-add.c --*/
+void mpi_add_ui(MPI w, MPI u, ulong v );
+void mpi_add(MPI w, MPI u, MPI v);
+void mpi_addm(MPI w, MPI u, MPI v, MPI m);
+void mpi_sub_ui(MPI w, MPI u, ulong v );
+void mpi_sub( MPI w, MPI u, MPI v);
+void mpi_subm( MPI w, MPI u, MPI v, MPI m);
+
+/*-- mpi-mul.c --*/
+void mpi_mul_ui(MPI w, MPI u, ulong v );
+void mpi_mul_2exp( MPI w, MPI u, ulong cnt);
+void mpi_mul( MPI w, MPI u, MPI v);
+void mpi_mulm( MPI w, MPI u, MPI v, MPI m);
+
+/*-- mpi-div.c --*/
+ulong mpi_fdiv_r_ui( MPI rem, MPI dividend, ulong divisor );
+void  mpi_fdiv_r( MPI rem, MPI dividend, MPI divisor );
+void  mpi_fdiv_q( MPI quot, MPI dividend, MPI divisor );
+void  mpi_fdiv_qr( MPI quot, MPI rem, MPI dividend, MPI divisor );
+void  mpi_tdiv_r( MPI rem, MPI num, MPI den);
+void  mpi_tdiv_qr( MPI quot, MPI rem, MPI num, MPI den);
+void  mpi_tdiv_q_2exp( MPI w, MPI u, unsigned count );
+int   mpi_divisible_ui(MPI dividend, ulong divisor );
+
+/*-- mpi-gcd.c --*/
+int mpi_gcd( MPI g, MPI a, MPI b );
+
+/*-- mpi-pow.c --*/
+void mpi_pow( MPI w, MPI u, MPI v);
+void mpi_powm( MPI res, MPI base, MPI exponent, MPI mod);
+
+/*-- mpi-mpow.c --*/
+void mpi_mulpowm( MPI res, MPI *basearray, MPI *exparray, MPI mod);
+
+/*-- mpi-cmp.c --*/
+int mpi_cmp_ui( MPI u, ulong v );
+int mpi_cmp( MPI u, MPI v );
+
+/*-- mpi-scan.c --*/
+int mpi_getbyte( MPI a, unsigned idx );
+void mpi_putbyte( MPI a, unsigned idx, int value );
+unsigned mpi_trailing_zeros( MPI a );
+
+/*-- mpi-bit.c --*/
+void mpi_normalize( MPI a );
+unsigned mpi_get_nbits( MPI a );
+int  mpi_test_bit( MPI a, unsigned n );
+void mpi_set_bit( MPI a, unsigned n );
+void mpi_set_highbit( MPI a, unsigned n );
+void mpi_clear_highbit( MPI a, unsigned n );
+void mpi_clear_bit( MPI a, unsigned n );
+void mpi_rshift( MPI x, MPI a, unsigned n );
+
+/*-- mpi-inv.c --*/
+void mpi_invm( MPI x, MPI u, MPI v );
+
+#endif /*G10_MPI_H*/
diff --git a/include/ttyio.h b/include/ttyio.h
new file mode 100644
index 0000000..2c52fc3
--- /dev/null
+++ b/include/ttyio.h
@@ -0,0 +1,59 @@
+/* ttyio.h
+ * Copyright (C) 1998, 1999, 2000, 2001, 2005 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+#ifndef G10_TTYIO_H
+#define G10_TTYIO_H
+
+#ifdef HAVE_LIBREADLINE
+#include <stdio.h>
+#include <readline/readline.h>
+#endif
+
+const char *tty_get_ttyname (void);
+int tty_batchmode( int onoff );
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
+ void tty_printf (const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
+ void tty_fprintf (FILE *fp, const char *fmt, ... )
+                                __attribute__ ((format (printf,2,3)));
+#else
+ void tty_printf (const char *fmt, ... );
+ void tty_fprintf (FILE *fp, const char *fmt, ... );
+#endif
+void tty_print_string( const byte *p, size_t n );
+void tty_print_utf8_string( const byte *p, size_t n );
+void tty_print_utf8_string2( const byte *p, size_t n, size_t max_n );
+char *tty_get( const char *prompt );
+char *tty_get_hidden( const char *prompt );
+void tty_kill_prompt(void);
+int tty_get_answer_is_yes( const char *prompt );
+int tty_no_terminal(int onoff);
+
+#ifdef HAVE_LIBREADLINE
+void tty_enable_completion(rl_completion_func_t *completer);
+void tty_disable_completion(void);
+#else
+/* Use a macro to stub out these functions since a macro has no need
+   to typedef a "rl_completion_func_t" which would be undefined
+   without readline. */
+#define tty_enable_completion(x)
+#define tty_disable_completion()
+#endif
+
+#endif /*G10_TTYIO_H*/
diff --git a/include/types.h b/include/types.h
new file mode 100644
index 0000000..3b85b10
--- /dev/null
+++ b/include/types.h
@@ -0,0 +1,142 @@
+/* types.h - some common typedefs
+ *	Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+
+#ifndef G10_TYPES_H
+#define G10_TYPES_H
+
+#ifdef HAVE_INTTYPES_H
+/* For uint64_t */
+#include <inttypes.h>
+#endif
+
+/* The AC_CHECK_SIZEOF() in configure fails for some machines.
+ * we provide some fallback values here */
+#if !SIZEOF_UNSIGNED_SHORT
+#undef SIZEOF_UNSIGNED_SHORT
+#define SIZEOF_UNSIGNED_SHORT 2
+#endif
+#if !SIZEOF_UNSIGNED_INT
+#undef SIZEOF_UNSIGNED_INT
+#define SIZEOF_UNSIGNED_INT 4
+#endif
+#if !SIZEOF_UNSIGNED_LONG
+#undef SIZEOF_UNSIGNED_LONG
+#define SIZEOF_UNSIGNED_LONG 4
+#endif
+
+
+#include <sys/types.h>
+
+
+#ifndef HAVE_BYTE_TYPEDEF
+#undef byte	    /* maybe there is a macro with this name */
+#ifndef __riscos__
+typedef unsigned char byte;
+#else 
+/* Norcroft treats char  = unsigned char  as legal assignment
+               but char* = unsigned char* as illegal assignment
+   and the same applies to the signed variants as well  */
+typedef char byte;
+#endif
+#define HAVE_BYTE_TYPEDEF
+#endif
+
+#ifndef HAVE_USHORT_TYPEDEF
+#undef ushort     /* maybe there is a macro with this name */
+typedef unsigned short ushort;
+#define HAVE_USHORT_TYPEDEF
+#endif
+
+#ifndef HAVE_ULONG_TYPEDEF
+#undef ulong	    /* maybe there is a macro with this name */
+typedef unsigned long ulong;
+#define HAVE_ULONG_TYPEDEF
+#endif
+
+#ifndef HAVE_U16_TYPEDEF
+#undef u16	    /* maybe there is a macro with this name */
+#if SIZEOF_UNSIGNED_INT == 2
+typedef unsigned int   u16;
+#elif SIZEOF_UNSIGNED_SHORT == 2
+typedef unsigned short u16;
+#else
+#error no typedef for u16
+#endif
+#define HAVE_U16_TYPEDEF
+#endif
+
+#ifndef HAVE_U32_TYPEDEF
+#undef u32	    /* maybe there is a macro with this name */
+#if SIZEOF_UNSIGNED_INT == 4
+typedef unsigned int u32;
+#elif SIZEOF_UNSIGNED_LONG == 4
+typedef unsigned long u32;
+#else
+#error no typedef for u32
+#endif
+#define HAVE_U32_TYPEDEF
+#endif
+
+/****************
+ * Warning: Some systems segfault when this u64 typedef and
+ * the dummy code in cipher/md.c is not available.  Examples are
+ * Solaris and IRIX.
+ */
+#ifndef HAVE_U64_TYPEDEF
+#undef u64	    /* maybe there is a macro with this name */
+#if SIZEOF_UINT64_T == 8
+typedef uint64_t u64;
+#define U64_C(c) (UINT64_C(c))
+#define HAVE_U64_TYPEDEF
+#elif SIZEOF_UNSIGNED_INT == 8
+typedef unsigned int u64;
+#define U64_C(c) (c ## U)
+#define HAVE_U64_TYPEDEF
+#elif SIZEOF_UNSIGNED_LONG == 8
+typedef unsigned long u64;
+#define U64_C(c) (c ## UL)
+#define HAVE_U64_TYPEDEF
+#elif SIZEOF_UNSIGNED_LONG_LONG == 8
+typedef unsigned long long u64;
+#define U64_C(c) (c ## ULL)
+#define HAVE_U64_TYPEDEF
+#endif
+#endif
+
+typedef union {
+    int a;
+    short b;
+    char c[1];
+    long d;
+#ifdef HAVE_U64_TYPEDEF
+    u64 e;
+#endif
+    float f;
+    double g;
+} PROPERLY_ALIGNED_TYPE;
+
+typedef struct string_list {
+    struct string_list *next;
+    unsigned int flags;
+    char d[1];
+} *STRLIST;
+
+#endif /*G10_TYPES_H*/
diff --git a/include/util.h b/include/util.h
new file mode 100644
index 0000000..265bb02
--- /dev/null
+++ b/include/util.h
@@ -0,0 +1,326 @@
+/* util.h
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ *               2006 Free Software Foundation, Inc.
+ *
+ * This file is part of GNUPG.
+ *
+ * GNUPG is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * GNUPG is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA.
+ */
+#ifndef G10_UTIL_H
+#define G10_UTIL_H
+
+#if defined (_WIN32) || defined (__CYGWIN32__)
+#include <stdarg.h>
+#endif
+
+#include "types.h"
+#include "errors.h"
+#include "types.h"
+#include "mpi.h"
+#include "compat.h"
+
+typedef struct {
+     int  *argc;	    /* pointer to argc (value subject to change) */
+     char ***argv;	    /* pointer to argv (value subject to change) */
+     unsigned flags;	    /* Global flags (DO NOT CHANGE) */
+     int err;		    /* print error about last option */
+			    /* 1 = warning, 2 = abort */
+     int r_opt; 	    /* return option */
+     int r_type;	    /* type of return value (0 = no argument found)*/
+     union {
+	 int   ret_int;
+	 long  ret_long;
+	 ulong ret_ulong;
+	 char *ret_str;
+     } r;		    /* Return values */
+     struct {
+	 int idx;
+	 int inarg;
+	 int stopped;
+	 const char *last;
+	 void *aliases;
+	 const void *cur_alias;
+     } internal;	    /* DO NOT CHANGE */
+} ARGPARSE_ARGS;
+
+typedef struct {
+    int 	short_opt;
+    const char *long_opt;
+    unsigned flags;
+    const char *description; /* optional option description */
+} ARGPARSE_OPTS;
+
+/*-- logger.c --*/
+void log_set_logfile( const char *name, int fd );
+FILE *log_stream(void);
+void g10_log_print_prefix(const char *text);
+void log_set_name( const char *name );
+const char *log_get_name(void);
+void log_set_pid( int pid );
+int  log_get_errorcount( int clear );
+void log_inc_errorcount(void);
+int log_set_strict(int val);
+void g10_log_hexdump( const char *text, const char *buf, size_t len );
+
+#if defined (__riscos__) \
+    || (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 ))
+  void g10_log_bug( const char *fmt, ... )
+			    __attribute__ ((noreturn, format (printf,1,2)));
+  void g10_log_bug0( const char *, int, const char * ) __attribute__ ((noreturn));
+  void g10_log_fatal( const char *fmt, ... )
+			    __attribute__ ((noreturn, format (printf,1,2)));
+  void g10_log_error( const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
+  void g10_log_info( const char *fmt, ... )  __attribute__ ((format (printf,1,2)));
+  void g10_log_warning( const char *fmt, ... )  __attribute__ ((format (printf,1,2)));
+  void g10_log_debug( const char *fmt, ... ) __attribute__ ((format (printf,1,2)));
+#ifndef __riscos__
+#define BUG() g10_log_bug0(  __FILE__ , __LINE__, __FUNCTION__ )
+#else
+#define BUG() g10_log_bug0(  __FILE__ , __LINE__, __func__ )
+#endif
+#else
+  void g10_log_bug( const char *fmt, ... );
+  void g10_log_bug0( const char *, int );
+  void g10_log_fatal( const char *fmt, ... );
+  void g10_log_error( const char *fmt, ... );
+  void g10_log_info( const char *fmt, ... );
+  void g10_log_warning( const char *fmt, ... );
+  void g10_log_debug( const char *fmt, ... );
+#define BUG() g10_log_bug0( __FILE__ , __LINE__ )
+#endif
+
+#define log_hexdump g10_log_hexdump
+#define log_bug     g10_log_bug
+#define log_bug0    g10_log_bug0
+#define log_fatal   g10_log_fatal
+#define log_error   g10_log_error
+#define log_info    g10_log_info
+#define log_warning g10_log_warning
+#define log_debug   g10_log_debug
+
+
+/*-- errors.c --*/
+const char * g10_errstr( int no );
+
+/*-- argparse.c --*/
+int arg_parse( ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
+int optfile_parse( FILE *fp, const char *filename, unsigned *lineno,
+		   ARGPARSE_ARGS *arg, ARGPARSE_OPTS *opts);
+void usage( int level );
+const char *default_strusage( int level );
+
+
+/*-- (main program) --*/
+const char *strusage( int level );
+
+
+/*-- dotlock.c --*/
+struct dotlock_handle;
+typedef struct dotlock_handle *DOTLOCK;
+
+void disable_dotlock(void);
+DOTLOCK create_dotlock( const char *file_to_lock );
+void destroy_dotlock ( DOTLOCK h );
+int make_dotlock( DOTLOCK h, long timeout );
+int release_dotlock( DOTLOCK h );
+void remove_lockfiles (void);
+
+/*-- fileutil.c --*/
+char * make_basename(const char *filepath, const char *inputpath);
+char * make_dirname(const char *filepath);
+char *make_filename( const char *first_part, ... );
+int compare_filenames( const char *a, const char *b );
+const char *print_fname_stdin( const char *s );
+const char *print_fname_stdout( const char *s );
+int is_file_compressed(const char *s, int *r_status);
+
+/*-- miscutil.c --*/
+u32 make_timestamp(void);
+u32 scan_isodatestr( const char *string );
+const char *strtimevalue( u32 stamp );
+const char *strtimestamp( u32 stamp ); /* GMT */
+const char *isotimestamp( u32 stamp ); /* GMT with hh:mm:ss */
+const char *asctimestamp( u32 stamp ); /* localized */
+void print_string( FILE *fp, const byte *p, size_t n, int delim );
+void print_string2( FILE *fp, const byte *p, size_t n, int delim, int delim2 );
+void  print_utf8_string( FILE *fp, const byte *p, size_t n );
+void  print_utf8_string2( FILE *fp, const byte *p, size_t n, int delim);
+char *make_printable_string( const byte *p, size_t n, int delim );
+int answer_is_yes_no_default( const char *s, int def_answer );
+int answer_is_yes( const char *s );
+int answer_is_yes_no_quit( const char *s );
+int answer_is_okay_cancel (const char *s, int def_answer);
+int match_multistr(const char *multistr,const char *match);
+
+/*-- strgutil.c --*/
+void free_strlist( STRLIST sl );
+#define FREE_STRLIST(a) do { free_strlist((a)); (a) = NULL ; } while(0)
+STRLIST add_to_strlist( STRLIST *list, const char *string );
+STRLIST add_to_strlist2( STRLIST *list, const char *string, int is_utf8 );
+STRLIST append_to_strlist( STRLIST *list, const char *string );
+STRLIST append_to_strlist2( STRLIST *list, const char *string, int is_utf8 );
+STRLIST strlist_prev( STRLIST head, STRLIST node );
+STRLIST strlist_last( STRLIST node );
+char *pop_strlist( STRLIST *list );
+const char *memistr( const char *buf, size_t buflen, const char *sub );
+const char *ascii_memistr( const char *buf, size_t buflen, const char *sub );
+char *mem2str( char *, const void *, size_t);
+char *trim_spaces( char *string );
+unsigned int trim_trailing_chars( byte *line, unsigned int len,
+                                  const char *trimchars);
+unsigned int trim_trailing_ws( byte *line, unsigned len );
+unsigned int check_trailing_chars( const byte *line, unsigned int len,
+                                   const char *trimchars );
+unsigned int check_trailing_ws( const byte *line, unsigned int len );
+int string_count_chr( const char *string, int c );
+int set_native_charset( const char *newset );
+const char* get_native_charset(void);
+char *native_to_utf8( const char *string );
+char *utf8_to_native( const char *string, size_t length, int delim);
+int  check_utf8_string( const char *string );
+
+int ascii_isupper (int c);
+int ascii_islower (int c);
+int ascii_toupper (int c);
+int ascii_tolower (int c);
+int ascii_strcasecmp( const char *a, const char *b );
+int ascii_strncasecmp( const char *a, const char *b, size_t n);
+int ascii_memcasecmp( const char *a, const char *b, size_t n);
+
+#ifndef HAVE_STPCPY
+char *stpcpy(char *a,const char *b);
+#endif
+#ifndef HAVE_STRLWR
+char *strlwr(char *a);
+#endif
+#ifndef HAVE_STRCASECMP
+int strcasecmp( const char *, const char *b);
+#endif
+#ifndef HAVE_STRNCASECMP
+int strncasecmp (const char *, const char *b, size_t n);
+#endif
+#ifndef HAVE_STRTOUL
+#define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
+#endif
+#ifndef HAVE_MEMMOVE
+#define memmove(d, s, n) bcopy((s), (d), (n))
+#endif
+
+/*-- membuf.c --*/
+/* The definition of the structure is private, we only need it here,
+   so it can be allocated on the stack. */
+struct private_membuf_s {
+  size_t len;      
+  size_t size;     
+  char *buf;       
+  int out_of_core; 
+};
+
+typedef struct private_membuf_s membuf_t;
+
+void init_membuf (membuf_t *mb, int initiallen);
+void put_membuf  (membuf_t *mb, const void *buf, size_t len);
+void *get_membuf (membuf_t *mb, size_t *len);
+
+
+
+#if defined (_WIN32)
+/*-- w32reg.c --*/
+char *read_w32_registry_string( const char *root,
+				const char *dir, const char *name );
+int write_w32_registry_string(const char *root, const char *dir,
+                              const char *name, const char *value);
+
+/*-- strgutil.c --*/
+int vasprintf (char **result, const char *format, va_list args);
+int asprintf (char **buf, const char *fmt, ...);
+#endif /*_WIN32*/
+
+/*-- pka.c --*/
+char *get_pka_info (const char *address, unsigned char *fpr);
+
+/*-- cert.c --*/
+int get_cert(const char *name,size_t max_size,IOBUF *iobuf,
+	     unsigned char **fpr,size_t *fpr_len,char **url);
+
+/**** other missing stuff ****/
+#ifndef HAVE_ATEXIT  /* For SunOS */
+#define atexit(a)    (on_exit((a),0))
+#endif
+
+#ifndef HAVE_RAISE
+#define raise(a) kill(getpid(), (a))
+#endif
+
+/*-- Replacement functions from funcname.c --*/
+
+
+
+/******** some macros ************/
+#ifndef STR
+#define STR(v) #v
+#endif
+#define STR2(v) STR(v)
+#define DIM(v) (sizeof(v)/sizeof((v)[0]))
+#define DIMof(type,member)   DIM(((type *)0)->member)
+
+#define wipememory2(_ptr,_set,_len) do { volatile char *_vptr=(volatile char *)(_ptr); size_t _vlen=(_len); while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } } while(0)
+#define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
+
+/*-- macros to replace ctype ones and avoid locale problems --*/
+#define spacep(p)   (*(p) == ' ' || *(p) == '\t')
+#define digitp(p)   (*(p) >= '0' && *(p) <= '9')
+#define hexdigitp(a) (digitp (a)                     \
+                      || (*(a) >= 'A' && *(a) <= 'F')  \
+                      || (*(a) >= 'a' && *(a) <= 'f'))
+/* the atoi macros assume that the buffer has only valid digits */
+#define atoi_1(p)   (*(p) - '0' )
+#define atoi_2(p)   ((atoi_1(p) * 10) + atoi_1((p)+1))
+#define atoi_4(p)   ((atoi_2(p) * 100) + atoi_2((p)+2))
+#define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
+                     *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
+#define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
+
+/******* RISC OS stuff ***********/
+#ifdef __riscos__
+int riscos_load_module(const char *name, const char * const path[], int fatal);
+int riscos_get_filetype_from_string(const char *string, int len);
+int riscos_get_filetype(const char *filename);
+void riscos_set_filetype_by_number(const char *filename, int type);
+void riscos_set_filetype_by_mimetype(const char *filename, const char *mimetype);
+pid_t riscos_getpid(void);
+int riscos_kill(pid_t pid, int sig);
+int riscos_access(const char *path, int amode);
+int riscos_getchar(void);
+char *riscos_make_basename(const char *filepath, const char *inputpath);
+int riscos_check_regexp(const char *exp, const char *string, int debug);
+int riscos_fdopenfile(const char *filename, const int allow_write);
+void riscos_close_fds(void);
+int riscos_renamefile(const char *old, const char *new);
+char *riscos_gstrans(const char *old);
+void riscos_not_implemented(const char *feature);
+#ifdef DEBUG
+void riscos_dump_fdlist(void);
+void riscos_list_openfiles(void);
+#endif
+#ifndef __RISCOS__C__
+#define getpid riscos_getpid
+#define kill(a,b) riscos_kill((a),(b))
+#define access(a,b) riscos_access((a),(b))
+#endif /* !__RISCOS__C__ */
+#endif /* __riscos__ */
+
+#endif /*G10_UTIL_H*/