Finished the bulk of changes for gnupg 1.9. This included switching
authorWerner Koch <wk@gnupg.org>
Wed, 18 Jun 2003 19:56:13 +0000 (19:56 +0000)
committerWerner Koch <wk@gnupg.org>
Wed, 18 Jun 2003 19:56:13 +0000 (19:56 +0000)
to libgcrypt functions, using shared error codes from libgpg-error,
replacing the old functions we used to have in ../util by those in
../jnlib and ../common, renaming the malloc functions and a couple of
types.  Note, that not all changes are listed below becuause they are
too similar and done at far too many places.  As of today the code
builds using the current libgcrypt from CVS but it is very unlikely
that it actually works.

90 files changed:
ChangeLog
TODO
acinclude.m4
configure.ac
g10/ChangeLog
g10/Makefile.am
g10/armor.c
g10/build-packet.c
g10/call-agent.c
g10/cipher.c
g10/comment.c
g10/compress.c
g10/dearmor.c
g10/decrypt.c
g10/delkey.c
g10/encode.c
g10/encr-data.c
g10/exec.c
g10/exec.h
g10/export.c
g10/filter.h
g10/free-packet.c
g10/g10.c
g10/getkey.c
g10/global.h
g10/gpg.h
g10/gpgv.c
g10/helptext.c
g10/import.c
g10/kbnode.c
g10/keydb.c
g10/keydb.h
g10/keyedit.c
g10/keygen.c
g10/keyid.c
g10/keylist.c
g10/keyring.c
g10/keyserver-internal.h
g10/keyserver.c
g10/main.h
g10/mainproc.c
g10/mdfilter.c
g10/misc.c
g10/mkdtemp.c
g10/openfile.c
g10/packet.h
g10/parse-packet.c
g10/passphrase.c
g10/photoid.c
g10/pipemode.c
g10/pkclist.c
g10/pkglue.c [new file with mode: 0644]
g10/pkglue.h [new file with mode: 0644]
g10/plaintext.c
g10/progress.c
g10/pubkey-enc.c
g10/revoke.c
g10/seckey-cert.c
g10/seskey.c
g10/sig-check.c
g10/sign.c
g10/signal.c
g10/skclist.c
g10/status.c
g10/tdbdump.c
g10/tdbio.c
g10/textfilter.c
g10/trustdb.c
g10/verify.c
include/ChangeLog
include/cipher.h
include/errors.h
include/iobuf.h [deleted file]
include/mpi.h
include/ttyio.h [deleted file]
include/types.h
include/util.h
jnlib/ChangeLog
jnlib/Makefile.am
jnlib/dotlock.c
jnlib/dotlock.h
jnlib/logging.c
jnlib/logging.h
jnlib/mischelp.h
jnlib/stringhelp.c
jnlib/stringhelp.h
jnlib/strlist.c
jnlib/strlist.h
jnlib/utf8conv.c [new file with mode: 0644]
jnlib/utf8conv.h [new file with mode: 0644]

index d2a1453..2efc1bf 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2003-06-18  Werner Koch  <wk@gnupg.org>
+
+       * configure.ac (GNUPG_DEFAULT_HOMEDIR): Changed temporary to
+       .gnupg2 to avoid accidential use with production keys.
+
+2003-06-11  Werner Koch  <wk@gnupg.org>
+
+       * configure.ac: Merged all stuff from current 1.3 version in.
+       * acinclude.m4: Merged required macros from current 1.2 version in.
+
 2003-06-04  Werner Koch  <wk@gnupg.org>
 
        * configure.ac, Makefile.am: Enable building of gpg.
diff --git a/TODO b/TODO
index bd23ba6..431f2a2 100644 (file)
--- a/TODO
+++ b/TODO
@@ -57,17 +57,3 @@ might want to have an agent context for each service request
 
 * ALL
 ** Return IMPORT_OK status.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
index 5156402..4237738 100644 (file)
@@ -1,5 +1,5 @@
 dnl macros to configure gnupg
-dnl Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+dnl Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
 dnl
 dnl This file is part of GnuPG.
 dnl
@@ -36,6 +36,127 @@ AC_DEFUN(GNUPG_CHECK_TYPEDEF,
   ])
 
 
+dnl GNUPG_CHECK_GNUMAKE
+dnl
+AC_DEFUN(GNUPG_CHECK_GNUMAKE,
+  [ 
+    if ${MAKE-make} --version 2>/dev/null | grep '^GNU ' >/dev/null 2>&1; then
+        :
+    else
+        AC_MSG_WARN([[
+***
+*** It seems that you are not using GNU make.  Some make tools have serious
+*** flaws and you may not be able to build this software at all. Before you
+*** complain, please try GNU make:  GNU make is easy to build and available
+*** at all GNU archives.  It is always available from ftp.gnu.org:/gnu/make.
+***]])
+    fi
+  ])
+
+dnl GNUPG_CHECK_FAQPROG
+dnl
+AC_DEFUN(GNUPG_CHECK_FAQPROG,
+  [ AC_MSG_CHECKING(for faqprog.pl)
+    if faqprog.pl -V 2>/dev/null | grep '^faqprog.pl ' >/dev/null 2>&1; then
+        working_faqprog=yes
+        FAQPROG="faqprog.pl"
+    else 
+       working_faqprog=no
+        FAQPROG=": "
+    fi
+    AC_MSG_RESULT($working_faqprog)
+    AC_SUBST(FAQPROG)
+    AM_CONDITIONAL(WORKING_FAQPROG, test "$working_faqprog" = "yes" )
+
+dnl     if test $working_faqprog = no; then
+dnl         AC_MSG_WARN([[
+dnl ***
+dnl *** It seems that the faqprog.pl program is not installed;
+dnl *** however it is only needed if you want to change the FAQ.
+dnl ***  (faqprog.pl should be available at:
+dnl ***    ftp://ftp.gnupg.org/gcrypt/contrib/faqprog.pl )
+dnl *** No need to worry about this warning.
+dnl ***]])
+dnl     fi
+   ])       
+
+dnl GNUPG_CHECK_DOCBOOK_TO_TEXI
+dnl
+AC_DEFUN(GNUPG_CHECK_DOCBOOK_TO_TEXI,
+  [
+    AC_CHECK_PROG(DOCBOOK_TO_TEXI, docbook2texi, yes, no)
+    AC_MSG_CHECKING(for sgml to texi tools)
+    working_sgmltotexi=no
+    if test "$ac_cv_prog_DOCBOOK_TO_TEXI" = yes; then
+      if sgml2xml -v /dev/null 2>&1 | grep 'SP version' >/dev/null 2>&1 ; then
+            working_sgmltotexi=yes
+      fi
+    fi
+    AC_MSG_RESULT($working_sgmltotexi)
+    AM_CONDITIONAL(HAVE_DOCBOOK_TO_TEXI, test "$working_sgmltotexi" = "yes" )
+   ])       
+
+
+
+dnl GNUPG_CHECK_ENDIAN
+dnl define either LITTLE_ENDIAN_HOST or BIG_ENDIAN_HOST
+dnl
+define(GNUPG_CHECK_ENDIAN,
+  [
+    tmp_assumed_endian=big
+    if test "$cross_compiling" = yes; then
+      case "$host_cpu" in
+         i@<:@345678@:>@* )
+            tmp_assumed_endian=little
+            ;;
+         *)
+            ;;
+      esac
+      AC_MSG_WARN(cross compiling; assuming $tmp_assumed_endian endianess)
+    fi
+    AC_MSG_CHECKING(endianess)
+    AC_CACHE_VAL(gnupg_cv_c_endian,
+      [ gnupg_cv_c_endian=unknown
+        # See if sys/param.h defines the BYTE_ORDER macro.
+        AC_TRY_COMPILE([#include <sys/types.h>
+        #include <sys/param.h>], [
+        #if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
+         bogus endian macros
+        #endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
+        AC_TRY_COMPILE([#include <sys/types.h>
+        #include <sys/param.h>], [
+        #if BYTE_ORDER != BIG_ENDIAN
+         not big endian
+        #endif], gnupg_cv_c_endian=big, gnupg_cv_c_endian=little)])
+        if test "$gnupg_cv_c_endian" = unknown; then
+            AC_TRY_RUN([main () {
+              /* Are we little or big endian?  From Harbison&Steele.  */
+              union
+              {
+                long l;
+                char c[sizeof (long)];
+              } u;
+              u.l = 1;
+              exit (u.c[sizeof (long) - 1] == 1);
+              }],
+              gnupg_cv_c_endian=little,
+              gnupg_cv_c_endian=big,
+              gnupg_cv_c_endian=$tmp_assumed_endian
+            )
+        fi
+      ])
+    AC_MSG_RESULT([$gnupg_cv_c_endian])
+    if test "$gnupg_cv_c_endian" = little; then
+      AC_DEFINE(LITTLE_ENDIAN_HOST,1,
+                [Defined if the host has little endian byte ordering])
+    else
+      AC_DEFINE(BIG_ENDIAN_HOST,1,
+                [Defined if the host has big endian byte ordering])
+    fi
+  ])
+
+
+
 # Check for the getsockopt SO_PEERCRED
 AC_DEFUN(GNUPG_SYS_SO_PEERCRED,
   [ AC_MSG_CHECKING(for SO_PEERCRED)
@@ -125,12 +246,11 @@ AC_DEFUN(GNUPG_PTH_VERSION_CHECK,
     fi    
   ])
 
-######################################################################
+
 # Check whether mlock is broken (hpux 10.20 raises a SIGBUS if mlock
 # is not called from uid 0 (not tested whether uid 0 works)
 # For DECs Tru64 we have also to check whether mlock is in librt
 # mlock is there a macro using memlk()
-######################################################################
 dnl GNUPG_CHECK_MLOCK
 dnl
 define(GNUPG_CHECK_MLOCK,
@@ -220,6 +340,32 @@ define(GNUPG_CHECK_MLOCK,
   ])
 
 
+dnl Stolen from gcc
+dnl Define MKDIR_TAKES_ONE_ARG if mkdir accepts only one argument instead
+dnl of the usual 2.
+AC_DEFUN(GNUPG_FUNC_MKDIR_TAKES_ONE_ARG,
+[AC_CHECK_HEADERS(sys/stat.h unistd.h direct.h)
+AC_CACHE_CHECK([if mkdir takes one argument], gnupg_cv_mkdir_takes_one_arg,
+[AC_TRY_COMPILE([
+#include <sys/types.h>
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+#ifdef HAVE_DIRECT_H
+# include <direct.h>
+#endif], [mkdir ("foo", 0);],
+        gnupg_cv_mkdir_takes_one_arg=no, gnupg_cv_mkdir_takes_one_arg=yes)])
+if test $gnupg_cv_mkdir_takes_one_arg = yes ; then
+  AC_DEFINE(MKDIR_TAKES_ONE_ARG,1,
+            [Defined if mkdir() does not take permission flags])
+fi
+])
+
+
+
 
 dnl [copied from libgcrypt]
 dnl AM_PATH_LIBGCRYPT([MINIMUM-VERSION,
index 2f0bf9d..b02e55f 100644 (file)
@@ -1,5 +1,6 @@
 # configure.ac - for GnuPG 1.9
-#       Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc,
+# Copyright (C) 1998, 1999, 2000, 2001, 2002,
+#               2003 Free Software Foundation, Inc.
 # 
 # This file is part of GnuPG.
 # 
@@ -22,11 +23,16 @@ AC_PREREQ(2.52)
 # Version number: Remember to change it immediately *after* a release.
 #                 Add a "-cvs" prefix for non-released code.
 AC_INIT(gnupg, 1.9.0-cvs, gnupg-devel@gnupg.org)
+# Set development_version to yes if the minor number is odd or you
+# feel that the default check for a development version is not
+# sufficient.
+development_version=yes
 NEED_LIBGCRYPT_VERSION=1.1.8
 NEED_LIBASSUAN_VERSION=0.0.1
 NEED_KSBA_VERSION=0.4.6
 NEED_OPENSC_VERSION=0.7.0
 
+
 PACKAGE=$PACKAGE_NAME
 VERSION=$PACKAGE_VERSION
 
@@ -35,8 +41,10 @@ AM_GNU_GETTEXT_VERSION(0.11.5)
 AC_CONFIG_AUX_DIR(scripts)
 AC_CONFIG_SRCDIR(sm/gpgsm.c)
 AM_CONFIG_HEADER(config.h)
+AC_CANONICAL_TARGET()
 AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
-AM_MAINTAINER_MODE
+
+AC_GNU_SOURCE
 
 # Some status variables to give feedback at the end of a configure run
 habe_libassuan=no
@@ -50,24 +58,6 @@ GNUPG_BUILD_PROGRAM(agent, yes)
 GNUPG_BUILD_PROGRAM(scdaemon, yes)
 
 
-AH_TOP([
-/* We need this, because some autoconf tests rely on this (e.g. stpcpy)
-   and it should be used for new programs anyway. */
-#define _GNU_SOURCE  1
-])
-
-AH_BOTTOM([
-/* Some global constants. */
-#ifdef HAVE_DRIVE_LETTERS
-#define GNUPG_DEFAULT_HOMEDIR "c:/gnupg"
-#else
-#define GNUPG_DEFAULT_HOMEDIR "~/.gnupg"
-#endif 
-#define GNUPG_PRIVATE_KEYS_DIR "private-keys-v1.d"
-])
-
-
-
 AC_SUBST(PACKAGE)
 AC_SUBST(VERSION)
 AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package])
@@ -82,56 +72,6 @@ AC_DEFINE_UNQUOTED(NEED_KSBA_VERSION, "$NEED_KSBA_VERSION",
 
 
 
-# Checks for programs.
-missing_dir=`cd $ac_aux_dir && pwd`
-AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
-AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
-AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
-AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
-AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
-AC_PROG_AWK
-AC_PROG_CC
-AC_PROG_CPP
-AC_PROG_INSTALL
-AC_PROG_LN_S
-AC_PROG_MAKE_SET
-AC_PROG_RANLIB
-#AC_ARG_PROGRAM
-
-if test "$GCC" = yes; then
-    CFLAGS="$CFLAGS -Wall -Wcast-align -Wshadow -Wstrict-prototypes"
-fi
-
-case "${target}" in
-    *-*-mingw32*)
-        PRINTABLE_OS_NAME="MingW32"
-        AC_DEFINE(HAVE_DOSISH_SYSTEM,1,
-                  [defined if we run on some of the PCDOS like systems 
-                   (DOS, Windoze. OS/2) with special properties like
-                    no file modes])
-        ;;
-    i?86-emx-os2 | i?86-*-os2*emx )
-        PRINTABLE_OS_NAME="OS/2"
-        ;;
-    i?86-*-msdosdjgpp*)
-        PRINTABLE_OS_NAME="MSDOS/DJGPP"
-        try_dynload=no
-        ;;
-    *-linux*)
-        PRINTABLE_OS_NAME="GNU/Linux"
-        ;;
-dnl let that after linux to avoid gnu-linux problems
-    *-gnu*)
-        PRINTABLE_OS_NAME="GNU/Hurd"
-        ;;
-    *)
-        PRINTABLE_OS_NAME=`uname -s || echo "Unknown"`
-        ;;
-esac
-AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",
-                   [A human readable text with the name of the OS])
-
-
 # I know that it is in general not a good idea to evaluate bindir in
 # the configuration but we want to hard code the defaults into some of
 # the programs and doing this during a make install is not a good
@@ -187,6 +127,221 @@ AC_DEFINE_UNQUOTED(GNUPG_PROTECT_TOOL, "$gnupg_protect_tool",
                    [Name of the protect tool program])
 
 
+
+AC_MSG_CHECKING([whether to enable external program execution])
+AC_ARG_ENABLE(exec,
+    AC_HELP_STRING([--disable-exec],[disable all external program execution]),
+    use_exec=$enableval)
+AC_MSG_RESULT($use_exec)
+if test "$use_exec" = no ; then
+    AC_DEFINE(NO_EXEC,1,[Define to disable all external program execution])
+fi
+
+if test "$use_exec" = yes ; then
+  AC_MSG_CHECKING([whether to enable photo ID viewing])
+  AC_ARG_ENABLE(photo-viewers,
+      [  --disable-photo-viewers disable photo ID viewers],
+      [if test "$enableval" = no ; then
+         AC_DEFINE(DISABLE_PHOTO_VIEWER,1,[define to disable photo viewing])
+      fi],enableval=yes)
+  gnupg_cv_enable_photo_viewers=$enableval
+  AC_MSG_RESULT($enableval)
+
+  if test "$gnupg_cv_enable_photo_viewers" = yes ; then
+    AC_MSG_CHECKING([whether to use a fixed photo ID viewer])
+    AC_ARG_WITH(photo-viewer,
+        [  --with-photo-viewer=FIXED_VIEWER  set a fixed photo ID viewer],
+        [if test "$withval" = yes ; then
+           withval=no
+        elif test "$withval" != no ; then
+           AC_DEFINE_UNQUOTED(FIXED_PHOTO_VIEWER,"$withval",
+                           [if set, restrict photo-viewer to this])
+        fi],withval=no)
+    AC_MSG_RESULT($withval)
+  fi
+
+  AC_MSG_CHECKING([whether to enable external keyserver helpers])
+  AC_ARG_ENABLE(keyserver-helpers,
+      [  --disable-keyserver-helpers  disable all external keyserver support],
+      [if test "$enableval" = no ; then
+         AC_DEFINE(DISABLE_KEYSERVER_HELPERS,1,
+                  [define to disable keyserver helpers])
+      fi],enableval=yes)
+  gnupg_cv_enable_keyserver_helpers=$enableval
+  AC_MSG_RESULT($enableval)
+
+  if test "$gnupg_cv_enable_keyserver_helpers" = yes ; then
+    AC_MSG_CHECKING([whether LDAP keyserver support is requested])
+    AC_ARG_ENABLE(ldap,
+    [  --disable-ldap          disable LDAP keyserver interface],
+        try_ldap=$enableval, try_ldap=yes)
+    AC_MSG_RESULT($try_ldap)
+
+    AC_MSG_CHECKING([whether HKP keyserver support is requested])
+    AC_ARG_ENABLE(hkp,
+    [  --disable-hkp           disable HKP keyserver interface],
+        try_hkp=$enableval, try_hkp=yes)
+    AC_MSG_RESULT($try_hkp)
+
+    if test "$try_hkp" = yes ; then
+      AC_SUBST(GPGKEYS_HKP,"gpgkeys_hkp$EXEEXT")
+    fi
+
+    AC_MSG_CHECKING([whether email keyserver support is requested])
+    AC_ARG_ENABLE(mailto,
+    [  --disable-mailto        disable email keyserver interface],
+        try_mailto=$enableval, try_mailto=yes)
+    AC_MSG_RESULT($try_mailto)
+    fi
+
+    AC_MSG_CHECKING([whether keyserver exec-path is enabled])
+    AC_ARG_ENABLE(keyserver-path,
+        [  --disable-keyserver-path disable the exec-path option for keyserver helpers],
+        [if test "$enableval" = no ; then
+        AC_DEFINE(DISABLE_KEYSERVER_PATH,1,[define to disable exec-path for keyserver helpers])
+        fi],enableval=yes)
+    AC_MSG_RESULT($enableval)
+  fi
+
+AC_MSG_CHECKING([whether the included zlib is requested])
+AC_ARG_WITH(included-zlib,
+    [  --with-included-zlib    use the zlib code included here],
+[g10_force_zlib=yes], [g10_force_zlib=no] )
+AC_MSG_RESULT($g10_force_zlib)
+
+dnl
+dnl Check whether we want to use Linux capabilities
+dnl
+AC_MSG_CHECKING([whether use of capabilities is requested])
+AC_ARG_WITH(capabilities,
+    [  --with-capabilities     use linux capabilities [default=no]],
+[use_capabilities="$withval"],[use_capabilities=no])
+AC_MSG_RESULT($use_capabilities)
+
+
+AH_BOTTOM([
+/* Some global constants. */
+#ifdef HAVE_DRIVE_LETTERS
+#define GNUPG_DEFAULT_HOMEDIR "c:/gnupg"
+#else
+#define GNUPG_DEFAULT_HOMEDIR "~/.gnupg2"
+#endif 
+#define GNUPG_PRIVATE_KEYS_DIR "private-keys-v1.d"
+
+#if !(defined(HAVE_FORK) && defined(HAVE_PIPE) && defined(HAVE_WAITPID))
+#define EXEC_TEMPFILE_ONLY
+#endif
+
+/* Tell libgcrypt not to use its own libgpg-error implementation. */
+#define USE_LIBGPG_ERROR 1
+
+#include "g10defs.h"
+
+])
+
+AM_MAINTAINER_MODE
+
+# Checks for programs.
+AC_PROG_MAKE_SET
+AM_SANITY_CHECK
+missing_dir=`cd $ac_aux_dir && pwd`
+AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
+AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
+AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
+AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
+AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
+AC_PROG_AWK
+AC_PROG_CC
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+AC_PROG_RANLIB
+AC_CHECK_TOOL(AR, ar, :)
+AC_PATH_PROG(PERL,"perl")
+AC_ISC_POSIX
+AC_SYS_LARGEFILE
+AC_CHECK_PROG(DOCBOOK_TO_MAN, docbook-to-man, yes, no)
+AM_CONDITIONAL(HAVE_DOCBOOK_TO_MAN, test "$ac_cv_prog_DOCBOOK_TO_MAN" = yes)
+GNUPG_CHECK_FAQPROG
+GNUPG_CHECK_DOCBOOK_TO_TEXI
+
+
+try_gettext=yes
+have_dosish_system=no
+case "${target}" in
+    *-*-mingw32*)
+        # special stuff for Windoze NT
+        ac_cv_have_dev_random=no
+        AC_DEFINE(USE_ONLY_8DOT3,1,
+                  [set this to limit filenames to the 8.3 format])
+        AC_DEFINE(HAVE_DRIVE_LETTERS,1,
+                  [defined if we must run on a stupid file system])
+        AC_DEFINE(USE_SIMPLE_GETTEXT,1,
+                  [because the Unix gettext has too much overhead on
+                   MingW32 systems and these systems lack Posix functions,
+                   we use a simplified version of gettext])
+        have_dosish_system=yes
+        try_gettext="no"
+        ;;
+    i?86-emx-os2 | i?86-*-os2*emx )
+        # OS/2 with the EMX environment
+        ac_cv_have_dev_random=no
+        AC_DEFINE(HAVE_DRIVE_LETTERS)
+        have_dosish_system=yes
+        try_gettext="no"
+        ;;
+
+    i?86-*-msdosdjgpp*)
+        # DOS with the DJGPP environment
+        ac_cv_have_dev_random=no
+        AC_DEFINE(HAVE_DRIVE_LETTERS)
+        have_dosish_system=yes
+        try_gettext="no"
+        ;;
+
+    *-*-freebsd*)
+       # FreeBSD
+       CPPFLAGS="$CPPFLAGS -I/usr/local/include"
+       LDFLAGS="$LDFLAGS -L/usr/local/lib"
+       ;;
+
+    *-*-hpux*)
+        if test -z "$GCC" ; then
+            CFLAGS="$CFLAGS -Ae -D_HPUX_SOURCE"
+        fi
+        ;;
+    *-dec-osf4*)
+        if test -z "$GCC" ; then
+            # Suppress all warnings
+            # to get rid of the unsigned/signed char mismatch warnings.
+            CFLAGS="$CFLAGS -w"
+        fi
+        ;;
+    *-dec-osf5*)
+        if test -z "$GCC" ; then
+            # Use the newer compiler `-msg_disable ptrmismatch' to
+            # get rid of the unsigned/signed char mismatch warnings.
+            # Using this may hide other pointer mismatch warnings, but
+           # it at least lets other warning classes through
+            CFLAGS="$CFLAGS -msg_disable ptrmismatch"
+        fi
+        ;;
+    m68k-atari-mint)
+        ;;
+    *)
+       ;;
+esac
+
+if test "$have_dosish_system" = yes; then
+   AC_DEFINE(HAVE_DOSISH_SYSTEM,1,
+             [defined if we run on some of the PCDOS like systems 
+              (DOS, Windoze. OS/2) with special properties like
+              no file modes])
+fi
+AM_CONDITIONAL(HAVE_DOSISH_SYSTEM, test "$have_dosish_system" = yes)
+
+
 #
 # Checks for libraries.
 #
@@ -290,11 +445,199 @@ fi
 AC_SUBST(PTH_CFLAGS)
 AC_SUBST(PTH_LIBS)
 
-AM_GNU_GETTEXT
+
+dnl Must check for network library requirements before doing link tests
+dnl for ldap, for example. If ldap libs are static (or dynamic and without
+dnl ELF runtime link paths), then link will fail and LDAP support won't
+dnl be detected.
+
+AC_CHECK_FUNC(gethostbyname, , AC_CHECK_LIB(nsl, gethostbyname,
+       [NETLIBS="-lnsl $NETLIBS"]))
+AC_CHECK_FUNC(setsockopt, , AC_CHECK_LIB(socket, setsockopt,
+       [NETLIBS="-lsocket $NETLIBS"]))
+
+dnl Now try for the resolver functions so we can use DNS SRV
+
+AC_ARG_ENABLE(dns-srv,
+   AC_HELP_STRING([--disable-dns-srv],[disable the use of DNS SRV in HKP]),
+   use_dns_srv=$enableval,use_dns_srv=yes)
+
+if test x"$try_hkp" = xyes && test x"$use_dns_srv" = xyes ; then
+  _srv_save_libs=$LIBS
+  LIBS=""
+  # the double underscore thing is a glibc-ism?
+  AC_SEARCH_LIBS(res_query,resolv bind,,
+                 AC_SEARCH_LIBS(__res_query,resolv bind,,use_dns_srv=no))
+  AC_SEARCH_LIBS(dn_expand,resolv bind,,
+                 AC_SEARCH_LIBS(__dn_expand,resolv bind,,use_dns_srv=no))
+  AC_SEARCH_LIBS(dn_skipname,resolv bind,,
+                 AC_SEARCH_LIBS(__dn_skipname,resolv bind,,use_dns_srv=no))
+
+  if test x"$use_dns_srv" = xyes ; then
+     AC_DEFINE(USE_DNS_SRV,1,[define to use DNS SRV])
+     SRVLIBS=$LIBS
+  else
+     AC_MSG_WARN([Resolver functions not found.  Disabling DNS SRV.])
+  fi
+  LIBS=$_srv_save_libs
+fi
+
+AC_SUBST(SRVLIBS)
+
+# Try and link a LDAP test program to weed out unusable LDAP
+# libraries.  -lldap [-llber [-lresolv]] is for OpenLDAP.  OpenLDAP in
+# general is terrible with creating weird dependencies.  If all else
+# fails, the user can play guess-the-dependency by using something
+# like ./configure LDAPLIBS="-Lfoo -lbar"
+
+if test "$try_ldap" = yes ; then
+  for MY_LDAPLIBS in ${LDAPLIBS+"$LDAPLIBS"} "-lldap" "-lldap -llber" "-lldap -llber -lresolv"; do
+    _ldap_save_libs=$LIBS
+    LIBS="$MY_LDAPLIBS $NETLIBS $LIBS"
+
+    AC_MSG_CHECKING([whether LDAP via \"$MY_LDAPLIBS\" is present and sane])
+    AC_TRY_LINK([#include <ldap.h>],[ldap_open("foobar",1234);],
+                [gnupg_cv_func_ldap_init=yes],[gnupg_cv_func_ldap_init=no])
+    AC_MSG_RESULT([$gnupg_cv_func_ldap_init])
+
+    if test $gnupg_cv_func_ldap_init = no; then
+      AC_MSG_CHECKING([whether I can make LDAP be sane with lber.h])
+      AC_TRY_LINK([#include <lber.h>
+#include <ldap.h>],[ldap_open("foobar",1234);],
+         [gnupg_cv_func_ldaplber_init=yes],[gnupg_cv_func_ldaplber_init=no])
+      AC_MSG_RESULT([$gnupg_cv_func_ldaplber_init])
+    fi
+
+    if test "$gnupg_cv_func_ldaplber_init" = yes ; then
+       AC_DEFINE(NEED_LBER_H,1,[Define if the LDAP library requires including lber.h before ldap.h])
+    fi
+
+    if test "$gnupg_cv_func_ldap_init" = yes || \
+       test "$gnupg_cv_func_ldaplber_init" = yes ; then
+       LDAPLIBS=$MY_LDAPLIBS
+       GPGKEYS_LDAP="gpgkeys_ldap$EXEEXT"
+
+       AC_MSG_CHECKING([whether LDAP supports ldap_get_option])
+
+       if test "$gnupg_cv_func_ldap_init" = yes ; then
+         AC_TRY_LINK([#include <ldap.h>],
+            [ldap_get_option((void *)0,0,(void *)0);],
+            [gnupg_cv_func_ldap_get_option=yes],
+            [gnupg_cv_func_ldap_get_option=no])
+       else
+         AC_TRY_LINK([#include <lber.h>
+#include <ldap.h>],[ldap_get_option((void *)0,0,(void *)0);],
+            [gnupg_cv_func_ldap_get_option=yes],
+            [gnupg_cv_func_ldap_get_option=no])
+       fi
+
+       AC_MSG_RESULT([$gnupg_cv_func_ldap_get_option])
+
+       if test "$gnupg_cv_func_ldap_get_option" = yes ; then
+          AC_DEFINE(HAVE_LDAP_GET_OPTION,1,[Define if the LDAP library has ldap_get_option])
+       else
+          AC_MSG_CHECKING([whether LDAP supports ld_errno])
+
+         if test "$gnupg_cv_func_ldap_init" = yes ; then
+           AC_TRY_COMPILE([#include <ldap.h>],
+              [LDAP *ldap; ldap->ld_errno;],
+              [gnupg_cv_func_ldap_ld_errno=yes],
+              [gnupg_cv_func_ldap_ld_errno=no])
+          else
+           AC_TRY_LINK([#include <lber.h>
+#include <ldap.h>],[LDAP *ldap; ldap->ld_errno;],
+              [gnupg_cv_func_ldap_ld_errno=yes],
+              [gnupg_cv_func_ldap_ld_errno=no])
+          fi
+
+          AC_MSG_RESULT([$gnupg_cv_func_ldap_ld_errno])
+
+         if test "$gnupg_cv_func_ldap_ld_errno" = yes ; then
+            AC_DEFINE(HAVE_LDAP_LD_ERRNO,1,[Define if the LDAP library supports ld_errno])
+          fi
+       fi
+    fi
+
+    LIBS=$_ldap_save_libs
+
+    if test "$GPGKEYS_LDAP" != "" ; then break; fi
+  done
+fi
+
+AC_SUBST(GPGKEYS_LDAP)
+AC_SUBST(LDAPLIBS)
+
+dnl This isn't necessarily sendmail itself, but anything that gives a
+dnl sendmail-ish interface to the outside world.  That includes qmail,
+dnl postfix, etc.  Basically, anything that can handle "sendmail -t".
+
+if test "$try_mailto" = yes ; then
+  AC_ARG_WITH(mailprog,[  --with-mailprog=NAME    use "NAME -t" for mail transport],,with_mailprog=yes)
+
+  if test "$with_mailprog" = yes ; then
+    AC_PATH_PROG(SENDMAIL,sendmail,,$PATH:/usr/sbin:/usr/libexec:/usr/lib)
+    if test "$ac_cv_path_SENDMAIL" ; then
+      GPGKEYS_MAILTO="gpgkeys_mailto"
+    fi
+  elif test "$with_mailprog" != no ; then
+    AC_MSG_CHECKING([for a mail transport program])
+    AC_SUBST(SENDMAIL,$with_mailprog)
+    AC_MSG_RESULT($with_mailprog)
+    GPGKEYS_MAILTO="gpgkeys_mailto"
+  fi
+fi
+
+AC_SUBST(GPGKEYS_MAILTO)
+
+case "${target}" in
+    *-*-mingw32*)
+        PRINTABLE_OS_NAME="MingW32"
+        ;;
+    *-*-cygwin*)
+        PRINTABLE_OS_NAME="Cygwin"
+        ;;
+    i?86-emx-os2 | i?86-*-os2*emx )
+        PRINTABLE_OS_NAME="OS/2"
+        ;;
+    i?86-*-msdosdjgpp*)
+        PRINTABLE_OS_NAME="MSDOS/DJGPP"
+        try_dynload=no
+        ;;
+    *-linux*)
+        PRINTABLE_OS_NAME="GNU/Linux"
+        ;;
+dnl let that after linux to avoid gnu-linux problems
+    *-gnu*)
+        PRINTABLE_OS_NAME="GNU/Hurd"
+        ;;
+    *)
+        PRINTABLE_OS_NAME=`uname -s || echo "Unknown"`
+        ;;
+esac
+AC_DEFINE_UNQUOTED(PRINTABLE_OS_NAME, "$PRINTABLE_OS_NAME",
+                   [A human readable text with the name of the OS])
+
+
+if test "$try_gettext" = yes; then
+  AM_GNU_GETTEXT(,[need-ngettext])
+
+  # gettext requires some extra checks.  These really should be part of
+  # the basic AM_GNU_GETTEXT macro.  TODO: move other gettext-specific
+  # function checks to here.
+
+  AC_CHECK_FUNCS(strchr)
+else
+  USE_NLS=no
+  USE_INCLUDED_LIBINTL=no
+  BUILD_INCLUDED_LIBINTL=no
+  AC_SUBST(USE_NLS)
+  AC_SUBST(USE_INCLUDED_LIBINTL)
+  AC_SUBST(BUILD_INCLUDED_LIBINTL)
+fi
 
 # Checks for header files.
 AC_HEADER_STDC
-AC_CHECK_HEADERS([string.h locale.h])
+AC_CHECK_HEADERS(string.h unistd.h langinfo.h termio.h locale.h)
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_C_CONST
@@ -303,34 +646,270 @@ AC_TYPE_SIZE_T
 AC_TYPE_SIGNAL
 AC_DECL_SYS_SIGLIST
 
+GNUPG_CHECK_ENDIAN
+
 GNUPG_CHECK_TYPEDEF(byte, HAVE_BYTE_TYPEDEF)
 GNUPG_CHECK_TYPEDEF(ushort, HAVE_USHORT_TYPEDEF)
 GNUPG_CHECK_TYPEDEF(ulong, HAVE_ULONG_TYPEDEF)
+GNUPG_CHECK_TYPEDEF(u16, HAVE_U16_TYPEDEF)
+GNUPG_CHECK_TYPEDEF(u32, HAVE_U32_TYPEDEF)
+
+AC_CHECK_SIZEOF(unsigned short)
+AC_CHECK_SIZEOF(unsigned int)
+AC_CHECK_SIZEOF(unsigned long)
+AC_CHECK_SIZEOF(unsigned long long)
+AC_CHECK_SIZEOF(uint64_t)
+
+if test "$ac_cv_sizeof_unsigned_short" = "0" \
+   || test "$ac_cv_sizeof_unsigned_int" = "0" \
+   || test "$ac_cv_sizeof_unsigned_long" = "0"; then
+    AC_MSG_WARN([Hmmm, something is wrong with the sizes - using defaults]);
+fi
+
+dnl Do we have any 64-bit data types?
+if test "$ac_cv_sizeof_unsigned_int" != "8" \
+   && test "$ac_cv_sizeof_unsigned_long" != "8" \
+   && test "$ac_cv_sizeof_unsigned_long_long" != "8" \
+   && test "$ac_cv_sizeof_uint64_t" != "8"; then
+    AC_MSG_WARN([No 64-bit types.  Disabling TIGER/192, SHA-384, and SHA-512])
+else
+  if test x"$use_tiger192" = xyes ; then
+     AC_SUBST(TIGER_O,tiger.o)
+     AC_DEFINE(USE_TIGER192,1,[Define to include the TIGER/192 digest])
+  fi
+
+  if test "$use_old_tiger192" = yes ; then
+     AC_SUBST(TIGER_O,tiger.o)
+     AC_DEFINE(USE_TIGER192,1,[Define to include the TIGER/192 digest])
+     AC_DEFINE(USE_OLD_TIGER,1,[Define to use the old fake OID for TIGER/192 digest support])
+  fi
+
+  if test x"$use_sha512" = xyes ; then
+     AC_SUBST(SHA512_O,sha512.o)
+     AC_DEFINE(USE_SHA512,1,[Define to include the SHA-384 and SHA-512 digests])
+  fi
+fi
 
 GNUPG_SYS_SO_PEERCRED
 
 # Checks for library functions.
+AC_FUNC_FSEEKO
+AC_FUNC_VPRINTF
+AC_FUNC_FORK
+AC_CHECK_FUNCS(strerror stpcpy strsep strlwr tcgetattr strtoul mmap)
+AC_CHECK_FUNCS(strcasecmp strncasecmp ctermid times)
+AC_CHECK_FUNCS(memmove gettimeofday getrusage setrlimit clock_gettime)
+AC_CHECK_FUNCS(atexit raise getpagesize strftime nl_langinfo setlocale)
+AC_CHECK_FUNCS(waitpid wait4 sigaction sigprocmask rand pipe stat)
 
 # These are needed by libjnlib - fixme: we should have a macros for them
 AC_CHECK_FUNCS(memicmp stpcpy strlwr strtoul memmove stricmp strtol)
 AC_CHECK_FUNCS(getrusage setrlimit stat setlocale)
 AC_CHECK_FUNCS(flockfile funlockfile)
 
-AC_CHECK_FUNCS(sigaction sigprocmask)
-
 AC_REPLACE_FUNCS(vasprintf)
 AC_REPLACE_FUNCS(fopencookie)
-# FIXME: Print a warning when fopencookie is not available.
 AC_REPLACE_FUNCS(mkdtemp)
 AC_REPLACE_FUNCS(fseeko ftello)
 AC_REPLACE_FUNCS(isascii)
 AC_REPLACE_FUNCS(putc_unlocked)
 
+#
+# check for gethrtime and run a testprogram to see whether
+# it is broken.  It has been reported that some Solaris and HP UX systems 
+# raise an SIGILL
+#
+AC_CACHE_CHECK([for gethrtime], 
+               [gnupg_cv_func_gethrtime],
+               [AC_TRY_LINK([#include <sys/times.h>],[
+                   hrtime_t tv;
+                   tv = gethrtime();
+                 ],
+                 [gnupg_cv_func_gethrtime=yes],
+                 [gnupg_cv_func_gethrtime=no])
+               ])
+if test $gnupg_cv_func_gethrtime = yes; then
+     AC_DEFINE([HAVE_GETHRTIME], 1,
+               [Define if you have the `gethrtime(2)' function.])
+     AC_CACHE_CHECK([whether gethrtime is broken], 
+               [gnupg_cv_func_broken_gethrtime],
+               [AC_TRY_RUN([
+                   #include <sys/times.h>
+                   int main () {
+                   hrtime_t tv;
+                   tv = gethrtime(); 
+                 }
+                 ],
+                 [gnupg_cv_func_broken_gethrtime=no],
+                 [gnupg_cv_func_broken_gethrtime=yes],
+                 [gnupg_cv_func_broken_gethrtime=assume-no])
+                ])
+    if test $gnupg_cv_func_broken_gethrtime = yes; then
+      AC_DEFINE([HAVE_BROKEN_GETHRTIME], 1,
+      [Define if `gethrtime(2)' does not work correctly i.e. issues a SIGILL.])
+    fi
+fi
+     
+
+GNUPG_CHECK_MLOCK
+GNUPG_FUNC_MKDIR_TAKES_ONE_ARG
+
+dnl
+dnl Check whether we can use Linux capabilities as requested
+dnl
+if test "$use_capabilities" = "yes" ; then
+use_capabilities=no
+AC_CHECK_HEADERS(sys/capability.h)
+if test "$ac_cv_header_sys_capability_h" = "yes" ; then
+  AC_CHECK_LIB(cap, cap_init, ac_need_libcap=1)
+  if test "$ac_cv_lib_cap_cap_init" = "yes"; then
+     AC_DEFINE(USE_CAPABILITIES,1,
+               [define if capabilities should be used])
+     AC_SUBST(CAPLIBS,"-lcap")
+     use_capabilities=yes
+  fi
+fi
+if test "$use_capabilities" = "no" ; then
+    AC_MSG_WARN([[
+***
+*** The use of capabilities on this system is not possible.
+*** You need a recent Linux kernel and some patches:
+***   fcaps-2.2.9-990610.patch      (kernel patch for 2.2.9)
+***   fcap-module-990613.tar.gz     (kernel module)
+***   libcap-1.92.tar.gz            (user mode library and utilities)
+*** And you have to configure the kernel with CONFIG_VFS_CAP_PLUGIN
+*** set (filesystems menu). Be warned: This code is *really* ALPHA.
+***]])
+fi
+fi
+
+
+# Sanity check regex.  Tests adapted from mutt.
+
+AC_MSG_CHECKING([whether regular expression support is requested])
+AC_ARG_ENABLE(regex,
+[  --disable-regex         do not handle regular expressions in trust sigs],
+     use_regex=$enableval, use_regex=yes)
+AC_MSG_RESULT($use_regex)
+
+if test "$use_regex" = yes ; then
+  AC_MSG_CHECKING([whether the included regex lib is requested])
+  AC_ARG_WITH(included-regex,
+      [  --with-included-regex   use the included GNU regex library],
+      [gnupg_cv_included_regex=yes],[gnupg_cv_included_regex=no])
+  AC_MSG_RESULT($gnupg_cv_included_regex)
+
+  if test $gnupg_cv_included_regex = no ; then
+     # Does the system have regex functions at all?
+     AC_CHECK_FUNC(regcomp,gnupg_cv_included_regex=no,
+                          gnupg_cv_included_regex=yes)
+  fi
+
+  if test $gnupg_cv_included_regex = no ; then
+     AC_CACHE_CHECK([whether your system's regexp library is broken],
+       [gnupg_cv_regex_broken],
+       AC_TRY_RUN([
+#include <unistd.h>
+#include <regex.h>
+main() { regex_t blah ; regmatch_t p; p.rm_eo = p.rm_eo; return regcomp(&blah, "foo.*bar", REG_NOSUB) || regexec (&blah, "foobar", 0, NULL, 0); }],
+       gnupg_cv_regex_broken=no, gnupg_cv_regex_broken=yes, gnupg_cv_regex_broken=yes))
+
+     if test $gnupg_cv_regex_broken = yes ; then
+      AC_MSG_WARN(your regex is broken - using the included GNU regex instead.)
+      gnupg_cv_included_regex=yes
+     fi
+  fi
+
+  if test $gnupg_cv_included_regex = yes; then
+     AC_DEFINE(USE_GNU_REGEX,1,[ Define if you want to use the included regex lib ])
+     AC_SUBST(REGEX_O,regex.o)
+  fi
+else
+
+  AC_DEFINE(DISABLE_REGEX,1,[ Define to disable regular expression support ])
+fi
+
+dnl Do we have zlib? Must do it here because Solaris failed
+dnl when compiling a conftest (due to the "-lz" from LIBS).
+use_local_zlib=yes
+if test "$g10_force_zlib" = "yes"; then
+  :
+else
+  _cppflags="${CPPFLAGS}"
+  _ldflags="${LDFLAGS}"
+
+  AC_ARG_WITH(zlib,
+  [  --with-zlib=DIR         use libz in DIR],[
+    if test -d "$withval"; then
+      CPPFLAGS="${CPPFLAGS} -I$withval/include"
+      LDFLAGS="${LDFLAGS} -L$withval/lib"
+    fi
+  ])
+
+  AC_CHECK_HEADER(zlib.h,
+      AC_CHECK_LIB(z, deflateInit2_,
+       use_local_zlib=no
+       LIBS="$LIBS -lz",
+       CPPFLAGS=${_cppflags} LDFLAGS=${_ldflags}),
+       CPPFLAGS=${_cppflags} LDFLAGS=${_ldflags})
+fi
+if test "$use_local_zlib" = yes ; then
+    AM_CONDITIONAL(ENABLE_LOCAL_ZLIB, true)
+    AC_CONFIG_LINKS(zlib.h:zlib/zlib.h zconf.h:zlib/zconf.h )
+    ZLIBS="../zlib/libzlib.a"
+else
+    AM_CONDITIONAL(ENABLE_LOCAL_ZLIB, false)
+    ZLIBS=
+fi
+AC_SUBST(ZLIBS)
+
+# Allow users to append something to the version string without
+# flagging it as development version.  The user version parts is
+# considered everything after a dash. 
+if test "$development_version" != yes; then
+  changequote(,)dnl
+  tmp_pat='[a-zA-Z]'
+  changequote([,])dnl
+  if echo "$VERSION" | sed 's/-.*//' | grep "$tmp_pat" >/dev/null ; then
+    development_version=yes
+  fi
+fi
+if test "$development_version" = yes; then
+    AC_DEFINE(IS_DEVELOPMENT_VERSION,1,
+            [Defined if this is not a regular release])
+fi
+
+AM_CONDITIONAL(CROSS_COMPILING, test x$cross_compiling = xyes)
+
+GNUPG_CHECK_GNUMAKE
+
+# add some extra libs here so that previous tests don't fail for
+# mysterious reasons - the final link step should bail out. 
+case "${target}" in
+    *-*-mingw32*)
+        LIBS="$LIBS -lwsock32"
+        ;;
+    *)
+       ;;
+esac
+
+
+if test "$GCC" = yes; then
+    if test "$USE_MAINTAINER_MODE" = "yes"; then
+        CFLAGS="$CFLAGS -Wall -Wcast-align -Wshadow -Wstrict-prototypes"
+    else
+        CFLAGS="$CFLAGS -Wall"
+    fi
+fi
+
+AC_SUBST(NETLIBS)
+
+
 # We use jnlib, so tell other modules about it
 AC_DEFINE(HAVE_JNLIB_LOGGING, 1,
         [Defined if jnlib style logging fucntions are available])
 
-
 #
 # Decide what to build
 #
@@ -369,6 +948,64 @@ AM_CONDITIONAL(BUILD_AGENT, test "$build_agent" = "yes")
 AM_CONDITIONAL(BUILD_SCDAEMON, test "$build_scdaemon" = "yes")
 
 
+AC_CONFIG_COMMANDS(g10defs.h,[[
+cat >g10defs.tmp <<G10EOF
+/* Generated automatically by configure */
+/* FIXME: Shouldn't we replace GNUPG_HOMEDIR by GNUPG_DEFAULT_HOMEDIR
+   and we propably can get rid of g10defs.h */
+#ifdef HAVE_DRIVE_LETTERS
+/*#define G10_LOCALEDIR     "c:\\\\lib\\\\gnupg\\\\locale"*/
+#define GNUPG_LIBDIR      "c:\\\\lib\\\\gnupg"
+#define GNUPG_LIBEXECDIR  "c:\\\\lib\\\\gnupg"
+#define GNUPG_DATADIR     "c:\\\\lib\\\\gnupg"
+#define GNUPG_HOMEDIR     "c:\\\\gnupg"
+#else
+/*#define G10_LOCALEDIR     "${datadir}/locale"*/
+#define GNUPG_LIBDIR      "${libdir}/gnupg"
+#define GNUPG_DATADIR     "${datadir}/gnupg"
+#ifdef __VMS
+#define GNUPG_HOMEDIR "/SYS\$LOGIN/gnupg" 
+#else
+#define GNUPG_HOMEDIR "~/.gnupg2" 
+#endif
+#endif
+/* those are here to be redefined by handcrafted g10defs.h.
+   Please note that the string version must not contain more
+   than one character because the using code assumes strlen()==1 */
+#ifdef HAVE_DOSISH_SYSTEM
+#define DIRSEP_C '\\\\'
+#define EXTSEP_C '.'
+#define DIRSEP_S "\\\\"
+#define EXTSEP_S "."
+#else
+#define DIRSEP_C '/'
+#define EXTSEP_C '.'
+#define DIRSEP_S "/"
+#define EXTSEP_S "."
+#endif
+/* This is the same as VERSION, but should be overridden if the
+   platform cannot handle things like dots '.' in filenames. */
+#define SAFE_VERSION VERSION
+G10EOF
+## Do we really need the following?  It defines BYTES_PER-MPI_LIMB
+## cat mpi/mpi-asm-defs.h >>g10defs.tmp 
+if cmp -s g10defs.h g10defs.tmp 2>/dev/null; then
+    echo "g10defs.h is unchanged"
+    rm -f g10defs.tmp
+else
+    rm -f g10defs.h
+    mv g10defs.tmp g10defs.h
+    echo "g10defs.h created"
+fi
+]],[[
+prefix=$prefix
+exec_prefix=$exec_prefix
+libdir=$libdir
+libexecdir=$libexecdir
+datadir=$datadir
+DATADIRNAME=$DATADIRNAME
+]])
+
 AC_CONFIG_FILES([ m4/Makefile 
 Makefile
 po/Makefile.in
@@ -389,6 +1026,8 @@ AC_OUTPUT
 echo "
         GnuPG v${VERSION} has been configured as follows:
         
+        Platform:  $PRINTABLE_OS_NAME ($target)
+
         OpenPGP:   $build_gpg
         S/MIME:    $build_gpgsm
         Agent:     $build_agent $build_agent_threaded
index 176ec10..1ff227f 100644 (file)
@@ -1,4 +1,71 @@
-2003-06-04  Werner Koch  <wk@gnupg.org>
+2003-06-18  Werner Koch  <wk@gnupg.org>
+
+        Finished the bulk of changes for gnupg 1.9.  This included
+       switching to libgcrypt functions, using shared error codes from
+       libgpg-error, replacing the old functions we used to have in
+       ../util by those in ../jnlib and ../common, renaming the malloc
+       functions and a couple of types.  Note, that not all changes are
+       listed below becuause they are too similar and done at far too
+       many places.  As of today the code builds using the current
+       libgcrypt from CVS but it is very unlikely that it actually works.
+       
+       * sig-check.c (cmp_help): Removed.  Was never used.
+
+       * pkglue.c: New. Most stuff taken from gnupg 1.1.2.
+       * pkglue.h: New.
+
+       * misc.c (pull_in_libs): Removed.
+
+       * keygen.c (count_chr): New.
+       (ask_user_id): Removed faked RNG support.
+
+       * misc.c (openpgp_md_map_name,openpgp_cipher_map_name)
+       (openpgp_pk_map_name): New.
+
+       * skclist.c (build_sk_list): Removed faked RNG support.
+       (is_insecure): Removed.
+
+       * comment.c (make_mpi_comment_node): Use gcry MPI print function.
+
+       * keyid.c (v3_keyid): New.
+
+       * misc.c (mpi_write,mpi_write_opaque,mpi_read,mpi_read_opaque)
+       (mpi_print): New.  Taken from gnupg 1.1.2.
+       (checksum_mpi): Replaced by implementation from 1.1.2.
+
+       * g10.c (my_strusage): Renamed from strusage and return NULL
+       instead calling a default function.
+       (add_to_strlist2): New.  Taken from ../util/strgutil.c of gnupg 1.2.
+
+       * plaintext.c (handle_plaintext): New arg CREATE_FILE to cope with
+       the fact that gpg-error does not have this error code anymore.
+
+       * mainproc.c (symkey_decrypt_sesskey): Ditto.
+
+       * seskey.c (make_session_key): Adjusted for use with libgcrypt.
+       (encode_session_key): Ditto.
+       (do_encode_md): Ditto.
+       (encode_md_value): Ditto.
+
+       * keyring.c: Use libgpg-error instead of READ_ERROR etc.
+
+       * g10.c: Adjusted all algorithm name/id mapping functions.
+       (set_debug): Pass MPI and CRYPTO debug values to libgcrypt.
+
+       * Makefile.am (INCLUDES): Define LOCALEDIR and the default error
+       source.
+
+       * g10.c (i18n_init): s/G10_LOCALEDIR/LOCALEDIR/.
+
+       Renamed m_alloc et al to xmalloc et al.
+       s/g10_errstr/gpg_strerror/
+       s/MPI/gcry_mpi_t/
+       Adjusted all md_open calls to the libgcrypt API.
+       
+       * build-packet.c (do_comment): Return error code from iobuf write
+       function.
+       (do_user_id): Ditto.
+       (do_public_key): Ditto.
 
        * Makefile.am: Add new files, link gpg with libgpg-error.
        * g10.c, options.h: New option --agent-program.
index 9143874..6940be6 100644 (file)
 
 ## Process this file with automake to produce Makefile.in
 
-INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/intl
+localedir = $(datadir)/locale
+INCLUDES = -I$(top_srcdir)/common -I$(top_srcdir)/include -I$(top_srcdir)/intl -DLOCALEDIR=\"$(localedir)\"
+
 EXTRA_DIST = options.skel
 # it seems that we can't use this with automake 1.5
 #OMIT_DEPENDENCIES = zlib.h zconf.h
 libexecdir = @libexecdir@/@PACKAGE@
-# FIXME: Windows support currently not enabled
-#if ! HAVE_DOSISH_SYSTEM
-#AM_CFLAGS = -DGNUPG_LIBEXECDIR="\"$(libexecdir)\""
-#endif
-needed_libs = ../cipher/libcipher.a ../mpi/libmpi.a ../util/libutil.a
+if ! HAVE_DOSISH_SYSTEM
+AM_CFLAGS = -DGNUPG_LIBEXECDIR="\"$(libexecdir)\""
+endif
+needed_libs = ../common/libcommon.a ../jnlib/libjnlib.a
 
 #noinst_PROGRAMS = gpgd
 bin_PROGRAMS = gpg gpgv
@@ -62,6 +63,7 @@ common_source =  \
              plaintext.c       \
              sig-check.c       \
              keylist.c         \
+             pkglue.c pkglue.h \
              signal.c
 
 gpg_SOURCES  = g10.c           \
@@ -108,8 +110,9 @@ gpgv_SOURCES = gpgv.c           \
 #             ks-db.h \
 #             $(common_source)
 
-LDADD =  $(needed_libs) @INTLLIBS@ @CAPLIBS@ @ZLIBS@
-gpg_LDADD = $(LDADD) @DLLIBS@ @EGDLIBS@ -lgpg-error
+LDADD =  $(needed_libs) @INTLLIBS@ @CAPLIBS@ @ZLIBS@ 
+gpg_LDADD = $(LIBGCRYPT_LIBS) $(LDADD) -lassuan -lgpg-error
+gpgv_LDADD = $(LIBGCRYPT_LIBS) $(LDADD) -lassuan -lgpg-error
 
 $(PROGRAMS): $(needed_libs)
 
index f007422..c6930e2 100644 (file)
@@ -27,6 +27,7 @@
 #include <assert.h>
 #include <ctype.h>
 
+#include "gpg.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "memory.h"
@@ -192,7 +193,7 @@ is_armored( const byte *buf )
  *        filter to do further processing.
  */
 int
-use_armor_filter( IOBUF a )
+use_armor_filter( iobuf_t a )
 {
     byte buf[1];
     int n;
@@ -337,7 +338,7 @@ parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
     int hashes=0;
     unsigned int len2;
 
-    len2 = check_trailing_ws( line, len );
+    len2 = length_sans_trailing_ws( line, len );
     if( !len2 ) {
         afx->buffer_pos = len2;  /* (it is not the fine way to do it here) */
        return 0; /* WS only: same as empty line */
@@ -376,7 +377,7 @@ parse_header_line( armor_filter_context_t *afx, byte *line, unsigned int len )
 
 /* figure out whether the data is armored or not */
 static int
-check_input( armor_filter_context_t *afx, IOBUF a )
+check_input( armor_filter_context_t *afx, iobuf_t a )
 {
     int rc = 0;
     int i;
@@ -418,7 +419,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
            if( hdr_line == BEGIN_SIGNED_MSG_IDX ) {
                if( afx->in_cleartext ) {
                    log_error(_("nested clear text signatures\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = GPG_ERR_INV_ARMOR;
                }
                afx->in_cleartext = 1;
            }
@@ -448,7 +449,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
        i = parse_header_line( afx, line, len );
        if( i <= 0 ) {
            if( i )
-               rc = G10ERR_INVALID_ARMOR;
+               rc = GPG_ERR_INV_ARMOR;
            break;
        }
     }
@@ -476,7 +477,7 @@ check_input( armor_filter_context_t *afx, IOBUF a )
  *       not implemented/checked.
  */
 static int
-fake_packet( armor_filter_context_t *afx, IOBUF a,
+fake_packet( armor_filter_context_t *afx, iobuf_t a,
             size_t *retn, byte *buf, size_t size  )
 {
     int rc = 0;
@@ -615,12 +616,12 @@ invalid_crc(void)
     if ( opt.ignore_crc_error )
         return 0;
     log_inc_errorcount();
-    return G10ERR_INVALID_ARMOR;
+    return GPG_ERR_INV_ARMOR;
 }
 
 
 static int
-radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
+radix64_read( armor_filter_context_t *afx, iobuf_t a, size_t *retn,
              byte *buf, size_t size )
 {
     byte val;
@@ -785,11 +786,11 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
                    rc = 0;
                else if( rc == 2 ) {
                    log_error(_("premature eof (in Trailer)\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = GPG_ERR_INV_ARMOR;
                }
                else {
                    log_error(_("error in trailer line\n"));
-                   rc = G10ERR_INVALID_ARMOR;
+                   rc = GPG_ERR_INV_ARMOR;
                }
 #endif
            }
@@ -808,7 +809,7 @@ radix64_read( armor_filter_context_t *afx, IOBUF a, size_t *retn,
  */
 int
 armor_filter( void *opaque, int control,
-            IOBUF a, byte *buf, size_t *ret_len)
+            iobuf_t a, byte *buf, size_t *ret_len)
 {
     size_t size = *ret_len;
     armor_filter_context_t *afx = opaque;
@@ -1081,7 +1082,7 @@ armor_filter( void *opaque, int control,
        if( afx->qp_detected )
            log_error(_("quoted printable character in armor - "
                        "probably a buggy MTA has been used\n") );
-       m_free( afx->buffer );
+       xfree ( afx->buffer );
        afx->buffer = NULL;
     }
     else if( control == IOBUFCTRL_DESC )
@@ -1098,7 +1099,7 @@ make_radix64_string( const byte *data, size_t len )
 {
     char *buffer, *p;
 
-    buffer = p = m_alloc( (len+2)/3*4 + 1 );
+    buffer = p = xmalloc ( (len+2)/3*4 + 1 );
     for( ; len >= 3 ; len -= 3, data += 3 ) {
        *p++ = bintoasc[(data[0] >> 2) & 077];
        *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
@@ -1158,14 +1159,14 @@ unarmor_pump_new (void)
 
     if( !is_initialized )
         initialize();
-    x = m_alloc_clear (sizeof *x);
+    x = xcalloc (1,sizeof *x);
     return x;
 }
 
 void
 unarmor_pump_release (UnarmorPump x)
 {
-    m_free (x);
+    xfree (x);
 }
 
 /* 
index 86aa07d..a317752 100644 (file)
@@ -25,6 +25,7 @@
 #include <string.h>
 #include <assert.h>
 
+#include "gpg.h"
 #include "packet.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "options.h"
 
 
-static int do_comment( IOBUF out, int ctb, PKT_comment *rem );
-static int do_user_id( IOBUF out, int ctb, PKT_user_id *uid );
-static int do_public_key( IOBUF out, int ctb, PKT_public_key *pk );
-static int do_secret_key( IOBUF out, int ctb, PKT_secret_key *pk );
-static int do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc );
-static int do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc );
+static int do_comment( iobuf_t out, int ctb, PKT_comment *rem );
+static int do_user_id( iobuf_t out, int ctb, PKT_user_id *uid );
+static int do_public_key( iobuf_t out, int ctb, PKT_public_key *pk );
+static int do_secret_key( iobuf_t out, int ctb, PKT_secret_key *pk );
+static int do_symkey_enc( iobuf_t out, int ctb, PKT_symkey_enc *enc );
+static int do_pubkey_enc( iobuf_t out, int ctb, PKT_pubkey_enc *enc );
 static u32 calc_plaintext( PKT_plaintext *pt );
-static int do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt );
-static int do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed );
-static int do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed );
-static int do_compressed( IOBUF out, int ctb, PKT_compressed *cd );
-static int do_signature( IOBUF out, int ctb, PKT_signature *sig );
-static int do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops );
+static int do_plaintext( iobuf_t out, int ctb, PKT_plaintext *pt );
+static int do_encrypted( iobuf_t out, int ctb, PKT_encrypted *ed );
+static int do_encrypted_mdc( iobuf_t out, int ctb, PKT_encrypted *ed );
+static int do_compressed( iobuf_t out, int ctb, PKT_compressed *cd );
+static int do_signature( iobuf_t out, int ctb, PKT_signature *sig );
+static int do_onepass_sig( iobuf_t out, int ctb, PKT_onepass_sig *ops );
 
 static int calc_header_length( u32 len, int new_ctb );
-static int write_16(IOBUF inp, u16 a);
-static int write_32(IOBUF inp, u32 a);
-static int write_header( IOBUF out, int ctb, u32 len );
-static int write_sign_packet_header( IOBUF out, int ctb, u32 len );
-static int write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode );
-static int write_new_header( IOBUF out, int ctb, u32 len, int hdrlen );
-static int write_version( IOBUF out, int ctb );
+static int write_16(iobuf_t inp, u16 a);
+static int write_32(iobuf_t inp, u32 a);
+static int write_header( iobuf_t out, int ctb, u32 len );
+static int write_sign_packet_header( iobuf_t out, int ctb, u32 len );
+static int write_header2( iobuf_t out, int ctb, u32 len, int hdrlen, int blkmode );
+static int write_new_header( iobuf_t out, int ctb, u32 len, int hdrlen );
+static int write_version( iobuf_t out, int ctb );
 
 /****************
  * Build a packet and write it to INP
@@ -65,7 +66,7 @@ static int write_version( IOBUF out, int ctb );
  * Note: Caller must free the packet
  */
 int
-build_packet( IOBUF out, PACKET *pkt )
+build_packet( iobuf_t out, PACKET *pkt )
 {
     int new_ctb=0, rc=0, ctb;
     int pkttype;
@@ -179,51 +180,56 @@ calc_packet_length( PACKET *pkt )
 }
 
 static void
-write_fake_data( IOBUF out, MPI a )
+write_fake_data( iobuf_t out, gcry_mpi_t a )
 {
     if( a ) {
-       int i;
+       unsigned int n;
        void *p;
 
-       p = mpi_get_opaque( a, &i );
-       iobuf_write( out, p, i );
+        assert( gcry_mpi_get_flag (a, GCRYMPI_FLAG_OPAQUE));
+        p = gcry_mpi_get_opaque (a, &n);
+        iobuf_write (out, p, (n+7)/8);
     }
 }
 
 
 static int
-do_comment( IOBUF out, int ctb, PKT_comment *rem )
+do_comment (iobuf_t out, int ctb, PKT_comment *rem)
 {
-    if( opt.sk_comments ) {
-       write_header(out, ctb, rem->len);
-       if( iobuf_write( out, rem->data, rem->len ) )
-           return G10ERR_WRITE_FILE;
+  int rc = 0;
+
+  if (opt.sk_comments)
+    {
+      write_header(out, ctb, rem->len);
+      rc = iobuf_write( out, rem->data, rem->len );
     }
-    return 0;
+  return rc;
 }
 
 static int
-do_user_id( IOBUF out, int ctb, PKT_user_id *uid )
+do_user_id( iobuf_t out, int ctb, PKT_user_id *uid )
 {
-    if( uid->attrib_data ) {
-       write_header(out, ctb, uid->attrib_len);
-       if( iobuf_write( out, uid->attrib_data, uid->attrib_len ) )
-           return G10ERR_WRITE_FILE;
+  int rc;
+
+  if (uid->attrib_data)
+    {
+      write_header (out, ctb, uid->attrib_len);
+      rc = iobuf_write (out, uid->attrib_data, uid->attrib_len );
     }
-    else {
-       write_header(out, ctb, uid->len);
-       if( iobuf_write( out, uid->name, uid->len ) )
-           return G10ERR_WRITE_FILE;
+  else
+    {
+      write_header (out, ctb, uid->len);
+      rc = iobuf_write (out, uid->name, uid->len );
     }
-    return 0;
+  return rc;
 }
 
 static int
-do_public_key( IOBUF out, int ctb, PKT_public_key *pk )
+do_public_key( iobuf_t out, int ctb, PKT_public_key *pk )
 {
     int rc = 0;
     int n, i;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 
     if( !pk->version )
        iobuf_put( a, 3 );
@@ -246,8 +252,7 @@ do_public_key( IOBUF out, int ctb, PKT_public_key *pk )
        mpi_write(a, pk->pkey[i] );
 
     write_header2(out, ctb, iobuf_get_temp_length(a), pk->hdrbytes, 1 );
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a);
 
     iobuf_close(a);
     return rc;
@@ -265,7 +270,7 @@ hash_public_key( MD_HANDLE md, PKT_public_key *pk )
     int ctb;
     ulong pktlen;
     int c;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 #if 0
     FILE *fp = fopen("dump.pk", "a");
     int i=0;
@@ -278,7 +283,7 @@ hash_public_key( MD_HANDLE md, PKT_public_key *pk )
     pkt.pkttype = PKT_PUBLIC_KEY;
     pkt.pkt.public_key = pk;
     if( (rc = build_packet( a, &pkt )) )
-       log_fatal("build public_key for hashing failed: %s\n", g10_errstr(rc));
+       log_fatal("build public_key for hashing failed: %s\n", gpg_strerror (rc));
 
     if( !(pk->version == 3 && pk->pubkey_algo == 16) ) {
        /* skip the constructed header but don't do this for our very old
@@ -309,10 +314,10 @@ hash_public_key( MD_HANDLE md, PKT_public_key *pk )
            }
        }
        /* hash a header */
-       md_putc( md, 0x99 );
+       gcry_md_putc ( md, 0x99 );
        pktlen &= 0xffff; /* can't handle longer packets */
-       md_putc( md, pktlen >> 8 );
-       md_putc( md, pktlen & 0xff );
+       gcry_md_putc ( md, pktlen >> 8 );
+       gcry_md_putc ( md, pktlen & 0xff );
     }
     /* hash the packet body */
     while( (c=iobuf_get(a)) != -1 ) {
@@ -323,7 +328,7 @@ hash_public_key( MD_HANDLE md, PKT_public_key *pk )
            i=0;
        }
 #endif
-       md_putc( md, c );
+       gcry_md_putc ( md, c );
     }
 #if 0
     putc('\n', fp);
@@ -334,11 +339,11 @@ hash_public_key( MD_HANDLE md, PKT_public_key *pk )
 
 
 static int
-do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
+do_secret_key( iobuf_t out, int ctb, PKT_secret_key *sk )
 {
     int rc = 0;
     int i, nskey, npkey;
-    IOBUF a = iobuf_temp(); /* build in a self-enlarging buffer */
+    iobuf_t a = iobuf_temp(); /* build in a self-enlarging buffer */
 
     /* Write the version number - if none is specified, use 3 */
     if( !sk->version )
@@ -366,7 +371,7 @@ do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
 
     /* If we don't have any public parameters - which is the case if
        we don't know the algorithm used - the parameters are stored as
-       one blob in a faked (opaque) MPI */
+       one blob in a faked (opaque) gcry_mpi_t */
     if( !npkey ) {
        write_fake_data( a, sk->skey[0] );
        goto leave;
@@ -423,19 +428,19 @@ do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
     else if( sk->is_protected && sk->version >= 4 ) {
         /* The secret key is protected - write it out as it is */
        byte *p;
-       assert( mpi_is_opaque( sk->skey[npkey] ) );
-       p = mpi_get_opaque( sk->skey[npkey], &i );
-       iobuf_write(a, p, i );
+       assert( gcry_mpi_get_flag( sk->skey[npkey], GCRYMPI_FLAG_OPAQUE ) );
+       p = gcry_mpi_get_opaque( sk->skey[npkey], &i );
+       iobuf_write(a, p, (i+7)/8 );
     }
     else if( sk->is_protected ) {
-        /* The secret key is protected te old v4 way. */
+        /* The secret key is protected the old v4 way. */
        for(   ; i < nskey; i++ ) {
             byte *p;
-            int ndata;
+            size_t n;
 
-            assert (mpi_is_opaque (sk->skey[i]));
-            p = mpi_get_opaque (sk->skey[i], &ndata);
-            iobuf_write (a, p, ndata);
+            assert( gcry_mpi_get_flag (sk->skey[i], GCRYMPI_FLAG_OPAQUE));
+            p = gcry_mpi_get_opaque( sk->skey[i], &n );
+            iobuf_write (a, p, (n+7)/8);
         }
        write_16(a, sk->csum );
     }
@@ -451,18 +456,17 @@ do_secret_key( IOBUF out, int ctb, PKT_secret_key *sk )
        the other stuff, so that we know the length of the packet */
     write_header2(out, ctb, iobuf_get_temp_length(a), sk->hdrbytes, 1 );
     /* And finally write it out the real stream */
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a );
 
     iobuf_close(a); /* close the remporary buffer */
     return rc;
 }
 
 static int
-do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
+do_symkey_enc( iobuf_t out, int ctb, PKT_symkey_enc *enc )
 {
     int rc = 0;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 
     assert( enc->version == 4 );
     switch( enc->s2k.mode ) {
@@ -482,8 +486,7 @@ do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
        iobuf_write(a, enc->seskey, enc->seskeylen );
 
     write_header(out, ctb, iobuf_get_temp_length(a) );
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a);
 
     iobuf_close(a);
     return rc;
@@ -493,11 +496,11 @@ do_symkey_enc( IOBUF out, int ctb, PKT_symkey_enc *enc )
 
 
 static int
-do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
+do_pubkey_enc( iobuf_t out, int ctb, PKT_pubkey_enc *enc )
 {
     int rc = 0;
     int n, i;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 
     write_version( a, ctb );
     if( enc->throw_keyid ) {
@@ -516,8 +519,7 @@ do_pubkey_enc( IOBUF out, int ctb, PKT_pubkey_enc *enc )
        mpi_write(a, enc->data[i] );
 
     write_header(out, ctb, iobuf_get_temp_length(a) );
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a);
 
     iobuf_close(a);
     return rc;
@@ -533,7 +535,7 @@ calc_plaintext( PKT_plaintext *pt )
 }
 
 static int
-do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
+do_plaintext( iobuf_t out, int ctb, PKT_plaintext *pt )
 {
     int i, rc = 0;
     u32 n;
@@ -551,15 +553,13 @@ do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
     iobuf_put(out, pt->namelen );
     for(i=0; i < pt->namelen; i++ )
        iobuf_put(out, pt->name[i] );
-    if( write_32(out, pt->timestamp ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = write_32 (out, pt->timestamp);
 
     n = 0;
     while( (nbytes=iobuf_read(pt->buf, buf, 1000)) != -1 ) {
-       if( iobuf_write(out, buf, nbytes) == -1 ) {
-           rc = G10ERR_WRITE_FILE;
-           break;
-       }
+        rc = iobuf_write(out, buf, nbytes);
+        if (rc)
+          break;
        n += nbytes;
     }
     wipememory(buf,1000); /* burn the buffer */
@@ -575,7 +575,7 @@ do_plaintext( IOBUF out, int ctb, PKT_plaintext *pt )
 
 
 static int
-do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
+do_encrypted( iobuf_t out, int ctb, PKT_encrypted *ed )
 {
     int rc = 0;
     u32 n;
@@ -589,7 +589,7 @@ do_encrypted( IOBUF out, int ctb, PKT_encrypted *ed )
 }
 
 static int
-do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
+do_encrypted_mdc( iobuf_t out, int ctb, PKT_encrypted *ed )
 {
     int rc = 0;
     u32 n;
@@ -608,7 +608,7 @@ do_encrypted_mdc( IOBUF out, int ctb, PKT_encrypted *ed )
 
 
 static int
-do_compressed( IOBUF out, int ctb, PKT_compressed *cd )
+do_compressed( iobuf_t out, int ctb, PKT_compressed *cd )
 {
     int rc = 0;
 
@@ -816,12 +816,12 @@ build_sig_subpkt (PKT_signature *sig, sigsubpkttype_t type,
         /*log_debug ("updating area for type %d\n", type );*/
     }
     else if (oldarea) {
-        newarea = m_realloc (oldarea, sizeof (*newarea) + n - 1);
+        newarea = xrealloc (oldarea, sizeof (*newarea) + n - 1);
         newarea->size = n;
         /*log_debug ("reallocating area for type %d\n", type );*/
     }
     else {
-        newarea = m_alloc (sizeof (*newarea) + n - 1);
+        newarea = xmalloc (sizeof (*newarea) + n - 1);
         newarea->size = n;
         /*log_debug ("allocating area for type %d\n", type );*/
     }
@@ -922,7 +922,7 @@ build_attribute_subpkt(PKT_user_id *uid,byte type,
 
   /* realloc uid->attrib_data to the right size */
 
-  uid->attrib_data=m_realloc(uid->attrib_data,
+  uid->attrib_data=xrealloc(uid->attrib_data,
                             uid->attrib_len+idx+1+headerlen+buflen);
 
   attrib=&uid->attrib_data[uid->attrib_len];
@@ -954,11 +954,11 @@ build_attribute_subpkt(PKT_user_id *uid,byte type,
 }
 
 static int
-do_signature( IOBUF out, int ctb, PKT_signature *sig )
+do_signature( iobuf_t out, int ctb, PKT_signature *sig )
 {
     int rc = 0;
     int n, i;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 
     if( !sig->version )
        iobuf_put( a, 3 );
@@ -1000,8 +1000,7 @@ do_signature( IOBUF out, int ctb, PKT_signature *sig )
        write_sign_packet_header(out, ctb, iobuf_get_temp_length(a) );
     else
        write_header(out, ctb, iobuf_get_temp_length(a) );
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a);
 
     iobuf_close(a);
     return rc;
@@ -1009,10 +1008,10 @@ do_signature( IOBUF out, int ctb, PKT_signature *sig )
 
 
 static int
-do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
+do_onepass_sig( iobuf_t out, int ctb, PKT_onepass_sig *ops )
 {
     int rc = 0;
-    IOBUF a = iobuf_temp();
+    iobuf_t a = iobuf_temp();
 
     write_version( a, ctb );
     iobuf_put(a, ops->sig_class );
@@ -1023,8 +1022,7 @@ do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
     iobuf_put(a, ops->last );
 
     write_header(out, ctb, iobuf_get_temp_length(a) );
-    if( iobuf_write_temp( out, a ) )
-       rc = G10ERR_WRITE_FILE;
+    rc = iobuf_write_temp (out, a);
 
     iobuf_close(a);
     return rc;
@@ -1032,23 +1030,19 @@ do_onepass_sig( IOBUF out, int ctb, PKT_onepass_sig *ops )
 
 
 static int
-write_16(IOBUF out, u16 a)
+write_16(iobuf_t out, u16 a)
 {
     iobuf_put(out, a>>8);
-    if( iobuf_put(out,a) )
-       return -1;
-    return 0;
+    return iobuf_put(out,a);
 }
 
 static int
-write_32(IOBUF out, u32 a)
+write_32(iobuf_t out, u32 a)
 {
     iobuf_put(out, a>> 24);
     iobuf_put(out, a>> 16);
     iobuf_put(out, a>> 8);
-    if( iobuf_put(out, a) )
-       return -1;
-    return 0;
+    return iobuf_put (out, a);
 }
 
 
@@ -1081,14 +1075,14 @@ calc_header_length( u32 len, int new_ctb )
  * Write the CTB and the packet length
  */
 static int
-write_header( IOBUF out, int ctb, u32 len )
+write_header( iobuf_t out, int ctb, u32 len )
 {
     return write_header2( out, ctb, len, 0, 1 );
 }
 
 
 static int
-write_sign_packet_header( IOBUF out, int ctb, u32 len )
+write_sign_packet_header( iobuf_t out, int ctb, u32 len )
 {
     /* work around a bug in the pgp read function for signature packets,
      * which are not correctly coded and silently assume at some
@@ -1103,7 +1097,7 @@ write_sign_packet_header( IOBUF out, int ctb, u32 len )
  * we need this, so that we can hash packets without reading them again.
  */
 static int
-write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode )
+write_header2( iobuf_t out, int ctb, u32 len, int hdrlen, int blkmode )
 {
     if( ctb & 0x40 )
        return write_new_header( out, ctb, len, hdrlen );
@@ -1149,7 +1143,7 @@ write_header2( IOBUF out, int ctb, u32 len, int hdrlen, int blkmode )
 
 
 static int
-write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
+write_new_header( iobuf_t out, int ctb, u32 len, int hdrlen )
 {
     if( hdrlen )
        log_bug("can't cope with hdrlen yet\n");
@@ -1188,7 +1182,7 @@ write_new_header( IOBUF out, int ctb, u32 len, int hdrlen )
 }
 
 static int
-write_version( IOBUF out, int ctb )
+write_version( iobuf_t out, int ctb )
 {
     if( iobuf_put( out, 3 ) )
        return -1;
index 6cc514d..e888820 100644 (file)
 #include <unistd.h> 
 #include <time.h>
 #include <assert.h>
-#include <gcrypt.h>
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif
 #include <assuan.h>
 
 #include "gpg.h"
+#include "util.h"
+#include "membuf.h"
+#include "options.h"
 #include "i18n.h"
+#include "call-agent.h"
+
+#ifndef DBG_ASSUAN
+# define DBG_ASSUAN 1
+#endif
 
 static ASSUAN_CONTEXT agent_ctx = NULL;
 static int force_pipe_server = 0;
@@ -175,7 +182,7 @@ start_agent (void)
       char *optstr;
       if (asprintf (&optstr, "OPTION display=%s",
                    opt.display ? opt.display : dft_display) < 0)
-       return OUT_OF_CORE (errno);
+       return gpg_error_from_errno (errno);
       rc = assuan_transact (agent_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
                            NULL);
       free (optstr);
@@ -193,7 +200,7 @@ start_agent (void)
       char *optstr;
       if (asprintf (&optstr, "OPTION ttyname=%s",
                    opt.ttyname ? opt.ttyname : dft_ttyname) < 0)
-       return OUT_OF_CORE (errno);
+       return gpg_error_from_errno (errno);
       rc = assuan_transact (agent_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
                            NULL);
       free (optstr);
@@ -206,7 +213,7 @@ start_agent (void)
       char *optstr;
       if (asprintf (&optstr, "OPTION ttytype=%s",
                    opt.ttyname ? opt.ttytype : dft_ttytype) < 0)
-       return OUT_OF_CORE (errno);
+       return gpg_error_from_errno (errno);
       rc = assuan_transact (agent_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
                            NULL);
       free (optstr);
@@ -219,7 +226,8 @@ start_agent (void)
     {
       old_lc = strdup (old_lc);
       if (!old_lc)
-        return OUT_OF_CORE (errno);
+        return gpg_error_from_errno (errno);
+
     }
   dft_lc = setlocale (LC_CTYPE, "");
 #endif
@@ -228,7 +236,7 @@ start_agent (void)
       char *optstr;
       if (asprintf (&optstr, "OPTION lc-ctype=%s",
                    opt.lc_ctype ? opt.lc_ctype : dft_lc) < 0)
-       rc = OUT_OF_CORE (errno);
+       rc = gpg_error_from_errno (errno);
       else
        {
          rc = assuan_transact (agent_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
@@ -253,7 +261,7 @@ start_agent (void)
     {
       old_lc = strdup (old_lc);
       if (!old_lc)
-        return OUT_OF_CORE (errno);
+        return gpg_error_from_errno (errno);
     }
   dft_lc = setlocale (LC_MESSAGES, "");
 #endif
@@ -262,7 +270,7 @@ start_agent (void)
       char *optstr;
       if (asprintf (&optstr, "OPTION lc-messages=%s",
                    opt.lc_messages ? opt.lc_messages : dft_lc) < 0)
-       rc = OUT_OF_CORE (errno);
+       rc = gpg_error_from_errno (errno);
       else
        {
          rc = assuan_transact (agent_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
index ab7c9b6..3d51a87 100644 (file)
@@ -1,5 +1,5 @@
 /* cipher.c - En-/De-ciphering filter
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <assert.h>
 
+#include "gpg.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "memory.h"
 
 
 static void
-write_header( cipher_filter_context_t *cfx, IOBUF a )
+write_header( cipher_filter_context_t *cfx, iobuf_t a )
 {
     PACKET pkt;
     PKT_encrypted ed;
     byte temp[18];
-    unsigned blocksize;
-    unsigned nprefix;
+    unsigned int blocksize;
+    unsigned int nprefix;
+    gpg_error_t rc;
 
-    blocksize = cipher_get_blocksize( cfx->dek->algo );
+    blocksize = gcry_cipher_get_algo_blklen ( cfx->dek->algo );
     if( blocksize < 8 || blocksize > 16 )
        log_fatal("unsupported blocksize %u\n", blocksize );
 
@@ -58,9 +60,9 @@ write_header( cipher_filter_context_t *cfx, IOBUF a )
     ed.new_ctb = !ed.len && !RFC1991;
     if( cfx->dek->use_mdc ) {
        ed.mdc_method = DIGEST_ALGO_SHA1;
-       cfx->mdc_hash = md_open( DIGEST_ALGO_SHA1, 0 );
+       gcry_md_open (&cfx->mdc_hash, GCRY_MD_SHA1, 0 );
        if ( DBG_HASHING )
-           md_start_debug( cfx->mdc_hash, "creatmdc" );
+           gcry_md_start_debug ( cfx->mdc_hash, "creatmdc" );
     }
 
     {
@@ -76,21 +78,28 @@ write_header( cipher_filter_context_t *cfx, IOBUF a )
     if( build_packet( a, &pkt ))
        log_bug("build_packet(ENCR_DATA) failed\n");
     nprefix = blocksize;
-    randomize_buffer( temp, nprefix, 1 );
+    gcry_randomize ( temp, nprefix, GCRY_STRONG_RANDOM);
     temp[nprefix] = temp[nprefix-2];
     temp[nprefix+1] = temp[nprefix-1];
     print_cipher_algo_note( cfx->dek->algo );
-    cfx->cipher_hd = cipher_open( cfx->dek->algo,
-                                 cfx->dek->use_mdc? CIPHER_MODE_CFB
-                                        : CIPHER_MODE_AUTO_CFB, 1 );
+    rc = gcry_cipher_open (&cfx->cipher_hd, cfx->dek->algo,
+                           GCRY_CIPHER_MODE_CFB,
+                           GCRY_CIPHER_SECURE
+                           | ((cfx->dek->use_mdc || cfx->dek->algo >= 100) ?
+                              0 : GCRY_CIPHER_ENABLE_SYNC));
+    if (rc) {
+       /* we should never get an error here cause we already checked, that
+        * the algorithm is available. */
+       BUG();
+    }
 /*   log_hexdump( "thekey", cfx->dek->key, cfx->dek->keylen );*/
-    cipher_setkey( cfx->cipher_hd, cfx->dek->key, cfx->dek->keylen );
-    cipher_setiv( cfx->cipher_hd, NULL, 0 );
+    gcry_cipher_setkey( cfx->cipher_hd, cfx->dek->key, cfx->dek->keylen );
+    gcry_cipher_setiv( cfx->cipher_hd, NULL, 0 );
 /*  log_hexdump( "prefix", temp, nprefix+2 ); */
     if( cfx->mdc_hash ) /* hash the "IV" */
-       md_write( cfx->mdc_hash, temp, nprefix+2 );
-    cipher_encrypt( cfx->cipher_hd, temp, temp, nprefix+2);
-    cipher_sync( cfx->cipher_hd );
+       gcry_md_write( cfx->mdc_hash, temp, nprefix+2 );
+    gcry_cipher_encrypt( cfx->cipher_hd, temp, nprefix+2, NULL, 0);
+    gcry_cipher_sync( cfx->cipher_hd );
     iobuf_write(a, temp, nprefix+2);
     cfx->header=1;
 }
@@ -102,7 +111,7 @@ write_header( cipher_filter_context_t *cfx, IOBUF a )
  */
 int
 cipher_filter( void *opaque, int control,
-              IOBUF a, byte *buf, size_t *ret_len)
+              iobuf_t a, byte *buf, size_t *ret_len)
 {
     size_t size = *ret_len;
     cipher_filter_context_t *cfx = opaque;
@@ -117,36 +126,40 @@ cipher_filter( void *opaque, int control,
            write_header( cfx, a );
        }
        if( cfx->mdc_hash )
-           md_write( cfx->mdc_hash, buf, size );
-       cipher_encrypt( cfx->cipher_hd, buf, buf, size);
-       if( iobuf_write( a, buf, size ) )
-           rc = G10ERR_WRITE_FILE;
+           gcry_md_write( cfx->mdc_hash, buf, size );
+       gcry_cipher_encrypt( cfx->cipher_hd, buf, size, NULL, 0);
+       rc = iobuf_write( a, buf, size );
     }
     else if( control == IOBUFCTRL_FREE ) {
        if( cfx->mdc_hash ) {
            byte *hash;
-           int hashlen = md_digest_length( md_get_algo( cfx->mdc_hash ) );
+           int hashlen = gcry_md_get_algo_dlen (gcry_md_get_algo (
+                                                            cfx->mdc_hash));
            byte temp[22];
 
            assert( hashlen == 20 );
            /* we must hash the prefix of the MDC packet here */
            temp[0] = 0xd3;
            temp[1] = 0x14;
-           md_putc( cfx->mdc_hash, temp[0] );
-           md_putc( cfx->mdc_hash, temp[1] );
+           gcry_md_putc ( cfx->mdc_hash, temp[0] );
+           gcry_md_putc ( cfx->mdc_hash, temp[1] );
 
-           md_final( cfx->mdc_hash );
-           hash = md_read( cfx->mdc_hash, 0 );
+           gcry_md_final ( cfx->mdc_hash );
+           hash = gcry_md_read ( cfx->mdc_hash, 0 );
            memcpy(temp+2, hash, 20);
-           cipher_encrypt( cfx->cipher_hd, temp, temp, 22 );
-           md_close( cfx->mdc_hash ); cfx->mdc_hash = NULL;
-           if( iobuf_write( a, temp, 22 ) )
+           gcry_cipher_encrypt( cfx->cipher_hd, temp, 22, NULL, 0 );
+           gcry_md_close ( cfx->mdc_hash ); cfx->mdc_hash = NULL;
+           rc = iobuf_write( a, temp, 22 );
+            if (rc)
                log_error("writing MDC packet failed\n" );
        }
-       cipher_close(cfx->cipher_hd);
+       gcry_cipher_close (cfx->cipher_hd);
     }
     else if( control == IOBUFCTRL_DESC ) {
        *(char**)buf = "cipher_filter";
     }
     return rc;
 }
+
+
+
index 6d27e48..3108351 100644 (file)
@@ -1,5 +1,5 @@
 /* comment.c - write comment stuff
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -37,7 +37,7 @@
 
 
 int
-write_comment( IOBUF out, const char *s )
+write_comment( iobuf_t out, const char *s )
 {
     PACKET pkt;
     size_t n = strlen(s);
@@ -45,18 +45,18 @@ write_comment( IOBUF out, const char *s )
 
     pkt.pkttype = PKT_COMMENT;
     if( *s != '#' ) {
-       pkt.pkt.comment = m_alloc( sizeof *pkt.pkt.comment + n );
+       pkt.pkt.comment = xmalloc ( sizeof *pkt.pkt.comment + n );
        pkt.pkt.comment->len = n+1;
        *pkt.pkt.comment->data = '#';
        strcpy(pkt.pkt.comment->data+1, s);
     }
     else {
-       pkt.pkt.comment = m_alloc( sizeof *pkt.pkt.comment + n - 1 );
+       pkt.pkt.comment = xmalloc ( sizeof *pkt.pkt.comment + n - 1 );
        pkt.pkt.comment->len = n;
        strcpy(pkt.pkt.comment->data, s);
     }
     if( (rc = build_packet( out, &pkt )) )
-       log_error("build_packet(comment) failed: %s\n", g10_errstr(rc) );
+       log_error("build_packet(comment) failed: %s\n", gpg_strerror (rc) );
     free_packet( &pkt );
     return rc;
 }
@@ -68,9 +68,9 @@ make_comment_node( const char *s )
     PACKET *pkt;
     size_t n = strlen(s);
 
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_COMMENT;
-    pkt->pkt.comment = m_alloc( sizeof *pkt->pkt.comment + n - 1 );
+    pkt->pkt.comment = xmalloc ( sizeof *pkt->pkt.comment + n - 1 );
     pkt->pkt.comment->len = n;
     strcpy(pkt->pkt.comment->data, s);
     return new_kbnode( pkt );
@@ -78,25 +78,29 @@ make_comment_node( const char *s )
 
 
 KBNODE
-make_mpi_comment_node( const char *s, MPI a )
+make_mpi_comment_node( const char *s, gcry_mpi_t a )
 {
     PACKET *pkt;
-    byte *buf, *p, *pp;
-    unsigned n1, nb1;
+    byte *buf, *pp;
+    size_t n1, nb1;
     size_t n = strlen(s);
 
     nb1 = mpi_get_nbits( a );
-    p = buf = mpi_get_buffer( a, &n1, NULL );
-    pkt = m_alloc_clear( sizeof *pkt );
+    if (gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, &n1, a))
+      BUG ();
+    /* fixme: allocate it on the stack */
+    buf = xmalloc (n1);
+    if (gcry_mpi_print (GCRYMPI_FMT_PGP, buf, &n1, a))
+      BUG ();
+
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_COMMENT;
-    pkt->pkt.comment = m_alloc( sizeof *pkt->pkt.comment + n + 2 + n1 );
+    pkt->pkt.comment = xmalloc ( sizeof *pkt->pkt.comment + n + 2 + n1 );
     pkt->pkt.comment->len = n+1+2+n1;
     pp = pkt->pkt.comment->data;
     memcpy(pp, s, n+1);
-    pp[n+1] = nb1 >> 8;
-    pp[n+2] = nb1 ;
-    memcpy(pp+n+3, p, n1 );
-    m_free(buf);
+    memcpy(pp+n+1, buf, n1 );
+    xfree (buf);
     return new_kbnode( pkt );
 }
 
index 8d9327c..7dce179 100644 (file)
@@ -1,5 +1,6 @@
 /* compress.c - compress filter
- * Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002,
+ *               2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -30,6 +31,7 @@
 # include "zlib-riscos.h"
 #endif
 
+#include "gpg.h"
 #include "util.h"
 #include "memory.h"
 #include "packet.h"
@@ -73,12 +75,13 @@ init_compress( compress_filter_context_t *zfx, z_stream *zs )
     }
 
     zfx->outbufsize = 8192;
-    zfx->outbuf = m_alloc( zfx->outbufsize );
+    zfx->outbuf = xmalloc ( zfx->outbufsize );
 }
 
 static int
-do_compress( compress_filter_context_t *zfx, z_stream *zs, int flush, IOBUF a )
+do_compress( compress_filter_context_t *zfx, z_stream *zs, int flush, iobuf_t a )
 {
+    gpg_error_t rc;
     int zrc;
     unsigned n;
 
@@ -108,10 +111,12 @@ do_compress( compress_filter_context_t *zfx, z_stream *zs, int flush, IOBUF a )
                (unsigned)zs->avail_in, (unsigned)zs->avail_out,
                                               (unsigned)n, zrc );
 
-       if( iobuf_write( a, zfx->outbuf, n ) ) {
+       rc = iobuf_write (a, zfx->outbuf, n);
+        if (rc)
+          {
            log_debug("deflate: iobuf_write failed\n");
-           return G10ERR_WRITE_FILE;
-       }
+           return rc;
+          }
     } while( zs->avail_in || (flush == Z_FINISH && zrc != Z_STREAM_END) );
     return 0;
 }
@@ -140,13 +145,13 @@ init_uncompress( compress_filter_context_t *zfx, z_stream *zs )
     }
 
     zfx->inbufsize = 2048;
-    zfx->inbuf = m_alloc( zfx->inbufsize );
+    zfx->inbuf = xmalloc ( zfx->inbufsize );
     zs->avail_in = 0;
 }
 
 static int
 do_uncompress( compress_filter_context_t *zfx, z_stream *zs,
-              IOBUF a, size_t *ret_len )
+              iobuf_t a, size_t *ret_len )
 {
     int zrc;
     int rc=0;
@@ -210,7 +215,7 @@ do_uncompress( compress_filter_context_t *zfx, z_stream *zs,
 
 int
 compress_filter( void *opaque, int control,
-                IOBUF a, byte *buf, size_t *ret_len)
+                iobuf_t a, byte *buf, size_t *ret_len)
 {
     size_t size = *ret_len;
     compress_filter_context_t *zfx = opaque;
@@ -219,7 +224,7 @@ compress_filter( void *opaque, int control,
 
     if( control == IOBUFCTRL_UNDERFLOW ) {
        if( !zfx->status ) {
-           zs = zfx->opaque = m_alloc_clear( sizeof *zs );
+           zs = zfx->opaque = xcalloc (1, sizeof *zs );
            init_uncompress( zfx, zs );
            zfx->status = 1;
        }
@@ -250,7 +255,7 @@ compress_filter( void *opaque, int control,
            pkt.pkt.compressed = &cd;
            if( build_packet( a, &pkt ))
                log_bug("build_packet(PKT_COMPRESSED) failed\n");
-           zs = zfx->opaque = m_alloc_clear( sizeof *zs );
+           zs = zfx->opaque = xcalloc (1, sizeof *zs );
            init_compress( zfx, zs );
            zfx->status = 2;
        }
@@ -266,9 +271,9 @@ compress_filter( void *opaque, int control,
     else if( control == IOBUFCTRL_FREE ) {
        if( zfx->status == 1 ) {
            inflateEnd(zs);
-           m_free(zs);
+           xfree (zs);
            zfx->opaque = NULL;
-           m_free(zfx->outbuf); zfx->outbuf = NULL;
+           xfree (zfx->outbuf); zfx->outbuf = NULL;
        }
        else if( zfx->status == 2 ) {
 #ifndef __riscos__
@@ -279,9 +284,9 @@ compress_filter( void *opaque, int control,
            zs->avail_in = 0;
            do_compress( zfx, zs, Z_FINISH, a );
            deflateEnd(zs);
-           m_free(zs);
+           xfree (zs);
            zfx->opaque = NULL;
-           m_free(zfx->outbuf); zfx->outbuf = NULL;
+           xfree (zfx->outbuf); zfx->outbuf = NULL;
        }
         if (zfx->release)
           zfx->release (zfx);
@@ -295,7 +300,7 @@ compress_filter( void *opaque, int control,
 static void
 release_context (compress_filter_context_t *ctx)
 {
-  m_free (ctx);
+  xfree (ctx);
 }
 
 /****************
@@ -303,14 +308,14 @@ release_context (compress_filter_context_t *ctx)
  */
 int
 handle_compressed( void *procctx, PKT_compressed *cd,
-                  int (*callback)(IOBUF, void *), void *passthru )
+                  int (*callback)(iobuf_t, void *), void *passthru )
 {
     compress_filter_context_t *cfx;
     int rc;
 
     if( cd->algorithm < 1 || cd->algorithm > 2 )
-       return G10ERR_COMPR_ALGO;
-    cfx = m_alloc_clear (sizeof *cfx);
+       return GPG_ERR_COMPR_ALGO;
+    cfx = xcalloc (1,sizeof *cfx);
     cfx->algo = cd->algorithm;
     cfx->release = release_context;
     iobuf_push_filter( cd->buf, compress_filter, cfx );
index 4ec8fa0..4f9fa2d 100644 (file)
@@ -1,5 +1,5 @@
 /* dearmor.c - Armor utility
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -25,6 +25,7 @@
 #include <errno.h>
 #include <assert.h>
 
+#include "gpg.h"
 #include "errors.h"
 #include "iobuf.h"
 #include "memory.h"
@@ -42,7 +43,7 @@ int
 dearmor_file( const char *fname )
 {
     armor_filter_context_t afx;
-    IOBUF inp = NULL, out = NULL;
+    iobuf_t inp = NULL, out = NULL;
     int rc = 0;
     int c;
 
@@ -50,9 +51,9 @@ dearmor_file( const char *fname )
 
     /* prepare iobufs */
     if( !(inp = iobuf_open(fname)) ) {
+        rc = gpg_error_from_errno (errno);
        log_error("can't open %s: %s\n", fname? fname: "[stdin]",
                                        strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
        goto leave;
     }
 
@@ -84,7 +85,7 @@ int
 enarmor_file( const char *fname )
 {
     armor_filter_context_t afx;
-    IOBUF inp = NULL, out = NULL;
+    iobuf_t inp = NULL, out = NULL;
     int rc = 0;
     int c;
 
@@ -92,9 +93,9 @@ enarmor_file( const char *fname )
 
     /* prepare iobufs */
     if( !(inp = iobuf_open(fname)) ) {
+        rc = gpg_error_from_errno (errno);
        log_error("can't open %s: %s\n", fname? fname: "[stdin]",
                                        strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
        goto leave;
     }
 
index df778d1..98a270c 100644 (file)
@@ -49,7 +49,7 @@
 int
 decrypt_message( const char *filename )
 {
-    IOBUF fp;
+    iobuf_t fp;
     armor_filter_context_t afx;
     progress_filter_context_t pfx;
     int rc;
@@ -58,8 +58,9 @@ decrypt_message( const char *filename )
     /* open the message file */
     fp = iobuf_open(filename);
     if( !fp ) {
+        rc = gpg_error_from_errno (errno);
        log_error(_("can't open `%s'\n"), print_fname_stdin(filename));
-       return G10ERR_OPEN_FILE;
+       return rc;
     }
 
     handle_progress (&pfx, fp, filename);
@@ -85,7 +86,7 @@ decrypt_message( const char *filename )
 void
 decrypt_messages(int nfiles, char **files)
 {
-  IOBUF fp;
+  iobuf_t fp;
   armor_filter_context_t afx;  
   progress_filter_context_t pfx;
   char *p, *output = NULL;
@@ -125,15 +126,15 @@ decrypt_messages(int nfiles, char **files)
       iobuf_close(fp);
       if (rc)
         log_error("%s: decryption failed: %s\n", print_fname_stdin(*files),
-                  g10_errstr(rc));
+                  gpg_strerror (rc));
       p = get_last_passphrase();
       set_next_passphrase(p);
-      m_free (p);
+      xfree (p);
 
     next_file:
       /* Note that we emit file_done even after an error. */
       write_status( STATUS_FILE_DONE );
-      m_free(output);
+      xfree (output);
       files++;
     }
   set_next_passphrase(NULL);  
index 35c903c..34a2e1b 100644 (file)
@@ -68,9 +68,9 @@ do_delete_key( const char *username, int secret, int *r_sec_avail )
     exactmatch = (desc.mode == KEYDB_SEARCH_MODE_FPR
                   || desc.mode == KEYDB_SEARCH_MODE_FPR16
                   || desc.mode == KEYDB_SEARCH_MODE_FPR20);
-    rc = desc.mode? keydb_search (hd, &desc, 1):G10ERR_INV_USER_ID;
+    rc = desc.mode? keydb_search (hd, &desc, 1):GPG_ERR_INV_USER_ID;
     if (rc) {
-       log_error (_("key `%s' not found: %s\n"), username, g10_errstr (rc));
+       log_error (_("key `%s' not found: %s\n"), username, gpg_strerror (rc));
        write_status_text( STATUS_DELETE_PROBLEM, "1" );
        goto leave;
     }
@@ -78,7 +78,7 @@ do_delete_key( const char *username, int secret, int *r_sec_avail )
     /* read the keyblock */
     rc = keydb_get_keyblock (hd, &keyblock );
     if (rc) {
-       log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
+       log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
        goto leave;
     }
 
@@ -86,7 +86,7 @@ do_delete_key( const char *username, int secret, int *r_sec_avail )
     node = find_kbnode( keyblock, secret? PKT_SECRET_KEY:PKT_PUBLIC_KEY );
     if( !node ) {
        log_error("Oops; key not found anymore!\n");
-       rc = G10ERR_GENERAL;
+       rc = GPG_ERR_GENERAL;
        goto leave;
     }
 
@@ -103,8 +103,8 @@ do_delete_key( const char *username, int secret, int *r_sec_avail )
             rc = -1;
             goto leave;
        }
-       else if( rc != G10ERR_NO_SECKEY ) {
-           log_error("%s: get secret key: %s\n", username, g10_errstr(rc) );
+       else if( rc != GPG_ERR_NO_SECKEY ) {
+           log_error("%s: get secret key: %s\n", username, gpg_strerror (rc) );
        }
        else
            rc = 0;
@@ -153,7 +153,7 @@ do_delete_key( const char *username, int secret, int *r_sec_avail )
     if( okay ) {
        rc = keydb_delete_keyblock (hd);
        if (rc) {
-           log_error (_("deleting keyblock failed: %s\n"), g10_errstr(rc) );
+           log_error (_("deleting keyblock failed: %s\n"), gpg_strerror (rc) );
            goto leave;
        }
 
@@ -200,7 +200,7 @@ delete_keys( STRLIST names, int secret, int allow_both )
        }
 
        if(rc) {
-        log_error("%s: delete key failed: %s\n", names->d, g10_errstr(rc) );
+        log_error("%s: delete key failed: %s\n", names->d, gpg_strerror (rc) );
         return rc;
        }
     }
index 66ce57c..ba40c0a 100644 (file)
@@ -26,6 +26,7 @@
 #include <errno.h>
 #include <assert.h>
 
+#include "gpg.h"
 #include "options.h"
 #include "packet.h"
 #include "errors.h"
 #include "trustdb.h"
 #include "i18n.h"
 #include "status.h"
+#include "pkglue.h"
+
 
 static int encode_simple( const char *filename, int mode, int compat );
-static int write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out );
+static int write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, iobuf_t out );
 
 
 
@@ -77,13 +80,14 @@ encode_store( const char *filename )
 static void
 encode_sesskey( DEK *dek, DEK **ret_dek, byte *enckey )
 {
+#warning This functions needs a review.
     CIPHER_HANDLE hd;
     DEK *c;
     byte buf[33];
 
     assert ( dek->keylen < 32 );
     
-    c = m_alloc_clear( sizeof *c );
+    c = xcalloc (1, sizeof *c );
     c->keylen = dek->keylen;
     c->algo = dek->algo;
     make_session_key( c );
@@ -92,11 +96,12 @@ encode_sesskey( DEK *dek, DEK **ret_dek, byte *enckey )
     buf[0] = c->algo;
     memcpy( buf + 1, c->key, c->keylen );
     
-    hd = cipher_open( dek->algo, CIPHER_MODE_CFB, 1 );
-    cipher_setkey( hd, dek->key, dek->keylen );
-    cipher_setiv( hd, NULL, 0 );
-    cipher_encrypt( hd, buf, buf, c->keylen + 1 );
-    cipher_close( hd );
+
+    gcry_cipher_open (&hd, dek->algo, GCRY_CIPHER_MODE_CFB, 1 );
+    gcry_cipher_setkey( hd, dek->key, dek->keylen );
+    gcry_cipher_setiv( hd, NULL, 0 );
+    gcry_cipher_encrypt( hd, buf, c->keylen + 1, NULL, 0 );
+    gcry_cipher_close( hd );
 
     memcpy( enckey, buf, c->keylen + 1 );
     wipememory( buf, sizeof buf ); /* burn key */
@@ -143,7 +148,7 @@ use_mdc(PK_LIST pk_list,int algo)
 
   /* Last try.  Use MDC for the modern ciphers. */
 
-  if(cipher_get_blocksize(algo)!=8)
+  if( gcry_cipher_get_algo_blklen (algo) != 8)
     return 1;
 
   return 0; /* No MDC */
@@ -152,7 +157,7 @@ use_mdc(PK_LIST pk_list,int algo)
 static int
 encode_simple( const char *filename, int mode, int compat )
 {
-    IOBUF inp, out;
+    iobuf_t inp, out;
     PACKET pkt;
     DEK *dek = NULL;
     PKT_plaintext *pt = NULL;
@@ -176,9 +181,10 @@ encode_simple( const char *filename, int mode, int compat )
     
     /* prepare iobufs */
     if( !(inp = iobuf_open(filename)) ) {
+        rc = gpg_error_from_errno (errno);
        log_error(_("%s: can't open: %s\n"), filename? filename: "[stdin]",
                                        strerror(errno) );
-       return G10ERR_OPEN_FILE;
+       return rc;
     }
 
     handle_progress (&pfx, inp, filename);
@@ -194,18 +200,18 @@ encode_simple( const char *filename, int mode, int compat )
     
     cfx.dek = NULL;
     if( mode ) {
-       s2k = m_alloc_clear( sizeof *s2k );
+       s2k = xcalloc (1, sizeof *s2k );
        s2k->mode = RFC1991? 0:opt.s2k_mode;
        s2k->hash_algo = opt.s2k_digest_algo;
        cfx.dek = passphrase_to_dek( NULL, 0,
                                     default_cipher_algo(), s2k, 2,
                                      NULL, NULL);
        if( !cfx.dek || !cfx.dek->keylen ) {
-           rc = G10ERR_PASSPHRASE;
-           m_free(cfx.dek);
-           m_free(s2k);
+            rc = gpg_error (GPG_ERR_INV_PASSPHRASE);
+           xfree (cfx.dek);
+           xfree (s2k);
            iobuf_close(inp);
-           log_error(_("error creating passphrase: %s\n"), g10_errstr(rc) );
+           log_error(_("error creating passphrase: %s\n"), gpg_strerror (rc) );
            return rc;
        }
         if (!compat && s2k->mode != 1 && s2k->mode != 3) {
@@ -215,9 +221,9 @@ encode_simple( const char *filename, int mode, int compat )
         }
 
         if ( !compat ) {            
-            seskeylen = cipher_get_keylen( default_cipher_algo() ) / 8;
+            seskeylen = gcry_cipher_get_algo_keylen (default_cipher_algo());
             encode_sesskey( cfx.dek, &dek, enckey );
-            m_free( cfx.dek ); cfx.dek = dek;
+            xfree (cfx.dek); cfx.dek = dek;
         }
 
        cfx.dek->use_mdc=use_mdc(NULL,cfx.dek->algo);
@@ -233,8 +239,8 @@ encode_simple( const char *filename, int mode, int compat )
 
     if( rc || (rc = open_outfile( filename, opt.armor? 1:0, &out )) ) {
        iobuf_cancel(inp);
-       m_free(cfx.dek);
-       m_free(s2k);
+       xfree (cfx.dek);
+       xfree (s2k);
        return rc;
     }
 
@@ -249,7 +255,7 @@ encode_simple( const char *filename, int mode, int compat )
     }
 #endif
     if( s2k && !RFC1991 ) {
-       PKT_symkey_enc *enc = m_alloc_clear( sizeof *enc + seskeylen + 1 );
+       PKT_symkey_enc *enc = xcalloc (1, sizeof *enc + seskeylen + 1 );
        enc->version = 4;
        enc->cipher_algo = cfx.dek->algo;
        enc->s2k = *s2k;
@@ -260,23 +266,25 @@ encode_simple( const char *filename, int mode, int compat )
        pkt.pkttype = PKT_SYMKEY_ENC;
        pkt.pkt.symkey_enc = enc;
        if( (rc = build_packet( out, &pkt )) )
-           log_error("build symkey packet failed: %s\n", g10_errstr(rc) );
-       m_free(enc);
+           log_error("build symkey packet failed: %s\n", gpg_strerror (rc) );
+       xfree (enc);
     }
 
     if (!opt.no_literal) {
        /* setup the inner packet */
        if( filename || opt.set_filename ) {
-           char *s = make_basename( opt.set_filename ? opt.set_filename
-                                                     : filename,
-                                    iobuf_get_real_fname( inp ) );
-           pt = m_alloc( sizeof *pt + strlen(s) - 1 );
+           char *s = make_basename ( opt.set_filename ? opt.set_filename
+                                                     : filename
+                                      /* for riscos?
+                                         .iobuf_get_real_fname( inp ) */
+                                      );
+           pt = xmalloc ( sizeof *pt + strlen(s) - 1 );
            pt->namelen = strlen(s);
            memcpy(pt->name, s, pt->namelen );
-           m_free(s);
+           xfree (s);
        }
        else { /* no filename */
-           pt = m_alloc( sizeof *pt - 1 );
+           pt = xmalloc ( sizeof *pt - 1 );
            pt->namelen = 0;
        }
     }
@@ -342,7 +350,7 @@ encode_simple( const char *filename, int mode, int compat )
     /* do the work */
     if (!opt.no_literal) {
        if( (rc = build_packet( out, &pkt )) )
-           log_error("build_packet failed: %s\n", g10_errstr(rc) );
+           log_error("build_packet failed: %s\n", gpg_strerror (rc) );
     }
     else {
        /* user requested not to create a literal packet,
@@ -350,9 +358,8 @@ encode_simple( const char *filename, int mode, int compat )
        byte copy_buffer[4096];
        int  bytes_copied;
        while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
-           if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
-               rc = G10ERR_WRITE_FILE;
-               log_error("copying input to output failed: %s\n", g10_errstr(rc) );
+           if ( (rc=iobuf_write(out, copy_buffer, bytes_copied))) {
+               log_error("copying input to output failed: %s\n", gpg_strerror (rc) );
                break;
            }
        wipememory(copy_buffer, 4096); /* burn buffer */
@@ -370,8 +377,8 @@ encode_simple( const char *filename, int mode, int compat )
     if (pt)
        pt->buf = NULL;
     free_packet(&pkt);
-    m_free(cfx.dek);
-    m_free(s2k);
+    xfree (cfx.dek);
+    xfree (s2k);
     return rc;
 }
 
@@ -382,7 +389,7 @@ encode_simple( const char *filename, int mode, int compat )
 int
 encode_crypt( const char *filename, STRLIST remusr )
 {
-    IOBUF inp = NULL, out = NULL;
+    iobuf_t inp = NULL, out = NULL;
     PACKET pkt;
     PKT_plaintext *pt = NULL;
     int rc = 0, rc2 = 0;
@@ -419,9 +426,9 @@ encode_crypt( const char *filename, STRLIST remusr )
 
     /* prepare iobufs */
     if( !(inp = iobuf_open(filename)) ) {
+        rc = gpg_error_from_errno (errno);
        log_error(_("can't open %s: %s\n"), filename? filename: "[stdin]",
                                        strerror(errno) );
-       rc = G10ERR_OPEN_FILE;
        goto leave;
     }
     else if( opt.verbose )
@@ -447,7 +454,7 @@ encode_crypt( const char *filename, STRLIST remusr )
     }
 #endif
     /* create a session key */
-    cfx.dek = m_alloc_secure_clear (sizeof *cfx.dek);
+    cfx.dek = xcalloc_secure (1, sizeof *cfx.dek);
     if( !opt.def_cipher_algo ) { /* try to get it from the prefs */
        cfx.dek->algo = select_algo_from_prefs(pk_list,PREFTYPE_SYM,-1,NULL);
        /* The only way select_algo_from_prefs can fail here is when
@@ -473,7 +480,7 @@ encode_crypt( const char *filename, STRLIST remusr )
                                opt.def_cipher_algo,NULL)!=opt.def_cipher_algo)
        log_info(_("forcing symmetric cipher %s (%d) "
                   "violates recipient preferences\n"),
-                cipher_algo_to_string(opt.def_cipher_algo),
+                gcry_cipher_algo_name (opt.def_cipher_algo),
                 opt.def_cipher_algo);
 
       cfx.dek->algo = opt.def_cipher_algo;
@@ -501,7 +508,7 @@ encode_crypt( const char *filename, STRLIST remusr )
 
     make_session_key( cfx.dek );
     if( DBG_CIPHER )
-       log_hexdump("DEK is: ", cfx.dek->key, cfx.dek->keylen );
+       log_printhex ("DEK is: ", cfx.dek->key, cfx.dek->keylen );
 
     rc = write_pubkey_enc_from_list( pk_list, cfx.dek, out );
     if( rc  )
@@ -511,15 +518,15 @@ encode_crypt( const char *filename, STRLIST remusr )
        /* setup the inner packet */
        if( filename || opt.set_filename ) {
            char *s = make_basename( opt.set_filename ? opt.set_filename
-                                                     : filename,
-                                    iobuf_get_real_fname( inp ) );
-           pt = m_alloc( sizeof *pt + strlen(s) - 1 );
+                                                     : filename
+                                    /* ,iobuf_get_real_fname( inp )*/ );
+           pt = xmalloc ( sizeof *pt + strlen(s) - 1 );
            pt->namelen = strlen(s);
            memcpy(pt->name, s, pt->namelen );
-           m_free(s);
+           xfree (s);
        }
        else { /* no filename */
-           pt = m_alloc( sizeof *pt - 1 );
+           pt = xmalloc ( sizeof *pt - 1 );
            pt->namelen = 0;
        }
     }
@@ -590,7 +597,7 @@ encode_crypt( const char *filename, STRLIST remusr )
     /* do the work */
     if (!opt.no_literal) {
        if( (rc = build_packet( out, &pkt )) )
-           log_error("build_packet failed: %s\n", g10_errstr(rc) );
+           log_error("build_packet failed: %s\n", gpg_strerror (rc) );
     }
     else {
        /* user requested not to create a literal packet, so we copy
@@ -598,10 +605,9 @@ encode_crypt( const char *filename, STRLIST remusr )
        byte copy_buffer[4096];
        int  bytes_copied;
        while ((bytes_copied = iobuf_read(inp, copy_buffer, 4096)) != -1)
-           if (iobuf_write(out, copy_buffer, bytes_copied) == -1) {
-               rc = G10ERR_WRITE_FILE;
+           if ((rc=iobuf_write(out, copy_buffer, bytes_copied))) {
                log_error("copying input to output failed: %s\n",
-                          g10_errstr(rc) );
+                          gpg_strerror (rc) );
                break;
            }
        wipememory(copy_buffer, 4096); /* burn buffer */
@@ -619,7 +625,7 @@ encode_crypt( const char *filename, STRLIST remusr )
     if( pt )
        pt->buf = NULL;
     free_packet(&pkt);
-    m_free(cfx.dek);
+    xfree (cfx.dek);
     release_pk_list( pk_list );
     return rc;
 }
@@ -632,7 +638,7 @@ encode_crypt( const char *filename, STRLIST remusr )
  */
 int
 encrypt_filter( void *opaque, int control,
-              IOBUF a, byte *buf, size_t *ret_len)
+              iobuf_t a, byte *buf, size_t *ret_len)
 {
     size_t size = *ret_len;
     encrypt_filter_context_t *efx = opaque;
@@ -643,7 +649,7 @@ encrypt_filter( void *opaque, int control,
     }
     else if( control == IOBUFCTRL_FLUSH ) { /* encrypt */
        if( !efx->header_okay ) {
-           efx->cfx.dek = m_alloc_secure_clear( sizeof *efx->cfx.dek );
+           efx->cfx.dek = xcalloc_secure (1, sizeof *efx->cfx.dek );
 
            if( !opt.def_cipher_algo  ) { /* try to get it from the prefs */
                efx->cfx.dek->algo =
@@ -661,7 +667,7 @@ encrypt_filter( void *opaque, int control,
                                        NULL)!=opt.def_cipher_algo)
                log_info(_("forcing symmetric cipher %s (%d) "
                           "violates recipient preferences\n"),
-                        cipher_algo_to_string(opt.def_cipher_algo),
+                        gcry_cipher_algo_name (opt.def_cipher_algo),
                         opt.def_cipher_algo);
 
              efx->cfx.dek->algo = opt.def_cipher_algo;
@@ -671,8 +677,8 @@ encrypt_filter( void *opaque, int control,
 
            make_session_key( efx->cfx.dek );
            if( DBG_CIPHER )
-               log_hexdump("DEK is: ",
-                            efx->cfx.dek->key, efx->cfx.dek->keylen );
+               log_printhex ("DEK is: ",
+                              efx->cfx.dek->key, efx->cfx.dek->keylen );
 
            rc = write_pubkey_enc_from_list( efx->pk_list, efx->cfx.dek, a );
            if( rc )
@@ -698,7 +704,7 @@ encrypt_filter( void *opaque, int control,
  * Write pubkey-enc packets from the list of PKs to OUT.
  */
 static int
-write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out )
+write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, iobuf_t out )
 {
     PACKET pkt;
     PKT_public_key *pk;
@@ -706,12 +712,12 @@ write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out )
     int rc;
 
     for( ; pk_list; pk_list = pk_list->next ) {
-       MPI frame;
+       gcry_mpi_t frame;
 
        pk = pk_list->pk;
 
        print_pubkey_algo_note( pk->pubkey_algo );
-       enc = m_alloc_clear( sizeof *enc );
+       enc = xcalloc (1, sizeof *enc );
        enc->pubkey_algo = pk->pubkey_algo;
        keyid_from_pk( pk, enc->keyid );
        enc->throw_keyid = (opt.throw_keyid || (pk_list->flags&1));
@@ -738,17 +744,17 @@ write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out )
         */
        frame = encode_session_key( dek, pubkey_nbits( pk->pubkey_algo,
                                                          pk->pkey ) );
-       rc = pubkey_encrypt( pk->pubkey_algo, enc->data, frame, pk->pkey );
-       mpi_free( frame );
+       rc = pk_encrypt( pk->pubkey_algo, enc->data, frame, pk->pkey );
+       gcry_mpi_release ( frame );
        if( rc )
-           log_error("pubkey_encrypt failed: %s\n", g10_errstr(rc) );
+           log_error("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
        else {
            if( opt.verbose ) {
                char *ustr = get_user_id_string_printable (enc->keyid);
                log_info(_("%s/%s encrypted for: \"%s\"\n"),
-                   pubkey_algo_to_string(enc->pubkey_algo),
-                   cipher_algo_to_string(dek->algo), ustr );
-               m_free(ustr);
+                   gcry_pk_algo_name (enc->pubkey_algo),
+                   gcry_cipher_algo_name (dek->algo), ustr );
+               xfree (ustr);
            }
            /* and write it */
            init_packet(&pkt);
@@ -756,7 +762,7 @@ write_pubkey_enc_from_list( PK_LIST pk_list, DEK *dek, IOBUF out )
            pkt.pkt.pubkey_enc = enc;
            rc = build_packet( out, &pkt );
            if( rc )
-              log_error("build_packet(pubkey_enc) failed: %s\n", g10_errstr(rc));
+              log_error("build_packet(pubkey_enc) failed: %s\n", gpg_strerror (rc));
        }
        free_pubkey_enc(enc);
        if( rc )
@@ -792,7 +798,7 @@ encode_crypt_files(int nfiles, char **files, STRLIST remusr)
           print_file_status(STATUS_FILE_START, line, 2);
           if ( (rc = encode_crypt(line, remusr)) )
             log_error("%s: encryption failed: %s\n",
-                      print_fname_stdin(line), g10_errstr(rc) );
+                      print_fname_stdin(line), gpg_strerror (rc) );
           write_status( STATUS_FILE_DONE );
         }
     }
@@ -803,7 +809,7 @@ encode_crypt_files(int nfiles, char **files, STRLIST remusr)
           print_file_status(STATUS_FILE_START, *files, 2);
           if ( (rc = encode_crypt(*files, remusr)) )
             log_error("%s: encryption failed: %s\n",
-                      print_fname_stdin(*files), g10_errstr(rc) );
+                      print_fname_stdin(*files), gpg_strerror (rc) );
           write_status( STATUS_FILE_DONE );
           files++;
         }
index c8a8c85..0744084 100644 (file)
@@ -1,5 +1,5 @@
 /* encr-data.c -  process an encrypted data packet
- * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+ * Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "memory.h"
 #include "packet.h"
@@ -32,9 +34,9 @@
 #include "i18n.h"
 
 
-static int mdc_decode_filter( void *opaque, int control, IOBUF a,
+static int mdc_decode_filter( void *opaque, int control, iobuf_t a,
                                              byte *buf, size_t *ret_len);
-static int decode_filter( void *opaque, int control, IOBUF a,
+static int decode_filter( void *opaque, int control, iobuf_t a,
                                        byte *buf, size_t *ret_len);
 
 typedef struct {
@@ -61,16 +63,16 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
 
     memset( &dfx, 0, sizeof dfx );
     if( opt.verbose && !dek->algo_info_printed ) {
-       const char *s = cipher_algo_to_string( dek->algo );
-       if( s )
+       const char *s = gcry_cipher_algo_name (dek->algo);
+       if (s && *s)
            log_info(_("%s encrypted data\n"), s );
        else
            log_info(_("encrypted with unknown algorithm %d\n"), dek->algo );
         dek->algo_info_printed = 1;
     }
-    if( (rc=check_cipher_algo(dek->algo)) )
+    if( (rc=openpgp_cipher_test_algo(dek->algo)) )
        goto leave;
-    blocksize = cipher_get_blocksize(dek->algo);
+    blocksize = gcry_cipher_get_algo_blklen (dek->algo);
     if( !blocksize || blocksize > 16 )
        log_fatal("unsupported blocksize %u\n", blocksize );
     nprefix = blocksize;
@@ -78,20 +80,29 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
        BUG();
 
     if( ed->mdc_method ) {
-       dfx.mdc_hash = md_open( ed->mdc_method, 0 );
+       gcry_md_open (&dfx.mdc_hash, ed->mdc_method, 0 );
        if ( DBG_HASHING )
-           md_start_debug(dfx.mdc_hash, "checkmdc");
+           gcry_md_start_debug (dfx.mdc_hash, "checkmdc");
     }
-    dfx.cipher_hd = cipher_open( dek->algo,
-                                ed->mdc_method? CIPHER_MODE_CFB
-                                              : CIPHER_MODE_AUTO_CFB, 1 );
-/* log_hexdump( "thekey", dek->key, dek->keylen );*/
-    rc = cipher_setkey( dfx.cipher_hd, dek->key, dek->keylen );
-    if( rc == G10ERR_WEAK_KEY )
+    rc = gcry_cipher_open (&dfx.cipher_hd, dek->algo,
+                           GCRY_CIPHER_MODE_CFB,
+                           GCRY_CIPHER_SECURE
+                           | ((ed->mdc_method || dek->algo >= 100)?
+                              0 : GCRY_CIPHER_ENABLE_SYNC) );
+     if (rc)
+       {
+         /* we should never get an error here cause we already
+          * checked, that the algorithm is available. What about a
+          * flag to let the function die in this case? */
+       BUG();
+       }
+    /* log_hexdump( "thekey", dek->key, dek->keylen );*/
+    rc = gcry_cipher_setkey (dfx.cipher_hd, dek->key, dek->keylen);
+    if( gpg_err_code (rc) == GPG_ERR_WEAK_KEY )
        log_info(_("WARNING: message was encrypted with "
                    "a weak key in the symmetric cipher.\n"));
     else if( rc ) {
-       log_error("key setup failed: %s\n", g10_errstr(rc) );
+       log_error("key setup failed: %s\n", gpg_strerror (rc) );
        goto leave;
     }
     if (!ed->buf) {
@@ -99,9 +110,9 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
         goto leave;
     }
 
-    cipher_setiv( dfx.cipher_hd, NULL, 0 );
+    gcry_cipher_setiv (dfx.cipher_hd, NULL, 0);
 
-    if( ed->len ) {
+    if (ed->len) {
        for(i=0; i < (nprefix+2) && ed->len; i++, ed->len-- ) {
            if( (c=iobuf_get(ed->buf)) == -1 )
                break;
@@ -116,17 +127,17 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
            else
                temp[i] = c;
     }
-    cipher_decrypt( dfx.cipher_hd, temp, temp, nprefix+2);
-    cipher_sync( dfx.cipher_hd );
+    gcry_cipher_decrypt( dfx.cipher_hd, temp, nprefix+2, NULL, 0);
+    gcry_cipher_sync( dfx.cipher_hd );
     p = temp;
 /* log_hexdump( "prefix", temp, nprefix+2 ); */
     if( p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1] ) {
-       rc = G10ERR_BAD_KEY;
+       rc = GPG_ERR_BAD_KEY;
        goto leave;
     }
 
     if( dfx.mdc_hash )
-       md_write( dfx.mdc_hash, temp, nprefix+2 );
+       gcry_md_write( dfx.mdc_hash, temp, nprefix+2 );
 
     if( ed->mdc_method )
        iobuf_push_filter( ed->buf, mdc_decode_filter, &dfx );
@@ -136,23 +147,23 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
     proc_packets( procctx, ed->buf );
     ed->buf = NULL;
     if( ed->mdc_method && dfx.eof_seen == 2 )
-       rc = G10ERR_INVALID_PACKET;
+       rc = gpg_error (GPG_ERR_INV_PACKET);
     else if( ed->mdc_method ) { /* check the mdc */
-       int datalen = md_digest_length( ed->mdc_method );
+       int datalen = gcry_md_get_algo_dlen (ed->mdc_method);
 
-       cipher_decrypt( dfx.cipher_hd, dfx.defer, dfx.defer, 20);
-       md_final( dfx.mdc_hash );
+       gcry_cipher_decrypt (dfx.cipher_hd, dfx.defer, 20, NULL, 0);
+       gcry_md_final ( dfx.mdc_hash );
        if( datalen != 20
-           || memcmp(md_read( dfx.mdc_hash, 0 ), dfx.defer, datalen) )
-           rc = G10ERR_BAD_SIGN;
-       /*log_hexdump("MDC calculated:", md_read( dfx.mdc_hash, 0), datalen);*/
+           || memcmp(gcry_md_read ( dfx.mdc_hash, 0 ), dfx.defer, datalen) )
+           rc = gpg_error (GPG_ERR_BAD_SIGNATURE);
+       /*log_hexdump("MDC calculated:", gcry_md_read ( dfx.mdc_hash, 0), datalen);*/
        /*log_hexdump("MDC message   :", dfx.defer, 20);*/
     }
     
 
   leave:
-    cipher_close(dfx.cipher_hd);
-    md_close( dfx.mdc_hash );
+    gcry_cipher_close(dfx.cipher_hd);
+    gcry_md_close ( dfx.mdc_hash );
     return rc;
 }
 
@@ -160,7 +171,7 @@ decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
 
 /* I think we should merge this with cipher_filter */
 static int
-mdc_decode_filter( void *opaque, int control, IOBUF a,
+mdc_decode_filter( void *opaque, int control, iobuf_t a,
                                              byte *buf, size_t *ret_len)
 {
     decode_filter_ctx_t *dfx = opaque;
@@ -218,8 +229,8 @@ mdc_decode_filter( void *opaque, int control, IOBUF a,
        }
 
        if( n ) {
-           cipher_decrypt( dfx->cipher_hd, buf, buf, n);
-           md_write( dfx->mdc_hash, buf, n );
+           gcry_cipher_decrypt( dfx->cipher_hd, buf, n, NULL, 0);
+           gcry_md_write( dfx->mdc_hash, buf, n );
        }
        else {
            assert( dfx->eof_seen );
@@ -234,7 +245,7 @@ mdc_decode_filter( void *opaque, int control, IOBUF a,
 }
 
 static int
-decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
+decode_filter( void *opaque, int control, iobuf_t a, byte *buf, size_t *ret_len)
 {
     decode_filter_ctx_t *fc = opaque;
     size_t n, size = *ret_len;
@@ -245,7 +256,7 @@ decode_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len)
        n = iobuf_read( a, buf, size );
        if( n == -1 ) n = 0;
        if( n )
-           cipher_decrypt( fc->cipher_hd, buf, buf, n);
+           gcry_cipher_decrypt( fc->cipher_hd, buf, n, NULL, 0);
        else
            rc = -1; /* eof */
        *ret_len = n;
index 0278438..f3b58aa 100644 (file)
@@ -46,12 +46,12 @@ int exec_write(struct exec_info **info,const char *program,
               const char *args_in,const char *name,int writeonly,int binary)
 {
   log_error(_("no remote program execution supported\n"));
-  return G10ERR_GENERAL;
+  return GPG_ERR_GENERAL;
 }
 
-int exec_read(struct exec_info *info) { return G10ERR_GENERAL; }
-int exec_finish(struct exec_info *info) { return G10ERR_GENERAL; }
-int set_exec_path(const char *path,int method) { return G10ERR_GENERAL; }
+int exec_read(struct exec_info *info) { return GPG_ERR_GENERAL; }
+int exec_finish(struct exec_info *info) { return GPG_ERR_GENERAL; }
+int set_exec_path(const char *path,int method) { return GPG_ERR_GENERAL; }
 
 #else /* ! NO_EXEC */
 
@@ -71,7 +71,7 @@ static int win_system(const char *command)
 
   /* We must use a copy of the command as CreateProcess modifies this
      argument. */
-  string=m_strdup(command);
+  string=xstrdup (command);
 
   memset(&pi,0,sizeof(pi));
   memset(&si,0,sizeof(si));
@@ -85,7 +85,7 @@ static int win_system(const char *command)
 
   CloseHandle(pi.hProcess);
   CloseHandle(pi.hThread);
-  m_free(string);
+  xfree (string);
 
   return 0;
 }
@@ -101,7 +101,7 @@ int set_exec_path(const char *path,int method)
   if(method==1 && (curpath=getenv("PATH")))
     curlen=strlen(curpath)+1;
 
-  p=m_alloc(5+curlen+strlen(path)+1);
+  p=xmalloc (5+curlen+strlen(path)+1);
   strcpy(p,"PATH=");
 
   if(curpath)
@@ -120,7 +120,7 @@ int set_exec_path(const char *path,int method)
      set_exec_path multiple times. */
 
   if(putenv(p)!=0)
-    return G10ERR_GENERAL;
+    return GPG_ERR_GENERAL;
   else
     return 0;
 }
@@ -140,7 +140,7 @@ static int make_tempdir(struct exec_info *info)
   if(tmp==NULL)
     {
 #if defined (__MINGW32__)
-      tmp=m_alloc(256);
+      tmp=xmalloc (256);
       if(GetTempPath(256,tmp)==0)
        strcpy(tmp,"c:\\windows\\temp");
       else
@@ -172,12 +172,12 @@ static int make_tempdir(struct exec_info *info)
 #endif
     }
 
-  info->tempdir=m_alloc(strlen(tmp)+strlen(DIRSEP_S)+10+1);
+  info->tempdir=xmalloc (strlen(tmp)+strlen(DIRSEP_S)+10+1);
 
   sprintf(info->tempdir,"%s" DIRSEP_S "gpg-XXXXXX",tmp);
 
 #if defined (__MINGW32__)
-  m_free(tmp);
+  xfree (tmp);
 #endif
 
   if(mkdtemp(info->tempdir)==NULL)
@@ -187,19 +187,19 @@ static int make_tempdir(struct exec_info *info)
     {
       info->madedir=1;
 
-      info->tempfile_in=m_alloc(strlen(info->tempdir)+
+      info->tempfile_in=xmalloc (strlen(info->tempdir)+
                                strlen(DIRSEP_S)+strlen(namein)+1);
       sprintf(info->tempfile_in,"%s" DIRSEP_S "%s",info->tempdir,namein);
 
       if(!info->writeonly)
        {
-         info->tempfile_out=m_alloc(strlen(info->tempdir)+
+         info->tempfile_out=xmalloc (strlen(info->tempdir)+
                                     strlen(DIRSEP_S)+strlen(nameout)+1);
          sprintf(info->tempfile_out,"%s" DIRSEP_S "%s",info->tempdir,nameout);
        }
     }
 
-  return info->madedir?0:G10ERR_GENERAL;
+  return info->madedir?0:GPG_ERR_GENERAL;
 }
 
 /* Expands %i and %o in the args to the full temp files within the
@@ -216,7 +216,7 @@ static int expand_args(struct exec_info *info,const char *args_in)
     log_debug("expanding string \"%s\"\n",args_in);
 
   size=100;
-  info->command=m_alloc(size);
+  info->command=xmalloc (size);
   len=0;
   info->command[0]='\0';
 
@@ -273,7 +273,7 @@ static int expand_args(struct exec_info *info,const char *args_in)
                    applen=100;
 
                  size+=applen;
-                 info->command=m_realloc(info->command,size);
+                 info->command=xrealloc(info->command,size);
                }
 
              strcat(info->command,append);
@@ -285,7 +285,7 @@ static int expand_args(struct exec_info *info,const char *args_in)
          if(len==size-1) /* leave room for the \0 */
            {
              size+=100;
-             info->command=m_realloc(info->command,size);
+             info->command=xrealloc(info->command,size);
            }
 
          info->command[len++]=*ch;
@@ -303,10 +303,10 @@ static int expand_args(struct exec_info *info,const char *args_in)
 
  fail:
 
-  m_free(info->command);
+  xfree (info->command);
   info->command=NULL;
 
-  return G10ERR_GENERAL;
+  return GPG_ERR_GENERAL;
 }
 
 /* Either handles the tempfile creation, or the fork/exec.  If it
@@ -318,7 +318,7 @@ static int expand_args(struct exec_info *info,const char *args_in)
 int exec_write(struct exec_info **info,const char *program,
               const char *args_in,const char *name,int writeonly,int binary)
 {
-  int ret=G10ERR_GENERAL;
+  int ret=GPG_ERR_GENERAL;
 
   if(opt.exec_disable && !opt.no_perm_warn)
     {
@@ -338,10 +338,10 @@ int exec_write(struct exec_info **info,const char *program,
   if(program==NULL && args_in==NULL)
     BUG();
 
-  *info=m_alloc_clear(sizeof(struct exec_info));
+  *info=xcalloc (1,sizeof(struct exec_info));
 
   if(name)
-    (*info)->name=m_strdup(name);
+    (*info)->name=xstrdup (name);
   (*info)->binary=binary;
   (*info)->writeonly=writeonly;
 
@@ -449,8 +449,8 @@ int exec_write(struct exec_info **info,const char *program,
       (*info)->tochild=fdopen(to[1],binary?"wb":"w");
       if((*info)->tochild==NULL)
        {
+          ret = gpg_error_from_errno (errno);
          close(to[1]);
-         ret=G10ERR_WRITE_FILE;
          goto fail;
        }
 
@@ -459,8 +459,8 @@ int exec_write(struct exec_info **info,const char *program,
       (*info)->fromchild=iobuf_fdopen(from[0],"r");
       if((*info)->fromchild==NULL)
        {
+          ret = gpg_error_from_errno (errno);
          close(from[0]);
-         ret=G10ERR_READ_FILE;
          goto fail;
        }
 
@@ -478,9 +478,9 @@ int exec_write(struct exec_info **info,const char *program,
   (*info)->tochild=fopen((*info)->tempfile_in,binary?"wb":"w");
   if((*info)->tochild==NULL)
     {
+      ret = gpg_error_from_errno (errno);
       log_error(_("can't create `%s': %s\n"),
                (*info)->tempfile_in,strerror(errno));
-      ret=G10ERR_WRITE_FILE;
       goto fail;
     }
 
@@ -492,7 +492,7 @@ int exec_write(struct exec_info **info,const char *program,
 
 int exec_read(struct exec_info *info)
 {
-  int ret=G10ERR_GENERAL;
+  int ret=GPG_ERR_GENERAL;
 
   fclose(info->tochild);
   info->tochild=NULL;
@@ -545,9 +545,9 @@ int exec_read(struct exec_info *info)
          info->fromchild=iobuf_open(info->tempfile_out);
          if(info->fromchild==NULL)
            {
+              ret = gpg_error_from_errno (errno);
              log_error(_("unable to read external program response: %s\n"),
                        strerror(errno));
-             ret=G10ERR_READ_FILE;
              goto fail;
            }
 
@@ -607,12 +607,12 @@ int exec_finish(struct exec_info *info)
                 info->tempdir,strerror(errno));
     }
 
-  m_free(info->command);
-  m_free(info->name);
-  m_free(info->tempdir);
-  m_free(info->tempfile_in);
-  m_free(info->tempfile_out);
-  m_free(info);
+  xfree (info->command);
+  xfree (info->name);
+  xfree (info->tempdir);
+  xfree (info->tempfile_in);
+  xfree (info->tempfile_out);
+  xfree (info);
 
   return ret;
 }
index 25369dc..eda4068 100644 (file)
@@ -1,5 +1,5 @@
 /* exec.h
- * Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+ * Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 
 #include <unistd.h>
 #include <stdio.h>
-#include "iobuf.h"
+#include "../common/iobuf.h"
 
 struct exec_info
 {
   int progreturn,binary,writeonly,madedir,use_temp_files,keep_temp_files;
   pid_t child;
   FILE *tochild;
-  IOBUF fromchild;
+  iobuf_t fromchild;
   char *command,*name,*tempdir,*tempfile_in,*tempfile_out;
 };
 
index 5783f6a..6c2c19f 100644 (file)
@@ -35,7 +35,7 @@
 #include "i18n.h"
 
 static int do_export( STRLIST users, int secret, unsigned int options );
-static int do_export_stream( IOBUF out, STRLIST users, int secret,
+static int do_export_stream( iobuf_t out, STRLIST users, int secret,
                             KBNODE *keyblock_out, unsigned int options,
                             int *any );
 
@@ -71,7 +71,7 @@ export_pubkeys( STRLIST users, unsigned int options )
  * been exported
  */
 int
-export_pubkeys_stream( IOBUF out, STRLIST users,
+export_pubkeys_stream( iobuf_t out, STRLIST users,
                       KBNODE *keyblock_out, unsigned int options )
 {
     int any, rc;
@@ -97,7 +97,7 @@ export_secsubkeys( STRLIST users )
 static int
 do_export( STRLIST users, int secret, unsigned int options )
 {
-    IOBUF out = NULL;
+    iobuf_t out = NULL;
     int any, rc;
     armor_filter_context_t afx;
     compress_filter_context_t zfx;
@@ -129,7 +129,7 @@ do_export( STRLIST users, int secret, unsigned int options )
    contains a pointer to the first keyblock found and exported.  No
    other keyblocks are exported.  The caller must free it. */
 static int
-do_export_stream( IOBUF out, STRLIST users, int secret,
+do_export_stream( iobuf_t out, STRLIST users, int secret,
                  KBNODE *keyblock_out, unsigned int options, int *any )
 {
     int rc = 0;
@@ -147,20 +147,20 @@ do_export_stream( IOBUF out, STRLIST users, int secret,
 
     if (!users) {
         ndesc = 1;
-        desc = m_alloc_clear ( ndesc * sizeof *desc);
+        desc = xcalloc (1, ndesc * sizeof *desc);
         desc[0].mode = KEYDB_SEARCH_MODE_FIRST;
     }
     else {
         for (ndesc=0, sl=users; sl; sl = sl->next, ndesc++) 
             ;
-        desc = m_alloc ( ndesc * sizeof *desc);
+        desc = xmalloc ( ndesc * sizeof *desc);
         
         for (ndesc=0, sl=users; sl; sl = sl->next) {
            if (classify_user_id (sl->d, desc+ndesc))
                 ndesc++;
             else
                 log_error (_("key `%s' not found: %s\n"),
-                           sl->d, g10_errstr (G10ERR_INV_USER_ID));
+                           sl->d, gpg_strerror (GPG_ERR_INV_USER_ID));
         }
 
         /* it would be nice to see which of the given users did
@@ -181,7 +181,7 @@ do_export_stream( IOBUF out, STRLIST users, int secret,
         /* read the keyblock */
         rc = keydb_get_keyblock (kdbhd, &keyblock );
        if( rc ) {
-            log_error (_("error reading keyblock: %s\n"), g10_errstr(rc) );
+            log_error (_("error reading keyblock: %s\n"), gpg_strerror (rc) );
            goto leave;
        }
 
@@ -370,8 +370,7 @@ do_export_stream( IOBUF out, STRLIST users, int secret,
 
            if( rc ) {
                log_error("build_packet(%d) failed: %s\n",
-                           node->pkt->pkttype, g10_errstr(rc) );
-               rc = G10ERR_WRITE_FILE;
+                           node->pkt->pkttype, gpg_strerror (rc) );
                goto leave;
            }
        }
@@ -386,7 +385,7 @@ do_export_stream( IOBUF out, STRLIST users, int secret,
        rc = 0;
 
   leave:
-    m_free(desc);
+    xfree (desc);
     keydb_release (kdbhd);
     if(rc || keyblock_out==NULL)
       release_kbnode( keyblock );
index 9f235fd..12c5ceb 100644 (file)
@@ -22,6 +22,7 @@
 
 #include "types.h"
 #include "cipher.h"
+#include "iobuf.h"
 
 typedef struct {
     MD_HANDLE md;      /* catch all */
@@ -120,35 +121,35 @@ typedef struct {
 /* encrypt_filter_context_t defined in main.h */
 
 /*-- mdfilter.c --*/
-int md_filter( void *opaque, int control, IOBUF a, byte *buf, size_t *ret_len);
+int md_filter( void *opaque, int control, iobuf_t a, byte *buf, size_t *ret_len);
 void free_md_filter_context( md_filter_context_t *mfx );
 
 /*-- armor.c --*/
-int use_armor_filter( IOBUF a );
+int use_armor_filter( iobuf_t a );
 int armor_filter( void *opaque, int control,
-                 IOBUF chain, byte *buf, size_t *ret_len);
+                 iobuf_t chain, byte *buf, size_t *ret_len);
 UnarmorPump unarmor_pump_new (void);
 void        unarmor_pump_release (UnarmorPump x);
 int         unarmor_pump (UnarmorPump x, int c);
 
 /*-- compress.c --*/
 int compress_filter( void *opaque, int control,
-                    IOBUF chain, byte *buf, size_t *ret_len);
+                    iobuf_t chain, byte *buf, size_t *ret_len);
 
 /*-- cipher.c --*/
 int cipher_filter( void *opaque, int control,
-                  IOBUF chain, byte *buf, size_t *ret_len);
+                  iobuf_t chain, byte *buf, size_t *ret_len);
 
 /*-- textfilter.c --*/
 int text_filter( void *opaque, int control,
-                IOBUF chain, byte *buf, size_t *ret_len);
-int copy_clearsig_text( IOBUF out, IOBUF inp, MD_HANDLE md,
+                iobuf_t chain, byte *buf, size_t *ret_len);
+int copy_clearsig_text( iobuf_t out, iobuf_t inp, MD_HANDLE md,
                          int escape_dash, int escape_from, int pgp2mode );
 
 /*-- progress.c --*/
 int progress_filter (void *opaque, int control,
-                    IOBUF a, byte *buf, size_t *ret_len);
+                    iobuf_t a, byte *buf, size_t *ret_len);
 void handle_progress (progress_filter_context_t *pfx,
-                     IOBUF inp, const char *name);
+                     iobuf_t inp, const char *name);
 
 #endif /*G10_FILTER_H*/
index ce3568c..7ced327 100644 (file)
@@ -36,7 +36,7 @@
 void
 free_symkey_enc( PKT_symkey_enc *enc )
 {
-    m_free(enc);
+    xfree (enc);
 }
 
 void
@@ -45,10 +45,10 @@ free_pubkey_enc( PKT_pubkey_enc *enc )
     int n, i;
     n = pubkey_get_nenc( enc->pubkey_algo );
     if( !n )
-       mpi_free(enc->data[0]);
+       mpi_release (enc->data[0]);
     for(i=0; i < n; i++ )
-       mpi_free( enc->data[i] );
-    m_free(enc);
+       mpi_release ( enc->data[i] );
+    xfree (enc);
 }
 
 void
@@ -58,14 +58,14 @@ free_seckey_enc( PKT_signature *sig )
 
   n = pubkey_get_nsig( sig->pubkey_algo );
   if( !n )
-    mpi_free(sig->data[0]);
+    mpi_release (sig->data[0]);
   for(i=0; i < n; i++ )
-    mpi_free( sig->data[i] );
+    mpi_release ( sig->data[i] );
   
-  m_free(sig->revkey);
-  m_free(sig->hashed);
-  m_free(sig->unhashed);
-  m_free(sig);
+  xfree (sig->revkey);
+  xfree (sig->hashed);
+  xfree (sig->unhashed);
+  xfree (sig);
 }
 
 
@@ -75,13 +75,13 @@ release_public_key_parts( PKT_public_key *pk )
     int n, i;
     n = pubkey_get_npkey( pk->pubkey_algo );
     if( !n )
-       mpi_free(pk->pkey[0]);
+       mpi_release (pk->pkey[0]);
     for(i=0; i < n; i++ ) {
-       mpi_free( pk->pkey[i] );
+       mpi_release ( pk->pkey[i] );
        pk->pkey[i] = NULL;
     }
     if (pk->prefs) {
-        m_free (pk->prefs);
+        xfree (pk->prefs);
         pk->prefs = NULL;
     }
     if (pk->user_id) {
@@ -89,7 +89,7 @@ release_public_key_parts( PKT_public_key *pk )
         pk->user_id = NULL;
     }
     if (pk->revkey) {
-        m_free(pk->revkey);
+        xfree (pk->revkey);
        pk->revkey=NULL;
        pk->numrevkeys=0;
     }
@@ -100,7 +100,7 @@ void
 free_public_key( PKT_public_key *pk )
 {
     release_public_key_parts( pk );
-    m_free(pk);
+    xfree (pk);
 }
 
 
@@ -111,7 +111,7 @@ cp_subpktarea (subpktarea_t *s )
 
     if( !s )
        return NULL;
-    d = m_alloc (sizeof (*d) + s->size - 1 );
+    d = xmalloc (sizeof (*d) + s->size - 1 );
     d->size = s->size;
     d->len = s->len;
     memcpy (d->data, s->data, s->len);
@@ -132,7 +132,7 @@ copy_prefs (const prefitem_t *prefs)
     
     for (n=0; prefs[n].type; n++)
         ;
-    new = m_alloc ( sizeof (*new) * (n+1));
+    new = xmalloc ( sizeof (*new) * (n+1));
     for (n=0; prefs[n].type; n++) {
         new[n].type = prefs[n].type;
         new[n].value = prefs[n].value;
@@ -150,7 +150,7 @@ copy_public_key ( PKT_public_key *d, PKT_public_key *s)
     int n, i;
 
     if( !d )
-       d = m_alloc(sizeof *d);
+       d = xmalloc (sizeof *d);
     memcpy( d, s, sizeof *d );
     d->user_id = scopy_user_id (s->user_id);
     d->prefs = copy_prefs (s->prefs);
@@ -164,7 +164,7 @@ copy_public_key ( PKT_public_key *d, PKT_public_key *s)
     if( !s->revkey && s->numrevkeys )
         BUG();
     if( s->numrevkeys ) {
-        d->revkey = m_alloc(sizeof(struct revocation_key)*s->numrevkeys);
+        d->revkey = xmalloc (sizeof(struct revocation_key)*s->numrevkeys);
         memcpy(d->revkey,s->revkey,sizeof(struct revocation_key)*s->numrevkeys);
     }
     else
@@ -200,7 +200,7 @@ copy_signature( PKT_signature *d, PKT_signature *s )
     int n, i;
 
     if( !d )
-       d = m_alloc(sizeof *d);
+       d = xmalloc (sizeof *d);
     memcpy( d, s, sizeof *d );
     n = pubkey_get_nsig( s->pubkey_algo );
     if( !n )
@@ -241,9 +241,9 @@ release_secret_key_parts( PKT_secret_key *sk )
 
     n = pubkey_get_nskey( sk->pubkey_algo );
     if( !n )
-       mpi_free(sk->skey[0]);
+       mpi_release (sk->skey[0]);
     for(i=0; i < n; i++ ) {
-       mpi_free( sk->skey[i] );
+       mpi_release ( sk->skey[i] );
        sk->skey[i] = NULL;
     }
 }
@@ -252,7 +252,7 @@ void
 free_secret_key( PKT_secret_key *sk )
 {
     release_secret_key_parts( sk );
-    m_free(sk);
+    xfree (sk);
 }
 
 PKT_secret_key *
@@ -261,7 +261,7 @@ copy_secret_key( PKT_secret_key *d, PKT_secret_key *s )
     int n, i;
 
     if( !d )
-       d = m_alloc(sizeof *d);
+       d = xmalloc (sizeof *d);
     memcpy( d, s, sizeof *d );
     n = pubkey_get_nskey( s->pubkey_algo );
     if( !n )
@@ -276,14 +276,14 @@ copy_secret_key( PKT_secret_key *d, PKT_secret_key *s )
 void
 free_comment( PKT_comment *rem )
 {
-    m_free(rem);
+    xfree (rem);
 }
 
 void
 free_attributes(PKT_user_id *uid)
 {
-  m_free(uid->attribs);
-  m_free(uid->attrib_data);
+  xfree (uid->attribs);
+  xfree (uid->attrib_data);
 
   uid->attribs=NULL;
   uid->attrib_data=NULL;
@@ -298,9 +298,9 @@ free_user_id (PKT_user_id *uid)
         return;
 
     free_attributes(uid);
-    m_free (uid->prefs);
-    m_free (uid->namehash);
-    m_free (uid);
+    xfree (uid->prefs);
+    xfree (uid->namehash);
+    xfree (uid);
 }
 
 void
@@ -312,7 +312,7 @@ free_compressed( PKT_compressed *zd )
        while( iobuf_read( zd->buf, NULL, 1<<30 ) != -1 )
            ;
     }
-    m_free(zd);
+    xfree (zd);
 }
 
 void
@@ -333,7 +333,7 @@ free_encrypted( PKT_encrypted *ed )
           }
        }
     }
-    m_free(ed);
+    xfree (ed);
 }
 
 
@@ -355,7 +355,7 @@ free_plaintext( PKT_plaintext *pt )
           }
        }
     }
-    m_free(pt);
+    xfree (pt);
 }
 
 /****************
@@ -405,7 +405,7 @@ free_packet( PACKET *pkt )
        free_plaintext( pkt->pkt.plaintext );
        break;
       default:
-       m_free( pkt->pkt.generic );
+       xfree ( pkt->pkt.generic );
        break;
     }
     pkt->pkt.generic = NULL;
index d17422c..cf6240d 100644 (file)
--- a/g10/g10.c
+++ b/g10/g10.c
@@ -34,6 +34,7 @@
 #endif
 
 #define INCLUDED_BY_MAIN_MODULE 1
+#include "gpg.h"
 #include "packet.h"
 #include "iobuf.h"
 #include "memory.h"
@@ -48,7 +49,6 @@
 #include "ttyio.h"
 #include "i18n.h"
 #include "status.h"
-#include "g10defs.h"
 #include "keyserver-internal.h"
 #include "exec.h"
 
@@ -644,8 +644,15 @@ static void add_policy_url( const char *string, int which );
 RISCOS_GLOBAL_STATICS("GnuPG Heap")
 #endif /* __riscos__ */
 
-const char *
-strusage( int level )
+static int
+pk_test_algo (int algo)
+{
+  return openpgp_pk_test_algo (algo, 0);
+}
+
+
+static const char *
+my_strusage( int level )
 {
   static char *digests, *pubkeys, *ciphers, *zips;
     const char *p;
@@ -676,20 +683,20 @@ strusage( int level )
       case 33: p = _("\nSupported algorithms:\n"); break;
       case 34:
        if( !pubkeys )
-           pubkeys = build_list(_("Pubkey: "), 0, pubkey_algo_to_string,
-                                                       check_pubkey_algo );
+           pubkeys = build_list(_("Pubkey: "), 0, gcry_pk_algo_name,
+                                 pk_test_algo );
        p = pubkeys;
        break;
       case 35:
        if( !ciphers )
-           ciphers = build_list(_("Cipher: "), 'S', cipher_algo_to_string,
-                                                       check_cipher_algo );
+           ciphers = build_list(_("Cipher: "), 'S', gcry_cipher_algo_name,
+                                 openpgp_cipher_test_algo );
        p = ciphers;
        break;
       case 36:
        if( !digests )
-           digests = build_list(_("Hash: "), 'H', digest_algo_to_string,
-                                                       check_digest_algo );
+           digests = build_list(_("Hash: "), 'H', gcry_md_algo_name,
+                                       openpgp_md_test_algo );
        p = digests;
        break;
       case 37:
@@ -699,7 +706,7 @@ strusage( int level )
        p = zips;
        break;
 
-      default: p = default_strusage(level);
+      default: p = NULL;
     }
     return p;
 }
@@ -715,12 +722,12 @@ build_list( const char *text, char letter,
     char *list, *p, *line=NULL;
 
     if( maybe_setuid )
-       secmem_init( 0 );    /* drop setuid */
+        gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* drop setuid */
 
     for(i=0; i <= 110; i++ )
        if( !chkf(i) && (s=mapf(i)) )
            n += strlen(s) + 7 + 2;
-    list = m_alloc( 21 + n ); *list = 0;
+    list = xmalloc ( 21 + n ); *list = 0;
     for(p=NULL, i=0; i <= 110; i++ ) {
        if( !chkf(i) && (s=mapf(i)) ) {
            if( !p ) {
@@ -733,7 +740,7 @@ build_list( const char *text, char letter,
            if(strlen(line)>60) {
              int spaces=strlen(text);
 
-             list=m_realloc(list,n+spaces+1);
+             list = xrealloc(list,n+spaces+1);
              /* realloc could move the block, so find the end again */
              p=list;
              while(*p)
@@ -768,7 +775,7 @@ i18n_init(void)
 #else
 #ifdef ENABLE_NLS
     setlocale( LC_ALL, "" );
-    bindtextdomain( PACKAGE, G10_LOCALEDIR );
+    bindtextdomain( PACKAGE, LOCALEDIR );
     textdomain( PACKAGE );
 #endif
 #endif
@@ -784,32 +791,58 @@ wrong_args( const char *text)
 }
 
 
+static void
+log_set_strict (int yesno)
+{
+  /* FIXME-XXX*/
+}
+
 static char *
 make_username( const char *string )
 {
     char *p;
     if( utf8_strings )
-       p = m_strdup(string);
+       p = xstrdup (string);
     else
        p = native_to_utf8( string );
     return p;
 }
 
 
+/*
+ * same as add_to_strlist() but if is_utf8 is *not* set a conversion
+ * to UTF8 is done  
+ */
+static STRLIST
+add_to_strlist2 ( STRLIST *list, const char *string, int is_utf8)
+{
+  STRLIST sl;
+  
+  if (is_utf8)
+    sl = add_to_strlist( list, string );
+  else 
+    {
+      char *p = native_to_utf8( string );
+      sl = add_to_strlist( list, p );
+      xfree( p );
+    }
+  return sl;
+}
+
+
 static void
 set_debug(void)
 {
-    if( opt.debug & DBG_MEMORY_VALUE )
-       memory_debug_mode = 1;
-    if( opt.debug & DBG_MEMSTAT_VALUE )
-       memory_stat_debug_mode = 1;
-    if( opt.debug & DBG_MPI_VALUE )
-       mpi_debug_mode = 1;
-    if( opt.debug & DBG_CIPHER_VALUE )
-       g10c_debug_mode = 1;
-    if( opt.debug & DBG_IOBUF_VALUE )
-       iobuf_debug_mode = 1;
-
+  if (opt.debug & DBG_MEMORY_VALUE )
+    memory_debug_mode = 1;
+  if (opt.debug & DBG_MEMSTAT_VALUE )
+    memory_stat_debug_mode = 1;
+  if (opt.debug & DBG_MPI_VALUE)
+    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
+  if (opt.debug & DBG_CIPHER_VALUE )
+    gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
+  if (opt.debug & DBG_IOBUF_VALUE )
+    iobuf_debug_mode = 1;
 }
 
 
@@ -876,7 +909,7 @@ static void add_group(char *string)
         add_to_strlist2 (&values,value,utf8_strings);
     }
 
-  item=m_alloc(sizeof(struct groupitem));
+  item=xmalloc (sizeof(struct groupitem));
   item->name=name;
   item->values=values;
   item->next=opt.grouplist;
@@ -920,7 +953,7 @@ check_permissions(const char *path,int item)
        tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
     }
   else
-    tmppath=m_strdup(path);
+    tmppath=xstrdup (path);
 
   /* If the item is located in the homedir, but isn't the homedir,
      don't continue if we already checked the homedir itself.  This is
@@ -953,7 +986,7 @@ check_permissions(const char *path,int item)
       goto end;
     }
 
-  m_free(dir);
+  xfree (dir);
 
   /* Assume failure */
   ret=1;
@@ -1076,7 +1109,7 @@ check_permissions(const char *path,int item)
     }
 
  end:
-  m_free(tmppath);
+  xfree (tmppath);
 
   if(homedir)
     homedir_cache=ret;
@@ -1092,7 +1125,7 @@ int
 main( int argc, char **argv )
 {
     ARGPARSE_ARGS pargs;
-    IOBUF a;
+    iobuf_t a;
     int rc=0;
     int orig_argc;
     char **orig_argv;
@@ -1137,17 +1170,31 @@ main( int argc, char **argv )
 #endif /* __riscos__ */
 
     trap_unaligned();
-    secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
+    set_strusage (my_strusage);
+    gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
+    /* We don't need any locking in libgcrypt unless we use any kind of
+       threading. */
+    gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
     /* Please note that we may running SUID(ROOT), so be very CAREFUL
      * when adding any stuff between here and the call to
      * secmem_init()  somewhere after the option parsing
      */
-    log_set_name("gpg");
-    secure_random_alloc(); /* put random number into secure memory */
+    log_set_prefix ("gpg", 1);
+    /* check that the libraries are suitable.  Do it here because the
+       option parse may need services of the library */
+    if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
+      {
+        log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
+                   NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
+      }
+
+    gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
+
     may_coredump = disable_core_dumps();
-    init_signals();
-    create_dotlock(NULL); /* register locking cleanup */
+    init_signals (); /* why not gnupg_init_signals. */
+    create_dotlock (NULL); /* register locking cleanup */
     i18n_init();
+
     opt.command_fd = -1; /* no command fd */
     opt.compress = -1; /* defaults to standard compress level */
     /* note: if you change these lines, look at oOpenPGP */
@@ -1238,7 +1285,7 @@ main( int argc, char **argv )
 
 #ifdef HAVE_DOSISH_SYSTEM
     if ( strchr (opt.homedir,'\\') ) {
-        char *d, *buf = m_alloc (strlen (opt.homedir)+1);
+        char *d, *buf = xmalloc (strlen (opt.homedir)+1);
         const char *s = opt.homedir;
         for (d=buf,s=opt.homedir; *s; s++)
             *d++ = *s == '\\'? '/': *s;
@@ -1251,11 +1298,13 @@ main( int argc, char **argv )
        init_shm_coprocessing(requested_shm_size, 1 );
     }
 #endif
-    /* initialize the secure memory. */
-    secmem_init( 32768 );
+    /* Initialize the secure memory. */
+    gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
     maybe_setuid = 0;
     /* Okay, we are now working under our real uid */
 
+    /* malloc hooks gohere ... */
+
     set_native_charset (NULL); /* Try to auto set the character set */
 
     if( default_config )
@@ -1265,7 +1314,7 @@ main( int argc, char **argv )
                                   "gpg" EXTSEP_S "conf-" SAFE_VERSION, NULL );
        if(access(configname,R_OK))
          {
-           m_free(configname);
+           xfree (configname);
            configname = make_filename(opt.homedir,
                                       "gpg" EXTSEP_S "conf", NULL );
          }
@@ -1274,11 +1323,11 @@ main( int argc, char **argv )
             char *p = make_filename(opt.homedir, "options", NULL );
             if (!access (p, R_OK))
               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
-            m_free (p);
+            xfree (p);
           }
         else
           { /* Keep on using the old default one. */
-            m_free (configname);
+            xfree (configname);
             configname = make_filename(opt.homedir, "options", NULL );
           }
       }
@@ -1317,7 +1366,7 @@ main( int argc, char **argv )
                                    configname, strerror(errno) );
                g10_exit(2);
            }
-           m_free(configname); configname = NULL;
+           xfree (configname); configname = NULL;
        }
        if( parse_debug && configname )
            log_info(_("reading options from `%s'\n"), configname );
@@ -1437,8 +1486,7 @@ main( int argc, char **argv )
             break;
 #endif /* __riscos__ */
          case oLoggerFD:
-            log_set_logfile( NULL,
-                             iobuf_translate_file_handle (pargs.r.ret_int, 1) );
+            log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
             break;
 #ifdef __riscos__
          case oLoggerFile:
@@ -1454,8 +1502,8 @@ main( int argc, char **argv )
          case oOptions:
            /* config files may not be nested (silently ignore them) */
            if( !configfp ) {
-               m_free(configname);
-               configname = m_strdup(pargs.r.ret_str);
+               xfree (configname);
+               configname = xstrdup (pargs.r.ret_str);
                goto next_pass;
            }
            break;
@@ -1465,7 +1513,8 @@ main( int argc, char **argv )
          case oNoGreeting: nogreeting = 1; break;
          case oNoVerbose: g10_opt_verbose = 0;
                           opt.verbose = 0; opt.list_sigs=0; break;
-         case oQuickRandom: quick_random_gen(1); break;
+      /* disabled for now: 
+          case oQuickRandom: quick_random_gen(1); break; */
          case oSKComments: opt.sk_comments=1; break;
          case oNoSKComments: opt.sk_comments=0; break;
          case oEmitVersion: opt.no_version=0; break;
@@ -1480,11 +1529,11 @@ main( int argc, char **argv )
                        opt.def_recipient = make_username(pargs.r.ret_str);
                    break;
          case oDefRecipientSelf:
-                   m_free(opt.def_recipient); opt.def_recipient = NULL;
+                   xfree (opt.def_recipient); opt.def_recipient = NULL;
                    opt.def_recipient_self = 1;
                    break;
          case oNoDefRecipient:
-                   m_free(opt.def_recipient); opt.def_recipient = NULL;
+                   xfree (opt.def_recipient); opt.def_recipient = NULL;
                    opt.def_recipient_self = 0;
                    break;
          case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
@@ -1621,8 +1670,8 @@ main( int argc, char **argv )
          case oDisableMDC: opt.disable_mdc = 1; break;
          case oNoDisableMDC: opt.disable_mdc = 0; break;
          case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
-         case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
-         case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
+         case oS2KDigest: s2k_digest_string = xstrdup (pargs.r.ret_str); break;
+         case oS2KCipher: s2k_cipher_string = xstrdup (pargs.r.ret_str); break;
           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
          case oNoEncryptTo: opt.no_encrypt_to = 1; break;
          case oEncryptTo: /* store the recipient in the second list */
@@ -1671,8 +1720,8 @@ main( int argc, char **argv )
             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
             break;
 #endif /* __riscos__ */
-         case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
-         case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
+         case oCipherAlgo: def_cipher_string = xstrdup (pargs.r.ret_str); break;
+         case oDigestAlgo: def_digest_string = xstrdup (pargs.r.ret_str); break;
          case oCompressAlgo:
            /* If it is all digits, stick a Z in front of it for
               later.  This is for backwards compatibility with
@@ -1689,16 +1738,19 @@ main( int argc, char **argv )
 
              if(*pt=='\0')
                {
-                 def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
+                 def_compress_string=xmalloc (strlen(pargs.r.ret_str)+2);
                  strcpy(def_compress_string,"Z");
                  strcat(def_compress_string,pargs.r.ret_str);
                }
              else
-               def_compress_string = m_strdup(pargs.r.ret_str);
+               def_compress_string = xstrdup (pargs.r.ret_str);
            }
            break;
-         case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
-         case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
+         case oCertDigestAlgo: cert_digest_string = xstrdup (pargs.r.ret_str); break;
+         case oNoSecmemWarn:
+#warning add secmem_get_flags
+/*              secmem_set_flags( secmem_get_flags() | 1 ); */
+            break;
          case oNoPermissionWarn: opt.no_perm_warn=1; break;
          case oNoMDCWarn: opt.no_mdc_warn=1; break;
           case oCharset:
@@ -1719,7 +1771,7 @@ main( int argc, char **argv )
 #endif /* __riscos__ */
             break;
          case oKeyServer:
-           opt.keyserver_uri=m_strdup(pargs.r.ret_str);
+           opt.keyserver_uri=xstrdup (pargs.r.ret_str);
            if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
              log_error(_("could not parse keyserver URI\n"));
            break;
@@ -1813,11 +1865,19 @@ main( int argc, char **argv )
          case oUtf8Strings: utf8_strings = 1; break;
          case oNoUtf8Strings: utf8_strings = 0; break;
          case oDisableCipherAlgo:
-               disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
-               break;
+            {
+              int algo = gcry_cipher_map_name (pargs.r.ret_str);
+              gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO,
+                               &algo, sizeof algo);
+            }
+            break;
          case oDisablePubkeyAlgo:
-               disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
-               break;
+            {
+              int algo = gcry_pk_map_name (pargs.r.ret_str);
+              gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,
+                           &algo, sizeof algo );
+            }
+            break;
           case oNoSigCache: opt.no_sig_cache = 1; break;
           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
          case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
@@ -1900,10 +1960,10 @@ main( int argc, char **argv )
     if( configfp ) {
        fclose( configfp );
        configfp = NULL;
-       m_free(configname); configname = NULL;
+       xfree (configname); configname = NULL;
        goto next_pass;
     }
-    m_free( configname ); configname = NULL;
+    xfree ( configname ); configname = NULL;
     if( log_get_errorcount(0) )
        g10_exit(2);
     if( nogreeting )
@@ -1952,8 +2012,10 @@ main( int argc, char **argv )
     if( opt.batch )
        tty_batchmode( 1 );
 
+#warning fix that
+#if 0
     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
-
+#endif
     set_debug();
 
     /* Do these after the switch(), so they can override settings. */
@@ -1986,7 +2048,7 @@ main( int argc, char **argv )
               preference, but those have their own error
               messages). */
 
-           if(check_cipher_algo(CIPHER_ALGO_IDEA))
+           if(openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
              {
                log_info(_("encrypting a message in --pgp2 mode requires "
                           "the IDEA cipher\n"));
@@ -1998,8 +2060,8 @@ main( int argc, char **argv )
                /* This only sets IDEA for symmetric encryption
                   since it is set via select_algo_from_prefs for
                   pk encryption. */
-               m_free(def_cipher_string);
-               def_cipher_string = m_strdup("idea");
+               xfree (def_cipher_string);
+               def_cipher_string = xstrdup ("idea");
              }
 
            /* PGP2 can't handle the output from the textmode
@@ -2024,8 +2086,8 @@ main( int argc, char **argv )
            opt.pgp2_workarounds = 1;
            opt.ask_sig_expire = 0;
            opt.ask_cert_expire = 0;
-           m_free(def_digest_string);
-           def_digest_string = m_strdup("md5");
+           xfree (def_digest_string);
+           def_digest_string = xstrdup ("md5");
            opt.def_compress_algo = 1;
          }
       }
@@ -2053,43 +2115,43 @@ main( int argc, char **argv )
     /* must do this after dropping setuid, because string_to...
      * may try to load an module */
     if( def_cipher_string ) {
-       opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
+       opt.def_cipher_algo = gcry_cipher_map_name (def_cipher_string);
        if(opt.def_cipher_algo==0 &&
           (ascii_strcasecmp(def_cipher_string,"idea")==0
            || ascii_strcasecmp(def_cipher_string,"s1")==0))
          idea_cipher_warn(1);
-       m_free(def_cipher_string); def_cipher_string = NULL;
-       if( check_cipher_algo(opt.def_cipher_algo) )
+       xfree (def_cipher_string); def_cipher_string = NULL;
+       if( openpgp_cipher_test_algo (opt.def_cipher_algo) )
            log_error(_("selected cipher algorithm is invalid\n"));
     }
     if( def_digest_string ) {
-       opt.def_digest_algo = string_to_digest_algo(def_digest_string);
-       m_free(def_digest_string); def_digest_string = NULL;
-       if( check_digest_algo(opt.def_digest_algo) )
+       opt.def_digest_algo = gcry_md_map_name (def_digest_string);
+       xfree (def_digest_string); def_digest_string = NULL;
+       if( openpgp_md_test_algo (opt.def_digest_algo) )
            log_error(_("selected digest algorithm is invalid\n"));
     }
     if( def_compress_string ) {
        opt.def_compress_algo = string_to_compress_algo(def_compress_string);
-       m_free(def_compress_string); def_compress_string = NULL;
+       xfree (def_compress_string); def_compress_string = NULL;
        if( check_compress_algo(opt.def_compress_algo) )
            log_error(_("selected compression algorithm is invalid\n"));
     }
     if( cert_digest_string ) {
-       opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
-       m_free(cert_digest_string); cert_digest_string = NULL;
-       if( check_digest_algo(opt.cert_digest_algo) )
+       opt.cert_digest_algo = gcry_md_map_name (cert_digest_string);
+       xfree (cert_digest_string); cert_digest_string = NULL;
+       if( openpgp_md_test_algo(opt.cert_digest_algo) )
            log_error(_("selected certification digest algorithm is invalid\n"));
     }
     if( s2k_cipher_string ) {
-       opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
-       m_free(s2k_cipher_string); s2k_cipher_string = NULL;
-       if( check_cipher_algo(opt.s2k_cipher_algo) )
+       opt.s2k_cipher_algo = gcry_cipher_map_name (s2k_cipher_string);
+       xfree (s2k_cipher_string); s2k_cipher_string = NULL;
+       if( openpgp_cipher_test_algo (opt.s2k_cipher_algo) )
            log_error(_("selected cipher algorithm is invalid\n"));
     }
     if( s2k_digest_string ) {
-       opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
-       m_free(s2k_digest_string); s2k_digest_string = NULL;
-       if( check_digest_algo(opt.s2k_digest_algo) )
+       opt.s2k_digest_algo = gcry_md_map_name (s2k_digest_string);
+       xfree (s2k_digest_string); s2k_digest_string = NULL;
+       if( openpgp_md_test_algo (opt.s2k_digest_algo) )
            log_error(_("selected digest algorithm is invalid\n"));
     }
     if( opt.completes_needed < 1 )
@@ -2143,32 +2205,32 @@ main( int argc, char **argv )
        const char *badalg=NULL;
        preftype_t badtype=PREFTYPE_NONE;
 
-       if(opt.def_cipher_algo
-          && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
+       if (opt.def_cipher_algo
+            && !algo_available (PREFTYPE_SYM,opt.def_cipher_algo,NULL))
          {
-           badalg=cipher_algo_to_string(opt.def_cipher_algo);
-           badtype=PREFTYPE_SYM;
+           badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
+           badtype = PREFTYPE_SYM;
          }
-       else if(opt.def_digest_algo
-               && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
+       else if (opt.def_digest_algo
+               && !algo_available (PREFTYPE_HASH,opt.def_digest_algo,NULL))
          {
-           badalg=digest_algo_to_string(opt.def_digest_algo);
-           badtype=PREFTYPE_HASH;
+           badalg = gcry_md_algo_name (opt.def_digest_algo);
+           badtype = PREFTYPE_HASH;
          }
-       else if(opt.cert_digest_algo
-               && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
+       else if (opt.cert_digest_algo
+                && !algo_available (PREFTYPE_HASH,opt.cert_digest_algo,NULL))
          {
-           badalg=digest_algo_to_string(opt.cert_digest_algo);
-           badtype=PREFTYPE_HASH;
+           badalg = gcry_md_algo_name (opt.cert_digest_algo);
+           badtype = PREFTYPE_HASH;
          }
-       else if(opt.def_compress_algo!=-1
-               && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
+       else if (opt.def_compress_algo!=-1
+                 && !algo_available (PREFTYPE_ZIP,opt.def_compress_algo,NULL))
          {
-           badalg=compress_algo_to_string(opt.def_compress_algo);
-           badtype=PREFTYPE_ZIP;
+           badalg = compress_algo_to_string (opt.def_compress_algo);
+           badtype = PREFTYPE_ZIP;
          }
 
-       if(badalg)
+       if (badalg)
          {
            switch(badtype)
              {
@@ -2198,8 +2260,11 @@ main( int argc, char **argv )
     /* set the random seed file */
     if( use_random_seed ) {
        char *p = make_filename(opt.homedir, "random_seed", NULL );
+#warning No random seed file yet
+#if 0
        set_random_seed_file(p);
-       m_free(p);
+#endif
+       xfree (p);
     }
 
     if( !cmd && opt.fingerprint && !with_fpr ) {
@@ -2276,7 +2341,7 @@ main( int argc, char **argv )
       default: rc = setup_trustdb(1, trustdb_name ); break;
     }
     if( rc )
-       log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
+       log_error(_("failed to initialize the TrustDB: %s\n"), gpg_strerror (rc));
 
 
     switch (cmd) {
@@ -2298,22 +2363,23 @@ main( int argc, char **argv )
        if( argc > 1 )
            wrong_args(_("--store [filename]"));
        if( (rc = encode_store(fname)) )
-           log_error_f( print_fname_stdin(fname),
-                       "store failed: %s\n", g10_errstr(rc) );
+           log_error ("\b%s: store failed: %s\n",
+                       print_fname_stdin(fname), gpg_strerror (rc) );
        break;
       case aSym: /* encrypt the given file only with the symmetric cipher */
        if( argc > 1 )
            wrong_args(_("--symmetric [filename]"));
        if( (rc = encode_symmetric(fname)) )
-           log_error_f(print_fname_stdin(fname),
-                       "symmetric encryption failed: %s\n",g10_errstr(rc) );
+           log_error ("\b%s: symmetric encryption failed: %s\n",
+                       print_fname_stdin(fname), gpg_strerror (rc) );
        break;
 
       case aEncr: /* encrypt the given file */
        if( argc > 1 )
            wrong_args(_("--encrypt [filename]"));
        if( (rc = encode_crypt(fname,remusr)) )
-           log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
+           log_error("%s: encryption failed: %s\n",
+                      print_fname_stdin(fname), gpg_strerror (rc) );
        break;
 
       case aEncrFiles: /* encrypt the given files */
@@ -2330,12 +2396,12 @@ main( int argc, char **argv )
            if( argc > 1 )
                wrong_args(_("--sign [filename]"));
            if( argc ) {
-               sl = m_alloc_clear( sizeof *sl + strlen(fname));
+               sl = xcalloc (1, sizeof *sl + strlen(fname));
                strcpy(sl->d, fname);
            }
        }
        if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
-           log_error("signing failed: %s\n", g10_errstr(rc) );
+           log_error("signing failed: %s\n", gpg_strerror (rc) );
        free_strlist(sl);
        break;
 
@@ -2343,13 +2409,13 @@ main( int argc, char **argv )
        if( argc > 1 )
            wrong_args(_("--sign --encrypt [filename]"));
        if( argc ) {
-           sl = m_alloc_clear( sizeof *sl + strlen(fname));
+           sl = xcalloc (1, sizeof *sl + strlen(fname));
            strcpy(sl->d, fname);
        }
        else
            sl = NULL;
        if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
-           log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
+           log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), gpg_strerror (rc) );
        free_strlist(sl);
        break;
 
@@ -2359,7 +2425,7 @@ main( int argc, char **argv )
        rc = sign_symencrypt_file (fname, locusr);
         if (rc)
            log_error("%s: sign+symmetric failed: %s\n",
-                      print_fname_stdin(fname), g10_errstr(rc) );
+                      print_fname_stdin(fname), gpg_strerror (rc) );
        break;
 
       case aClearsign: /* make a clearsig */
@@ -2367,24 +2433,24 @@ main( int argc, char **argv )
            wrong_args(_("--clearsign [filename]"));
        if( (rc = clearsign_file(fname, locusr, NULL)) )
            log_error("%s: clearsign failed: %s\n",
-                      print_fname_stdin(fname), g10_errstr(rc) );
+                      print_fname_stdin(fname), gpg_strerror (rc) );
        break;
 
       case aVerify:
        if( (rc = verify_signatures( argc, argv ) ))
-           log_error("verify signatures failed: %s\n", g10_errstr(rc) );
+           log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
        break;
 
       case aVerifyFiles:
        if( (rc = verify_files( argc, argv ) ))
-           log_error("verify files failed: %s\n", g10_errstr(rc) );
+           log_error("verify files failed: %s\n", gpg_strerror (rc) );
        break;
 
       case aDecrypt:
        if( argc > 1 )
            wrong_args(_("--decrypt [filename]"));
        if( (rc = decrypt_message( fname ) ))
-           log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
+           log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
        break;
 
       case aDecryptFiles:
@@ -2396,7 +2462,7 @@ main( int argc, char **argv )
            wrong_args(_("--sign-key user-id"));
        username = make_username( fname );
        keyedit_menu(fname, locusr, NULL, 1 );
-       m_free(username);
+       xfree (username);
        break;
 
       case aLSignKey:
@@ -2404,7 +2470,7 @@ main( int argc, char **argv )
            wrong_args(_("--lsign-key user-id"));
        username = make_username( fname );
        keyedit_menu(fname, locusr, NULL, 2 );
-       m_free(username);
+       xfree (username);
        break;
 
       case aNRSignKey:
@@ -2412,7 +2478,7 @@ main( int argc, char **argv )
            wrong_args(_("--nrsign-key user-id"));
        username = make_username( fname );
        keyedit_menu(fname, locusr, NULL, 3 );
-        m_free(username);
+        xfree (username);
         break;
 
       case aNRLSignKey:
@@ -2420,7 +2486,7 @@ main( int argc, char **argv )
            wrong_args(_("--nrlsign-key user-id"));
        username = make_username( fname );
        keyedit_menu(fname, locusr, NULL, 4 );
-        m_free(username);
+        xfree (username);
         break;
 
       case aEditKey: /* Edit a key signature */
@@ -2436,7 +2502,7 @@ main( int argc, char **argv )
        }
        else
            keyedit_menu(username, locusr, NULL, 0 );
-       m_free(username);
+       xfree (username);
        break;
 
       case aDeleteKeys:
@@ -2534,11 +2600,11 @@ main( int argc, char **argv )
        if(rc)
          {
            if(cmd==aSendKeys)
-             log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
+             log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
            else if(cmd==aRecvKeys)
-             log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
+             log_error(_("keyserver receive failed: %s\n"),gpg_strerror (rc));
            else
-             log_error(_("key export failed: %s\n"),g10_errstr(rc));
+             log_error(_("key export failed: %s\n"),gpg_strerror (rc));
          }
        free_strlist(sl);
        break;
@@ -2546,11 +2612,20 @@ main( int argc, char **argv )
      case aSearchKeys:
        sl = NULL;
        for( ; argc; argc--, argv++ )
-         append_to_strlist2( &sl, *argv, utf8_strings );
+          {
+            if (utf8_strings)
+              sl = append_to_strlist ( &sl, *argv );
+            else
+              {
+                char *p = native_to_utf8 ( *argv );
+                sl = append_to_strlist( &sl, p );
+                xfree( p );
+              }
+          }
 
        rc=keyserver_search( sl );
        if(rc)
-         log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
+         log_error(_("keyserver search failed: %s\n"),gpg_strerror (rc));
        free_strlist(sl);
        break;
 
@@ -2560,7 +2635,7 @@ main( int argc, char **argv )
            add_to_strlist2( &sl, *argv, utf8_strings );
        rc=keyserver_refresh(sl);
        if(rc)
-         log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
+         log_error(_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
        free_strlist(sl);
        break;
 
@@ -2585,7 +2660,7 @@ main( int argc, char **argv )
            wrong_args("--gen-revoke user-id");
        username =  make_username(*argv);
        gen_revoke( username );
-       m_free( username );
+       xfree ( username );
        break;
 
       case aDesigRevoke:
@@ -2593,7 +2668,7 @@ main( int argc, char **argv )
            wrong_args("--desig-revoke user-id");
        username =  make_username(*argv);
        gen_desig_revoke( username );
-       m_free( username );
+       xfree ( username );
        break;
 
       case aDeArmor:
@@ -2601,7 +2676,7 @@ main( int argc, char **argv )
            wrong_args("--dearmor [file]");
        rc = dearmor_file( argc? *argv: NULL );
        if( rc )
-           log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
+           log_error(_("dearmoring failed: %s\n"), gpg_strerror (rc));
        break;
 
       case aEnArmor:
@@ -2609,11 +2684,12 @@ main( int argc, char **argv )
            wrong_args("--enarmor [file]");
        rc = enarmor_file( argc? *argv: NULL );
        if( rc )
-           log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
+           log_error(_("enarmoring failed: %s\n"), gpg_strerror (rc));
        break;
 
 
       case aPrimegen:
+#if 0 /*FIXME-XXX*/
        {   int mode = argc < 2 ? 0 : atoi(*argv);
 
            if( mode == 1 && argc == 2 ) {
@@ -2625,7 +2701,7 @@ main( int argc, char **argv )
                                             atoi(argv[2]), NULL,NULL ), 1);
            }
            else if( mode == 3 && argc == 3 ) {
-               MPI *factors;
+               gcry_mpi_t *factors;
                mpi_print( stdout, generate_elg_prime(
                                             1, atoi(argv[1]),
                                             atoi(argv[2]), NULL,&factors ), 1);
@@ -2633,7 +2709,7 @@ main( int argc, char **argv )
                mpi_print( stdout, factors[0], 1 ); /* print q */
            }
            else if( mode == 4 && argc == 3 ) {
-               MPI g = mpi_alloc(1);
+               gcry_mpi_t g = mpi_alloc(1);
                mpi_print( stdout, generate_elg_prime(
                                                 0, atoi(argv[1]),
                                                 atoi(argv[2]), g, NULL ), 1);
@@ -2645,6 +2721,7 @@ main( int argc, char **argv )
                wrong_args("--gen-prime mode bits [qbits] ");
            putchar('\n');
        }
+#endif
        break;
 
       case aGenRandom:
@@ -2664,14 +2741,14 @@ main( int argc, char **argv )
                    other tools */
                size_t n = !endless && count < 99? count : 99;
 
-               p = get_random_bits( n*8, level, 0);
+               p = gcry_random_bytes (n, level);
 #ifdef HAVE_DOSISH_SYSTEM
                setmode ( fileno(stdout), O_BINARY );
 #endif
                 if (opt.armor) {
                     char *tmp = make_radix64_string (p, n);
                     fputs (tmp, stdout);
-                    m_free (tmp);
+                    xfree (tmp);
                     if (n%3 == 1)
                       putchar ('=');
                     if (n%3)
@@ -2679,7 +2756,7 @@ main( int argc, char **argv )
                 } else {
                     fwrite( p, n, 1, stdout );
                 }
-               m_free(p);
+               xfree (p);
                if( !endless )
                    count -= n;
            }
@@ -2693,7 +2770,7 @@ main( int argc, char **argv )
            wrong_args("--print-md algo [files]");
        {
            int all_algos = (**argv=='*' && !(*argv)[1]);
-           int algo = all_algos? 0 : string_to_digest_algo(*argv);
+           int algo = all_algos? 0 : gcry_md_map_name (*argv);
 
            if( !algo && !all_algos )
                log_error(_("invalid hash algorithm `%s'\n"), *argv );
@@ -2750,7 +2827,7 @@ main( int argc, char **argv )
        for( ; argc; argc--, argv++ ) {
            username = make_username( *argv );
            list_trust_path( username );
-           m_free(username);
+           xfree (username);
        }
        break;
 
@@ -2804,7 +2881,7 @@ main( int argc, char **argv )
            }
            rc = proc_packets(NULL, a );
            if( rc )
-               log_error("processing message failed: %s\n", g10_errstr(rc) );
+               log_error("processing message failed: %s\n", gpg_strerror (rc) );
            iobuf_close(a);
        }
        break;
@@ -2821,14 +2898,14 @@ main( int argc, char **argv )
 void
 g10_exit( int rc )
 {
-    update_random_seed_file();
-    if( opt.debug & DBG_MEMSTAT_VALUE ) {
-       m_print_stats("on exit");
-       random_dump_stats();
-    }
-    if( opt.debug )
-       secmem_dump_stats();
-    secmem_term();
+  /* FIXME-XX update_random_seed_file(); */
+/*      if( opt.debug & DBG_MEMSTAT_VALUE ) { */
+/*          m_print_stats("on exit"); */
+/*     random_dump_stats(); */
+/*      } */
+/*      if( opt.debug ) */
+/*     secmem_dump_stats(); */
+    gcry_control (GCRYCTL_TERM_SECMEM );
     rc = rc? rc : log_get_errorcount(0)? 2 :
                        g10_errors_seen? 1 : 0;
     exit(rc );
@@ -2858,14 +2935,14 @@ print_hex( MD_HANDLE md, int algo, const char *fname )
   else if(algo==DIGEST_ALGO_TIGER)
     indent+=printf(" TIGER = ");
   else if(algo>0)
-    indent+=printf("%6s = ",digest_algo_to_string(algo));
+    indent+=printf("%6s = ", gcry_md_algo_name (algo));
   else
     algo=abs(algo);
 
   count=indent;
 
-  p = md_read( md, algo );
-  n = md_digest_length(algo);
+  p = gcry_md_read (md, algo);
+  n = gcry_md_get_algo_dlen (algo);
 
   count+=printf("%02X",*p++);
 
@@ -2936,8 +3013,8 @@ print_hashline( MD_HANDLE md, int algo, const char *fname )
     }
     putchar(':');
     printf("%d:", algo );
-    p = md_read( md, algo );
-    n = md_digest_length(algo);
+    p = gcry_md_read (md, algo );
+    n = gcry_md_get_algo_dlen (algo);
     for(i=0; i < n ; i++, p++ ) 
         printf("%02X", *p );
     putchar(':');
@@ -2966,47 +3043,47 @@ print_mds( const char *fname, int algo )
        return;
     }
 
-    md = md_open( 0, 0 );
+    gcry_md_open (&md, 0, 0 );
     if( algo )
-       md_enable( md, algo );
+       gcry_md_enable ( md, algo );
     else {
-       md_enable( md, DIGEST_ALGO_MD5 );
-       md_enable( md, DIGEST_ALGO_SHA1 );
-       md_enable( md, DIGEST_ALGO_RMD160 );
+       gcry_md_enable (md, GCRY_MD_MD5 );
+       gcry_md_enable (md, GCRY_MD_SHA1 );
+       gcry_md_enable (md, GCRY_MD_RMD160 );
 #ifdef USE_TIGER192
-       md_enable( md, DIGEST_ALGO_TIGER );
+       gcry_md_enable (md, GCRY_MD_TIGER );
 #endif
 #ifdef USE_SHA256
-       md_enable( md, DIGEST_ALGO_SHA256 );
+       gcry_md_enable (md, GCRY_MD_SHA256 );
 #endif
 #ifdef USE_SHA512
-       md_enable( md, DIGEST_ALGO_SHA384 );
-       md_enable( md, DIGEST_ALGO_SHA512 );
+       gcry_md_enable (md, GCRY_MD_SHA384 );
+       gcry_md_enable (md, GCRY_MD_SHA512 );
 #endif
     }
 
     while( (n=fread( buf, 1, DIM(buf), fp )) )
-       md_write( md, buf, n );
+       gcry_md_write (md, buf, n);
     if( ferror(fp) )
        log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
     else {
-       md_final(md);
+       gcry_md_final (md);
         if ( opt.with_colons ) {
             if ( algo ) 
                 print_hashline( md, algo, fname );
             else {
-                print_hashline( md, DIGEST_ALGO_MD5, fname );
-                print_hashline( md, DIGEST_ALGO_SHA1, fname );
-                print_hashline( md, DIGEST_ALGO_RMD160, fname );
+                print_hashline( md, GCRY_MD_MD5, fname );
+                print_hashline( md, GCRY_MD_SHA1, fname );
+                print_hashline( md, GCRY_MD_RMD160, fname );
 #ifdef USE_TIGER192
-               print_hashline( md, DIGEST_ALGO_TIGER, fname );
+               print_hashline( md, GCRY_MD_TIGER, fname );
 #endif
 #ifdef USE_SHA256
-                print_hashline( md, DIGEST_ALGO_SHA256, fname );
+                print_hashline( md, GCRY_MD_SHA256, fname );
 #endif
 #ifdef USE_SHA512
-               print_hashline( md, DIGEST_ALGO_SHA384, fname );
-               print_hashline( md, DIGEST_ALGO_SHA512, fname );
+               print_hashline( md, GCRY_MD_SHA384, fname );
+               print_hashline( md, GCRY_MD_SHA512, fname );
 #endif
             }
         }
@@ -3014,23 +3091,23 @@ print_mds( const char *fname, int algo )
             if( algo )
               print_hex(md,-algo,fname);
             else {
-                print_hex( md, DIGEST_ALGO_MD5, fname );
-                print_hex( md, DIGEST_ALGO_SHA1, fname );
-                print_hex( md, DIGEST_ALGO_RMD160, fname );
+                print_hex( md, GCRY_MD_MD5, fname );
+                print_hex( md, GCRY_MD_SHA1, fname );
+                print_hex( md, GCRY_MD_RMD160, fname );
 #ifdef USE_TIGER192
-               print_hex( md, DIGEST_ALGO_TIGER, fname );
+               print_hex( md, GCRY_MD_TIGER, fname );
 #endif
 #ifdef USE_SHA256
-                print_hex( md, DIGEST_ALGO_SHA256, fname );
+                print_hex( md, GCRY_MD_SHA256, fname );
 #endif
 #ifdef USE_SHA512
-               print_hex( md, DIGEST_ALGO_SHA384, fname );
-               print_hex( md, DIGEST_ALGO_SHA512, fname );
+               print_hex( md, GCRY_MD_SHA384, fname );
+               print_hex( md, GCRY_MD_SHA512, fname );
 #endif
             }
         }
     }
-    md_close(md);
+    gcry_md_close (md);
 
     if( fp != stdin )
        fclose(fp);
index 1944c2a..79fcaf3 100644 (file)
@@ -25,6 +25,8 @@
 #include <string.h>
 #include <assert.h>
 #include <ctype.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "packet.h"
 #include "memory.h"
@@ -152,7 +154,7 @@ cache_public_key( PKT_public_key *pk )
        return;
     }
     pk_cache_entries++;
-    ce = m_alloc( sizeof *ce );
+    ce = xmalloc ( sizeof *ce );
     ce->next = pk_cache;
     pk_cache = ce;
     ce->pk = copy_public_key( NULL, pk );
@@ -195,7 +197,7 @@ release_keyid_list ( keyid_list_t k )
 {
     while (  k ) {
         keyid_list_t k2 = k->next;
-        m_free (k);
+        xfree (k);
         k = k2;
     }
 }
@@ -216,7 +218,7 @@ cache_user_id( KBNODE keyblock )
     for (k=keyblock; k; k = k->next ) {
         if ( k->pkt->pkttype == PKT_PUBLIC_KEY
              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
-            keyid_list_t a = m_alloc_clear ( sizeof *a );
+            keyid_list_t a = xcalloc (1, sizeof *a );
             /* Hmmm: For a long list of keyids it might be an advantage
              * to append the keys */
             keyid_from_pk( k->pkt->pkt.public_key, a->keyid );
@@ -229,7 +231,7 @@ cache_user_id( KBNODE keyblock )
                         if( DBG_CACHE )
                             log_debug("cache_user_id: already in cache\n");
                         release_keyid_list ( keyids );
-                        m_free ( a );
+                        xfree ( a );
                         return;
                     }
                 }
@@ -250,10 +252,10 @@ cache_user_id( KBNODE keyblock )
        r = user_id_db;
        user_id_db = r->next;
         release_keyid_list ( r->keyids );
-       m_free(r);
+       xfree (r);
        uid_cache_entries--;
     }
-    r = m_alloc( sizeof *r + uidlen-1 );
+    r = xmalloc ( sizeof *r + uidlen-1 );
     r->keyids = keyids;
     r->len = uidlen;
     memcpy(r->name, uid, r->len);
@@ -273,7 +275,7 @@ getkey_disable_caches()
        for( ce = pk_cache; ce; ce = ce2 ) {
            ce2 = ce->next;
            free_public_key( ce->pk );
-           m_free( ce );
+           xfree ( ce );
        }
        pk_cache_disabled=1;
        pk_cache_entries = 0;
@@ -333,7 +335,7 @@ get_pubkey( PKT_public_key *pk, u32 *keyid )
 #endif
     /* more init stuff */
     if( !pk ) {
-       pk = m_alloc_clear( sizeof *pk );
+       pk = xcalloc (1, sizeof *pk );
        internal++;
     }
 
@@ -361,7 +363,7 @@ get_pubkey( PKT_public_key *pk, u32 *keyid )
     if( !rc )
        goto leave;
 
-    rc = G10ERR_NO_PUBKEY;
+    rc = GPG_ERR_NO_PUBKEY;
 
   leave:
     if( !rc )
@@ -404,14 +406,14 @@ get_pubkey_fast (PKT_public_key *pk, u32 *keyid)
   if (rc == -1)
     {
       keydb_release (hd);
-      return G10ERR_NO_PUBKEY;
+      return GPG_ERR_NO_PUBKEY;
     }
   rc = keydb_get_keyblock (hd, &keyblock);
   keydb_release (hd);
   if (rc) 
     {
-      log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-      return G10ERR_NO_PUBKEY;
+      log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
+      return GPG_ERR_NO_PUBKEY;
     }
   
   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
@@ -494,7 +496,7 @@ get_seckey( PKT_secret_key *sk, u32 *keyid )
  * check and does not tell us whether the secret key is valid.  It
  * merely tells other whether there is some secret key.
  * Returns: 0 := key is available
- * G10ERR_NO_SECKEY := not availabe
+ * GPG_ERR_NO_SECKEY := not availabe
  */
 int
 seckey_available( u32 *keyid )
@@ -504,7 +506,7 @@ seckey_available( u32 *keyid )
 
     rc = keydb_search_kid (hd, keyid);
     if ( rc == -1 )
-        rc = G10ERR_NO_SECKEY;
+        rc = GPG_ERR_NO_SECKEY;
     keydb_release (hd);
     return rc;
 }
@@ -729,13 +731,13 @@ static int
 skip_disabled(void *dummy,u32 *keyid)
 {
   int rc,disabled=0;
-  PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
+  PKT_public_key *pk=xcalloc (1,sizeof(PKT_public_key));
 
   rc = get_pubkey(pk, keyid);
   if(rc)
     {
       log_error("error checking disabled status of %08lX: %s\n",
-               (ulong)keyid[1],g10_errstr(rc));
+               (ulong)keyid[1],gpg_strerror (rc));
       goto leave;
     }
  
@@ -778,7 +780,7 @@ key_byname( GETKEY_CTX *retctx, STRLIST namelist,
     /* build the search context */
     for(n=0, r=namelist; r; r = r->next )
        n++;
-    ctx = m_alloc_clear (sizeof *ctx + (n-1)*sizeof ctx->items );
+    ctx = xcalloc (1,sizeof *ctx + (n-1)*sizeof ctx->items );
     ctx->nitems = n;
 
     for(n=0, r=namelist; r; r = r->next, n++ ) {
@@ -787,8 +789,8 @@ key_byname( GETKEY_CTX *retctx, STRLIST namelist,
         if (ctx->items[n].exact)
             ctx->exact = 1;
         if (!ctx->items[n].mode) {
-           m_free (ctx);
-           return G10ERR_INV_USER_ID;
+           xfree (ctx);
+           return GPG_ERR_INV_USER_ID;
        }
        if(!include_disabled
           && ctx->items[n].mode!=KEYDB_SEARCH_MODE_SHORT_KID
@@ -886,7 +888,7 @@ get_pubkey_end( GETKEY_CTX ctx )
         memset (&ctx->kbpos, 0, sizeof ctx->kbpos);
         keydb_release (ctx->kr_handle);
        if( !ctx->not_allocated )
-           m_free( ctx );
+           xfree ( ctx );
     }
 }
 
@@ -924,7 +926,7 @@ get_pubkey_byfprint( PKT_public_key *pk,
        get_pubkey_end( &ctx );
     }
     else
-       rc = G10ERR_GENERAL; /* Oops */
+       rc = GPG_ERR_GENERAL; /* Oops */
     return rc;
 }
 
@@ -954,14 +956,14 @@ get_pubkey_byfprint_fast (PKT_public_key *pk,
   if (rc == -1)
     {
       keydb_release (hd);
-      return G10ERR_NO_PUBKEY;
+      return GPG_ERR_NO_PUBKEY;
     }
   rc = keydb_get_keyblock (hd, &keyblock);
   keydb_release (hd);
   if (rc) 
     {
-      log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
-      return G10ERR_NO_PUBKEY;
+      log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
+      return GPG_ERR_NO_PUBKEY;
     }
   
   assert ( keyblock->pkt->pkttype == PKT_PUBLIC_KEY
@@ -1000,7 +1002,7 @@ get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
        get_pubkey_end( &ctx );
     }
     else
-       rc = G10ERR_GENERAL; /* Oops */
+       rc = GPG_ERR_GENERAL; /* Oops */
 
     return rc;
 }
@@ -1118,7 +1120,7 @@ get_seckey_byfprint( PKT_secret_key *sk,
        get_pubkey_end( &ctx );
     }
     else
-       rc = G10ERR_GENERAL; /* Oops */
+       rc = GPG_ERR_GENERAL; /* Oops */
     return rc;
 }
 
@@ -1290,12 +1292,12 @@ fixup_uidnode ( KBNODE uidnode, KBNODE signode, u32 keycreated )
     p = parse_sig_subpkt ( sig->hashed, SIGSUBPKT_PREF_COMPR, &n );
     zip = p; nzip = p?n:0;
     if (uid->prefs) 
-        m_free (uid->prefs);
+        xfree (uid->prefs);
     n = nsym + nhash + nzip;
     if (!n)
         uid->prefs = NULL;
     else {
-        uid->prefs = m_alloc (sizeof (*uid->prefs) * (n+1));
+        uid->prefs = xmalloc (sizeof (*uid->prefs) * (n+1));
         n = 0;
         for (; nsym; nsym--, n++) {
             uid->prefs[n].type = PREFTYPE_SYM;
@@ -1364,7 +1366,7 @@ merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
      */
 
     /* In case this key was already merged */
-    m_free(pk->revkey);
+    xfree (pk->revkey);
     pk->revkey=NULL;
     pk->numrevkeys=0;
 
@@ -1400,7 +1402,7 @@ merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
                    int i;
 
                    pk->revkey=
-                     m_realloc(pk->revkey,sizeof(struct revocation_key)*
+                     xrealloc(pk->revkey,sizeof(struct revocation_key)*
                                (pk->numrevkeys+sig->numrevkeys));
 
                    for(i=0;i<sig->numrevkeys;i++)
@@ -1451,7 +1453,7 @@ merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
          }
 
        if(changed)
-         pk->revkey=m_realloc(pk->revkey,
+         pk->revkey=xrealloc(pk->revkey,
                               pk->numrevkeys*sizeof(struct revocation_key));
       }
 
@@ -1594,7 +1596,7 @@ merge_selfsigs_main( KBNODE keyblock, int *r_revoked )
                  {
                    PKT_public_key *ultimate_pk;
 
-                   ultimate_pk=m_alloc_clear(sizeof(*ultimate_pk));
+                   ultimate_pk=xcalloc (1,sizeof(*ultimate_pk));
 
                     /* We don't want to use the full get_pubkey to
                        avoid infinite recursion in certain cases.
@@ -1969,7 +1971,7 @@ merge_selfsigs( KBNODE keyblock )
              || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
             PKT_public_key *pk = k->pkt->pkt.public_key;
             if (pk->prefs)
-                m_free (pk->prefs);
+                xfree (pk->prefs);
             pk->prefs = copy_prefs (prefs);
             pk->mdc_feature = mdc_feature;
         }
@@ -2326,7 +2328,7 @@ lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
 
         rc = keydb_get_keyblock (ctx->kr_handle, &ctx->keyblock);
         if (rc) {
-            log_error ("keydb_get_keyblock failed: %s\n", g10_errstr(rc));
+            log_error ("keydb_get_keyblock failed: %s\n", gpg_strerror (rc));
             rc = 0;
             goto skip;
         }
@@ -2383,16 +2385,16 @@ lookup( GETKEY_CTX ctx, KBNODE *ret_keyblock, int secmode )
 
   found:
     if( rc && rc != -1 )
-       log_error("keydb_search failed: %s\n", g10_errstr(rc));
+       log_error("keydb_search failed: %s\n", gpg_strerror (rc));
 
     if( !rc ) {
         *ret_keyblock = ctx->keyblock; /* return the keyblock */
         ctx->keyblock = NULL;
     }
     else if (rc == -1 && no_suitable_key)
-        rc = secmode ? G10ERR_UNU_SECKEY : G10ERR_UNU_PUBKEY;
+         rc = secmode ? GPG_ERR_UNUSABLE_SECKEY : GPG_ERR_UNUSABLE_PUBKEY;
     else if( rc == -1 )
-       rc = secmode ? G10ERR_NO_SECKEY : G10ERR_NO_PUBKEY;
+       rc = secmode ? GPG_ERR_NO_SECKEY : GPG_ERR_NO_PUBKEY;
 
     if ( secmode ) {
         release_kbnode( secblock );
@@ -2442,7 +2444,7 @@ enum_secret_keys( void **context, PKT_secret_key *sk,
 
 
     if( !c ) { /* make a new context */
-       c = m_alloc_clear( sizeof *c );
+       c = xcalloc (1, sizeof *c );
        *context = c;
        c->hd = keydb_new (1);
         c->first = 1;
@@ -2453,7 +2455,7 @@ enum_secret_keys( void **context, PKT_secret_key *sk,
     if( !sk ) { /* free the context */
         keydb_release (c->hd);
         release_kbnode (c->keyblock);
-       m_free( c );
+       xfree ( c );
        *context = NULL;
        return 0;
     }
@@ -2514,7 +2516,7 @@ get_user_id_string( u32 *keyid )
             keyid_list_t a;
             for (a=r->keyids; a; a= a->next ) {
                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
-                    p = m_alloc( r->len + 10 );
+                    p = xmalloc ( r->len + 10 );
                     sprintf(p, "%08lX %.*s",
                             (ulong)keyid[1], r->len, r->name );
                     return p;
@@ -2522,7 +2524,7 @@ get_user_id_string( u32 *keyid )
             }
         }
     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
-    p = m_alloc( 15 );
+    p = xmalloc ( 15 );
     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
     return p;
 }
@@ -2533,9 +2535,9 @@ get_user_id_string_printable ( u32 *keyid )
 {
     char *p = get_user_id_string( keyid );
     char *p2 = utf8_to_native( p, strlen(p), 0 );
-    m_free(p);
+    xfree (p);
     p = make_printable_string (p2, strlen (p2), 0);
-    m_free (p2);
+    xfree (p2);
     return p;
 }
 
@@ -2552,7 +2554,7 @@ get_long_user_id_string( u32 *keyid )
             keyid_list_t a;
             for (a=r->keyids; a; a= a->next ) {
                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
-                    p = m_alloc( r->len + 20 );
+                    p = xmalloc ( r->len + 20 );
                     sprintf(p, "%08lX%08lX %.*s",
                             (ulong)keyid[0], (ulong)keyid[1],
                             r->len, r->name );
@@ -2561,7 +2563,7 @@ get_long_user_id_string( u32 *keyid )
             }
         }
     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
-    p = m_alloc( 25 );
+    p = xmalloc ( 25 );
     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
     return p;
 }
@@ -2579,7 +2581,7 @@ get_user_id( u32 *keyid, size_t *rn )
             keyid_list_t a;
             for (a=r->keyids; a; a= a->next ) {
                 if( a->keyid[0] == keyid[0] && a->keyid[1] == keyid[1] ) {
-                    p = m_alloc( r->len );
+                    p = xmalloc ( r->len );
                     memcpy(p, r->name, r->len );
                     *rn = r->len;
                     return p;
@@ -2587,7 +2589,7 @@ get_user_id( u32 *keyid, size_t *rn )
             }
         }
     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
-    p = m_strdup( _("[User id not found]") );
+    p = xstrdup ( _("[User id not found]") );
     *rn = strlen(p);
     return p;
 }
@@ -2598,9 +2600,9 @@ get_user_id_printable( u32 *keyid )
     size_t rn;
     char *p = get_user_id( keyid, &rn );
     char *p2 = utf8_to_native( p, rn, 0 );
-    m_free(p);
+    xfree (p);
     p = make_printable_string (p2, strlen (p2), 0);
-    m_free (p2);
+    xfree (p2);
     return p;
 }
 
index 3c4e59e..d1c554d 100644 (file)
@@ -26,4 +26,6 @@
 typedef struct kbnode_struct *KBNODE;
 typedef struct keydb_search_desc KEYDB_SEARCH_DESC;
 
+#include "gpg.h"
+
 #endif /*GPG_GLOBAL_H*/
index ca7699b..bf61411 100644 (file)
--- a/g10/gpg.h
+++ b/g10/gpg.h
 #ifndef GNUPG_G10_GPG_H
 #define GNUPG_G10_GPG_H 
 
+/* Note, that this file should be the first one after the system
+   header files.  This is required to set the error source to the
+   correct value and may be of advantage if we ever have to do
+   special things. */
+
 #ifdef GPG_ERR_SOURCE_DEFAULT
 #error GPG_ERR_SOURCE_DEFAULT already defined
 #endif
index 67eccea..91574a7 100644 (file)
@@ -30,6 +30,7 @@
 #endif
 
 #define INCLUDED_BY_MAIN_MODULE 1
+#include "gpg.h"
 #include "packet.h"
 #include "iobuf.h"
 #include "memory.h"
@@ -82,8 +83,8 @@ int g10_errors_seen = 0;
 RISCOS_GLOBAL_STATICS("GnuPG (gpgv) Heap")
 #endif /* __riscos__ */
 
-const char *
-strusage( int level )
+static const char *
+my_strusage( int level )
 {
     const char *p;
     switch( level ) {
@@ -103,7 +104,7 @@ strusage( int level )
              "Check signatures against known trusted keys\n");
        break;
 
-      default: p = default_strusage(level);
+      default: p = NULL;
     }
     return p;
 }
@@ -124,7 +125,7 @@ i18n_init(void)
 #else
        setlocale( LC_ALL, "" );
 #endif
-    bindtextdomain( PACKAGE, G10_LOCALEDIR );
+    bindtextdomain( PACKAGE, LOCALEDIR );
     textdomain( PACKAGE );
 #endif
 #endif
@@ -144,7 +145,8 @@ main( int argc, char **argv )
     riscos_global_defaults();
 #endif /* __riscos__ */
 
-    log_set_name("gpgv");
+    set_strusage (my_strusage);
+    log_set_prefix ("gpgv", 1);
     init_signals();
     i18n_init();
     opt.command_fd = -1; /* no command fd */
@@ -177,7 +179,9 @@ main( int argc, char **argv )
                  opt.verbose++; opt.list_sigs=1; break;
           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
          case oStatusFD: set_status_fd( pargs.r.ret_int ); break;
-         case oLoggerFD: log_set_logfile( NULL, pargs.r.ret_int ); break;
+         case oLoggerFD: 
+            log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
+            break;
          case oHomedir: opt.homedir = pargs.r.ret_str; break;
          case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
          default : pargs.err = 2; break;
@@ -200,7 +204,7 @@ main( int argc, char **argv )
     FREE_STRLIST(nrings);
     
     if( (rc = verify_signatures( argc, argv ) ))
-        log_error("verify signatures failed: %s\n", g10_errstr(rc) );
+        log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
 
     /* cleanup */
     g10_exit(0);
@@ -287,19 +291,19 @@ keyserver_import_keyid( u32 *keyid, void *dummy )
 int
 get_session_key( PKT_pubkey_enc *k, DEK *dek )
 {
-    return G10ERR_GENERAL;
+    return GPG_ERR_GENERAL;
 }
 /* Stub: */
 int
 get_override_session_key( DEK *dek, const char *string )
 {
-    return G10ERR_GENERAL;
+    return GPG_ERR_GENERAL;
 }
 /* Stub: */
 int
 decrypt_data( void *procctx, PKT_encrypted *ed, DEK *dek )
 {
-    return G10ERR_GENERAL;
+    return GPG_ERR_GENERAL;
 }
 
 
@@ -317,7 +321,7 @@ display_online_help( const char *keyword )
 int
 check_secret_key( PKT_secret_key *sk, int n )
 {
-    return G10ERR_GENERAL;
+    return GPG_ERR_GENERAL;
 }
 
 /* Stub:
@@ -355,26 +359,6 @@ void cipher_decrypt( CIPHER_HANDLE c, byte *outbuf,
                      byte *inbuf, unsigned nbytes ) {}
 void cipher_sync( CIPHER_HANDLE c ) {}
 
-/* Stubs to avoid linking to ../cipher/random.c */
-void random_dump_stats(void) {}
-int quick_random_gen( int onoff ) { return -1;}
-void randomize_buffer( byte *buffer, size_t length, int level ) {}
-int random_is_faked() { return -1;}
-byte *get_random_bits( size_t nbits, int level, int secure ) { return NULL;}
-void set_random_seed_file( const char *name ) {}
-void update_random_seed_file() {}
-void fast_random_poll() {}
-
-/* Stubs to avoid linking of ../cipher/primegen.c */
-void register_primegen_progress ( void (*cb)( void *, int), void *cb_data ) {}
-MPI generate_secret_prime( unsigned  nbits ) { return NULL;}
-MPI generate_public_prime( unsigned  nbits ) { return NULL;}
-MPI generate_elg_prime( int mode, unsigned pbits, unsigned qbits,
-                        MPI g, MPI **ret_factors ) { return NULL;}
-
-/* Do not link to ../cipher/rndlinux.c */
-void rndlinux_constructor(void) {}
-
 
 /* Stubs to avoid linking to ../util/ttyio.c */
 int tty_batchmode( int onoff ) { return 0; }
@@ -393,4 +377,4 @@ void disable_dotlock(void) {}
 DOTLOCK create_dotlock( const char *file_to_lock ) { return NULL; }
 int make_dotlock( DOTLOCK h, long timeout ) { return 0;}
 int release_dotlock( DOTLOCK h ) {return 0;}
-void remove_lockfiles(void) {}
+void dotlock_remove_lockfiles(void) {}
index 0150c54..4a65314 100644 (file)
@@ -22,6 +22,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "ttyio.h"
 #include "main.h"
index 1b955c4..94e8914 100644 (file)
@@ -56,9 +56,9 @@ struct stats_s {
 };
 
 
-static int import( IOBUF inp, const char* fname,
+static int import( iobuf_t inp, const char* fname,
                    struct stats_s *stats, unsigned int options );
-static int read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root );
+static int read_block( iobuf_t a, PACKET **pending_pkt, KBNODE *ret_root );
 static void revocation_present(KBNODE keyblock);
 static int import_one( const char *fname, KBNODE keyblock,
                        struct stats_s *stats, unsigned int options);
@@ -101,13 +101,13 @@ parse_import_options(char *str,unsigned int *options)
 void *
 import_new_stats_handle (void)
 {
-    return m_alloc_clear ( sizeof (struct stats_s) );
+    return xcalloc (1, sizeof (struct stats_s) );
 }
 
 void
 import_release_stats_handle (void *p)
 {
-    m_free (p);
+    xfree (p);
 }
 
 /****************
@@ -142,7 +142,7 @@ import_release_stats_handle (void *p)
  *
  */
 static int
-import_keys_internal( IOBUF inp, char **fnames, int nnames,
+import_keys_internal( iobuf_t inp, char **fnames, int nnames,
                      void *stats_handle, unsigned int options )
 {
     int i, rc = 0;
@@ -160,7 +160,7 @@ import_keys_internal( IOBUF inp, char **fnames, int nnames,
 
        for(i=0; i < nnames; i++ ) {
            const char *fname = fnames? fnames[i] : NULL;
-           IOBUF inp2 = iobuf_open(fname);
+           iobuf_t inp2 = iobuf_open(fname);
            if( !fname )
                fname = "[stdin]";
            if( !inp2 )
@@ -170,7 +170,7 @@ import_keys_internal( IOBUF inp, char **fnames, int nnames,
                iobuf_close(inp2);
                if( rc )
                    log_error("import from `%s' failed: %s\n", fname,
-                                     g10_errstr(rc) );
+                                     gpg_strerror (rc) );
            }
            if( !fname )
                break;
@@ -204,13 +204,13 @@ import_keys( char **fnames, int nnames,
 }
 
 int
-import_keys_stream( IOBUF inp, void *stats_handle, unsigned int options )
+import_keys_stream( iobuf_t inp, void *stats_handle, unsigned int options )
 {
     return import_keys_internal( inp, NULL, 0, stats_handle, options);
 }
 
 static int
-import( IOBUF inp, const char* fname,
+import( iobuf_t inp, const char* fname,
        struct stats_s *stats, unsigned int options )
 {
     PACKET *pending_pkt = NULL;
@@ -220,7 +220,7 @@ import( IOBUF inp, const char* fname,
     getkey_disable_caches();
 
     if( !opt.no_armor ) { /* armored reading is not disabled */
-       armor_filter_context_t *afx = m_alloc_clear( sizeof *afx );
+       armor_filter_context_t *afx = xcalloc (1, sizeof *afx );
        afx->only_keyblocks = 1;
        iobuf_push_filter2( inp, armor_filter, afx, 1 );
     }
@@ -247,8 +247,8 @@ import( IOBUF inp, const char* fname,
     }
     if( rc == -1 )
        rc = 0;
-    else if( rc && rc != G10ERR_INV_KEYRING )
-       log_error( _("error reading `%s': %s\n"), fname, g10_errstr(rc));
+    else if( rc && rc != GPG_ERR_INV_KEYRING )
+       log_error( _("error reading `%s': %s\n"), fname, gpg_strerror (rc));
 
     return rc;
 }
@@ -321,7 +321,7 @@ import_print_stats (void *hd)
  * Retunr: 0 = okay, -1 no more blocks or another errorcode.
  */
 static int
-read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
+read_block( iobuf_t a, PACKET **pending_pkt, KBNODE *ret_root )
 {
     int rc;
     PACKET *pkt;
@@ -335,13 +335,13 @@ read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
     }
     else
        in_cert = 0;
-    pkt = m_alloc( sizeof *pkt );
+    pkt = xmalloc ( sizeof *pkt );
     init_packet(pkt);
     while( (rc=parse_packet(a, pkt)) != -1 ) {
        if( rc ) {  /* ignore errors */
-           if( rc != G10ERR_UNKNOWN_PACKET ) {
-               log_error("read_block: read error: %s\n", g10_errstr(rc) );
-               rc = G10ERR_INV_KEYRING;
+           if( rc != GPG_ERR_UNKNOWN_PACKET ) {
+               log_error("read_block: read error: %s\n", gpg_strerror (rc) );
+               rc = GPG_ERR_INV_KEYRING;
                goto ready;
            }
            free_packet( pkt );
@@ -363,11 +363,11 @@ read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
          case PKT_COMPRESSED:
            if( pkt->pkt.compressed->algorithm < 1
                || pkt->pkt.compressed->algorithm > 2 ) {
-               rc = G10ERR_COMPR_ALGO;
+               rc = GPG_ERR_COMPR_ALGO;
                goto ready;
            }
            {
-               compress_filter_context_t *cfx = m_alloc_clear( sizeof *cfx );
+               compress_filter_context_t *cfx = xcalloc (1, sizeof *cfx );
                cfx->algo = pkt->pkt.compressed->algorithm;
                pkt->pkt.compressed->buf = NULL;
                iobuf_push_filter2( a, compress_filter, cfx, 1 );
@@ -396,7 +396,7 @@ read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
                    root = new_kbnode( pkt );
                else
                    add_kbnode( root, new_kbnode( pkt ) );
-               pkt = m_alloc( sizeof *pkt );
+               pkt = xmalloc ( sizeof *pkt );
            }
            init_packet(pkt);
            break;
@@ -411,7 +411,7 @@ read_block( IOBUF a, PACKET **pending_pkt, KBNODE *ret_root )
     else
        *ret_root = root;
     free_packet( pkt );
-    m_free( pkt );
+    xfree ( pkt );
     return rc;
 }
 
@@ -513,7 +513,7 @@ print_import_check (PKT_public_key * pk, PKT_user_id * id)
     u32 keyid[2];
     size_t i, pos = 0, n;
 
-    buf = m_alloc (17+41+id->len+32);
+    buf = xmalloc (17+41+id->len+32);
     keyid_from_pk (pk, keyid);
     sprintf (buf, "%08X%08X ", keyid[0], keyid[1]);
     pos = 17;
@@ -524,7 +524,7 @@ print_import_check (PKT_public_key * pk, PKT_user_id * id)
     pos += 1;
     strcat (buf, id->name);
     write_status_text (STATUS_IMPORT_CHECK, buf);
-    m_free (buf);
+    xfree (buf);
 }
 
 /****************
@@ -607,7 +607,7 @@ import_one( const char *fname, KBNODE keyblock,
            node->flag |= 1;
            log_info( _("key %08lX: accepted non self-signed user ID '%s'\n"),
                      (ulong)keyid[1],user);
-           m_free(user);
+           xfree (user);
          }
 
     if( !delete_inv_parts( fname, keyblock, keyid, options ) ) {
@@ -621,11 +621,12 @@ import_one( const char *fname, KBNODE keyblock,
     }
 
     /* do we have this key already in one of our pubrings ? */
-    pk_orig = m_alloc_clear( sizeof *pk_orig );
+    pk_orig = xcalloc (1, sizeof *pk_orig );
     rc = get_pubkey_fast ( pk_orig, keyid );
-    if( rc && rc != G10ERR_NO_PUBKEY && rc != G10ERR_UNU_PUBKEY ) {
+    if( rc && gpg_err_code (rc) != GPG_ERR_NO_PUBKEY
+        && gpg_err_code (rc) != GPG_ERR_UNUSABLE_PUBKEY ) {
        log_error( _("key %08lX: public key not found: %s\n"),
-                               (ulong)keyid[1], g10_errstr(rc));
+                               (ulong)keyid[1], gpg_strerror (rc));
     }
     else if ( rc && opt.merge_only ) {
        if( opt.verbose )
@@ -638,16 +639,16 @@ import_one( const char *fname, KBNODE keyblock,
 
         rc = keydb_locate_writable (hd, NULL);
        if (rc) {
-           log_error (_("no writable keyring found: %s\n"), g10_errstr (rc));
+           log_error (_("no writable keyring found: %s\n"), gpg_strerror (rc));
             keydb_release (hd);
-           return G10ERR_GENERAL;
+           return GPG_ERR_GENERAL;
        }
        if( opt.verbose > 1 )
            log_info (_("writing to `%s'\n"), keydb_get_resource_name (hd) );
        rc = keydb_insert_keyblock (hd, keyblock );
         if (rc)
           log_error (_("error writing keyring `%s': %s\n"),
-                      keydb_get_resource_name (hd), g10_errstr(rc));
+                      keydb_get_resource_name (hd), gpg_strerror (rc));
        else
          {
            /* This should not be possible since we delete the
@@ -666,12 +667,12 @@ import_one( const char *fname, KBNODE keyblock,
            char *p=get_user_id_printable (keyid);
            log_info( _("key %08lX: public key \"%s\" imported\n"),
                      (ulong)keyid[1],p);
-           m_free(p);
+           xfree (p);
        }
        if( is_status_enabled() ) {
            char *us = get_long_user_id_string( keyid );
            write_status_text( STATUS_IMPORTED, us );
-           m_free(us);
+           xfree (us);
             print_import_ok (pk,NULL, 1);
        }
        stats->imported++;
@@ -704,14 +705,14 @@ import_one( const char *fname, KBNODE keyblock,
         }
        if( rc ) {
            log_error (_("key %08lX: can't locate original keyblock: %s\n"),
-                                    (ulong)keyid[1], g10_errstr(rc));
+                                    (ulong)keyid[1], gpg_strerror (rc));
             keydb_release (hd);
            goto leave;
        }
        rc = keydb_get_keyblock (hd, &keyblock_orig );
        if (rc) {
            log_error (_("key %08lX: can't read original keyblock: %s\n"),
-                                           (ulong)keyid[1], g10_errstr(rc));
+                                           (ulong)keyid[1], gpg_strerror (rc));
             keydb_release (hd);
            goto leave;
        }
@@ -733,7 +734,7 @@ import_one( const char *fname, KBNODE keyblock,
            rc = keydb_update_keyblock (hd, keyblock_orig);
             if (rc)
                log_error (_("error writing keyring `%s': %s\n"),
-                            keydb_get_resource_name (hd), g10_errstr(rc) );
+                            keydb_get_resource_name (hd), gpg_strerror (rc) );
            else if(non_self)
              revalidation_mark ();
 
@@ -758,7 +759,7 @@ import_one( const char *fname, KBNODE keyblock,
                else if( n_subk )
                    log_info( _("key %08lX: \"%s\" %d new subkeys\n"),
                                             (ulong)keyid[1], p, n_subk );
-               m_free(p);
+               xfree (p);
            }
 
            stats->n_uids +=n_uids;
@@ -777,7 +778,7 @@ import_one( const char *fname, KBNODE keyblock,
                char *p=get_user_id_printable(keyid);
                log_info( _("key %08lX: \"%s\" not changed\n"),
                          (ulong)keyid[1],p);
-               m_free(p);
+               xfree (p);
            }
            stats->unchanged++;
        }
@@ -810,8 +811,8 @@ sec_to_pub_keyblock(KBNODE sec_keyblock)
             write the keyblock out. */
 
          PKT_secret_key *sk=secnode->pkt->pkt.secret_key;
-         PACKET *pkt=m_alloc_clear(sizeof(PACKET));
-         PKT_public_key *pk=m_alloc_clear(sizeof(PKT_public_key));
+         PACKET *pkt=xcalloc (1,sizeof(PACKET));
+         PKT_public_key *pk=xcalloc (1,sizeof(PKT_public_key));
          int n;
 
          if(secnode->pkt->pkttype==PKT_SECRET_KEY)
@@ -905,20 +906,20 @@ import_secret_one( const char *fname, KBNODE keyblock,
 
     /* do we have this key already in one of our secrings ? */
     rc = seckey_available( keyid );
-    if( rc == G10ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
+    if( rc == GPG_ERR_NO_SECKEY && !opt.merge_only ) { /* simply insert this key */
         KEYDB_HANDLE hd = keydb_new (1);
 
        /* get default resource */
         rc = keydb_locate_writable (hd, NULL);
        if (rc) {
-           log_error (_("no default secret keyring: %s\n"), g10_errstr (rc));
+           log_error (_("no default secret keyring: %s\n"), gpg_strerror (rc));
             keydb_release (hd);
-           return G10ERR_GENERAL;
+           return GPG_ERR_GENERAL;
        }
        rc = keydb_insert_keyblock (hd, keyblock );
         if (rc)
            log_error (_("error writing keyring `%s': %s\n"),
-                       keydb_get_resource_name (hd), g10_errstr(rc) );
+                       keydb_get_resource_name (hd), gpg_strerror (rc) );
         keydb_release (hd);
        /* we are ready */
        if( !opt.quiet )
@@ -949,7 +950,7 @@ import_secret_one( const char *fname, KBNODE keyblock,
     }
     else
        log_error( _("key %08lX: secret key not found: %s\n"),
-                               (ulong)keyid[1], g10_errstr(rc));
+                               (ulong)keyid[1], gpg_strerror (rc));
 
     return rc;
 }
@@ -974,9 +975,9 @@ import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
     keyid[0] = node->pkt->pkt.signature->keyid[0];
     keyid[1] = node->pkt->pkt.signature->keyid[1];
 
-    pk = m_alloc_clear( sizeof *pk );
+    pk = xcalloc (1, sizeof *pk );
     rc = get_pubkey( pk, keyid );
-    if( rc == G10ERR_NO_PUBKEY ) {
+    if( rc == GPG_ERR_NO_PUBKEY ) {
        log_info( _("key %08lX: no public key - "
                 "can't apply revocation certificate\n"), (ulong)keyid[1]);
        rc = 0;
@@ -984,7 +985,7 @@ import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
     }
     else if( rc ) {
        log_error( _("key %08lX: public key not found: %s\n"),
-                                      (ulong)keyid[1], g10_errstr(rc));
+                                      (ulong)keyid[1], gpg_strerror (rc));
        goto leave;
     }
 
@@ -1001,13 +1002,13 @@ import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
     }
     if (rc) {
        log_error (_("key %08lX: can't locate original keyblock: %s\n"),
-                   (ulong)keyid[1], g10_errstr(rc));
+                   (ulong)keyid[1], gpg_strerror (rc));
        goto leave;
     }
     rc = keydb_get_keyblock (hd, &keyblock );
     if (rc) {
        log_error (_("key %08lX: can't read original keyblock: %s\n"),
-                   (ulong)keyid[1], g10_errstr(rc));
+                   (ulong)keyid[1], gpg_strerror (rc));
        goto leave;
     }
 
@@ -1018,7 +1019,7 @@ import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
     rc = check_key_signature( keyblock, node, NULL);
     if( rc ) {
        log_error( _("key %08lX: invalid revocation certificate"
-                 ": %s - rejected\n"), (ulong)keyid[1], g10_errstr(rc));
+                 ": %s - rejected\n"), (ulong)keyid[1], gpg_strerror (rc));
        goto leave;
     }
 
@@ -1044,14 +1045,14 @@ import_revoke_cert( const char *fname, KBNODE node, struct stats_s *stats )
     rc = keydb_update_keyblock (hd, keyblock );
     if (rc)
        log_error (_("error writing keyring `%s': %s\n"),
-                   keydb_get_resource_name (hd), g10_errstr(rc) );
+                   keydb_get_resource_name (hd), gpg_strerror (rc) );
     keydb_release (hd); hd = NULL;
     /* we are ready */
     if( !opt.quiet ) {
         char *p=get_user_id_printable (keyid);
        log_info( _("key %08lX: \"%s\" revocation certificate imported\n"),
                                        (ulong)keyid[1],p);
-       m_free(p);
+       xfree (p);
     }
     stats->n_revoc++;
 
@@ -1125,13 +1126,13 @@ chk_self_sigs( const char *fname, KBNODE keyblock,
                    {
                      char *p=utf8_to_native(unode->pkt->pkt.user_id->name,
                                      strlen(unode->pkt->pkt.user_id->name),0);
-                     log_info( rc == G10ERR_PUBKEY_ALGO ?
+                     log_info( rc == GPG_ERR_PUBKEY_ALGO ?
                                _("key %08lX: unsupported public key "
                                  "algorithm on user id \"%s\"\n"):
                                _("key %08lX: invalid self-signature "
                                  "on user id \"%s\"\n"),
                                (ulong)keyid[1],p);
-                     m_free(p);
+                     xfree (p);
                    }
                  else
                    unode->flag |= 1; /* mark that signature checked */
@@ -1150,7 +1151,7 @@ chk_self_sigs( const char *fname, KBNODE keyblock,
                else {
                  rc = check_key_signature( keyblock, n, NULL);
                  if( rc ) {
-                   log_info(  rc == G10ERR_PUBKEY_ALGO ?
+                   log_info(  rc == GPG_ERR_PUBKEY_ALGO ?
                            _("key %08lX: unsupported public key algorithm\n"):
                            _("key %08lX: invalid subkey binding\n"),
                            (ulong)keyid[1]);
@@ -1191,7 +1192,7 @@ chk_self_sigs( const char *fname, KBNODE keyblock,
                else {
                  rc = check_key_signature( keyblock, n, NULL);
                  if( rc ) {
-                   log_info(  rc == G10ERR_PUBKEY_ALGO ?
+                   log_info(  rc == GPG_ERR_PUBKEY_ALGO ?
                            _("key %08lX: unsupported public key algorithm\n"):
                            _("key %08lX: invalid subkey revocation\n"),
                               (ulong)keyid[1]);
@@ -1281,7 +1282,8 @@ delete_inv_parts( const char *fname, KBNODE keyblock,
              subkey_seen = 1;
        }
        else if( node->pkt->pkttype == PKT_SIGNATURE
-                && check_pubkey_algo( node->pkt->pkt.signature->pubkey_algo)
+                && openpgp_pk_test_algo( node->pkt->pkt.signature
+                                                     ->pubkey_algo, 0)
                 && node->pkt->pkt.signature->pubkey_algo != PUBKEY_ALGO_RSA )
            delete_kbnode( node ); /* build_packet() can't handle this */
        else if( node->pkt->pkttype == PKT_SIGNATURE &&
@@ -1320,7 +1322,7 @@ delete_inv_parts( const char *fname, KBNODE keyblock,
                    {
                      log_error( _("key %08lX: invalid revocation "
                                   "certificate: %s - skipped\n"),
-                                (ulong)keyid[1], g10_errstr(rc));
+                                (ulong)keyid[1], gpg_strerror (rc));
                      delete_kbnode( node );
                    }
                }
@@ -1489,7 +1491,8 @@ revocation_present(KBNODE keyblock)
 
                      rc=get_pubkey_byfprint_fast (NULL,sig->revkey[idx]->fpr,
                                                    MAX_FINGERPRINT_LEN);
-                     if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
+                     if ( gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
+                          || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
                        {
                          /* No, so try and get it */
                          if(opt.keyserver_scheme &&
@@ -1508,7 +1511,8 @@ revocation_present(KBNODE keyblock)
                                                     MAX_FINGERPRINT_LEN);
                            }
 
-                         if(rc==G10ERR_NO_PUBKEY || rc==G10ERR_UNU_PUBKEY)
+                         if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY
+                              || gpg_err_code (rc) == GPG_ERR_UNUSABLE_PUBKEY)
                            log_info(_("WARNING: key %08lX may be revoked: "
                                       "revocation key %08lX not present.\n"),
                                     (ulong)keyid_from_pk(pk,NULL),
@@ -1568,7 +1572,7 @@ merge_blocks( const char *fname, KBNODE keyblock_orig, KBNODE keyblock,
                 ++*n_sigs;
                log_info(_("key %08lX: \"%s\" revocation certificate added\n"),
                                         (ulong)keyid[1],p);
-               m_free(p);
+               xfree (p);
            }
        }
     }
index 5df6d8d..58daad8 100644 (file)
@@ -23,6 +23,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
+
+#include "gpg.h"
 #include "util.h"
 #include "memory.h"
 #include "packet.h"
@@ -41,7 +43,7 @@ alloc_node(void)
     if( n )
        unused_nodes = n->next;
     else
-       n = m_alloc( sizeof *n );
+       n = xmalloc ( sizeof *n );
     n->next = NULL;
     n->pkt = NULL;
     n->flag = 0;
@@ -58,7 +60,7 @@ free_node( KBNODE n )
        n->next = unused_nodes;
        unused_nodes = n;
 #else
-       m_free( n );
+       xfree ( n );
 #endif
     }
 }
@@ -94,7 +96,7 @@ release_kbnode( KBNODE n )
        n2 = n->next;
        if( !is_cloned_kbnode(n) ) {
            free_packet( n->pkt );
-           m_free( n->pkt );
+           xfree ( n->pkt );
        }
        free_node( n );
        n = n2;
@@ -267,7 +269,7 @@ commit_kbnode( KBNODE *root )
                nl->next = n->next;
            if( !is_cloned_kbnode(n) ) {
                free_packet( n->pkt );
-               m_free( n->pkt );
+               xfree ( n->pkt );
            }
            free_node( n );
            changed = 1;
@@ -291,7 +293,7 @@ remove_kbnode( KBNODE *root, KBNODE node )
                nl->next = n->next;
            if( !is_cloned_kbnode(n) ) {
                free_packet( n->pkt );
-               m_free( n->pkt );
+               xfree ( n->pkt );
            }
            free_node( n );
        }
index c67c361..b64f38c 100644 (file)
@@ -28,6 +28,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
+#include "gpg.h"
 #include "util.h"
 #include "options.h"
 #include "main.h" /*try_make_homedir ()*/
@@ -84,7 +85,7 @@ keydb_add_resource (const char *url, int flags, int secret)
 {
     static int any_secret, any_public;
     const char *resname = url;
-    IOBUF iobuf = NULL;
+    iobuf_t iobuf = NULL;
     char *filename = NULL;
     int force=(flags&1);
     int rc = 0;
@@ -103,7 +104,7 @@ keydb_add_resource (const char *url, int flags, int secret)
 #if !defined(HAVE_DRIVE_LETTERS) && !defined(__riscos__)
        else if (strchr (resname, ':')) {
            log_error ("invalid key resource URL `%s'\n", url );
-           rc = G10ERR_GENERAL;
+           rc = GPG_ERR_GENERAL;
            goto leave;
        }
 #endif /* !HAVE_DRIVE_LETTERS && !__riscos__ */
@@ -116,7 +117,7 @@ keydb_add_resource (const char *url, int flags, int secret)
            filename = make_filename (opt.homedir, resname, NULL);
     }
     else
-       filename = m_strdup (resname);
+       filename = xstrdup (resname);
 
     if (!force)
        force = secret? !any_secret : !any_public;
@@ -145,7 +146,7 @@ keydb_add_resource (const char *url, int flags, int secret)
     switch (rt) {
       case KEYDB_RESOURCE_TYPE_NONE:
        log_error ("unknown type of key resource `%s'\n", url );
-       rc = G10ERR_GENERAL;
+       rc = GPG_ERR_GENERAL;
        goto leave;
 
       case KEYDB_RESOURCE_TYPE_KEYRING:
@@ -156,7 +157,7 @@ keydb_add_resource (const char *url, int flags, int secret)
 
             if (!force) 
               {
-                rc = G10ERR_OPEN_FILE;
+                rc = gpg_error_from_errno (errno);
                 goto leave;
               }
 
@@ -174,7 +175,7 @@ keydb_add_resource (const char *url, int flags, int secret)
                   }
                if (access (filename, F_OK))
                   {
-                    rc = G10ERR_OPEN_FILE;
+                    rc = gpg_error_from_errno (errno);
                     *last_slash_in_filename = DIRSEP_C;
                     goto leave;
                   }
@@ -188,7 +189,7 @@ keydb_add_resource (const char *url, int flags, int secret)
               {
                log_error ( _("error creating keyring `%s': %s\n"),
                             filename, strerror(errno));
-               rc = G10ERR_OPEN_FILE;
+                rc = gpg_error_from_errno (errno);
                goto leave;
               }
 
@@ -203,7 +204,7 @@ keydb_add_resource (const char *url, int flags, int secret)
         if(keyring_register_filename (filename, secret, &token))
          {
            if (used_resources >= MAX_KEYDB_RESOURCES)
-             rc = G10ERR_RESOURCE_LIMIT;
+             rc = GPG_ERR_RESOURCE_LIMIT;
            else 
              {
                if(flags&2)
@@ -227,7 +228,7 @@ keydb_add_resource (const char *url, int flags, int secret)
 
       default:
        log_error ("resource type of `%s' not supported\n", url);
-       rc = G10ERR_GENERAL;
+       rc = GPG_ERR_GENERAL;
        goto leave;
     }
 
@@ -235,12 +236,12 @@ keydb_add_resource (const char *url, int flags, int secret)
 
   leave:
     if (rc)
-       log_error ("keyblock resource `%s': %s\n", filename, g10_errstr(rc));
+       log_error ("keyblock resource `%s': %s\n", filename, gpg_strerror (rc));
     else if (secret)
        any_secret = 1;
     else
        any_public = 1;
-    m_free (filename);
+    xfree (filename);
     return rc;
 }
 
@@ -253,7 +254,7 @@ keydb_new (int secret)
   KEYDB_HANDLE hd;
   int i, j;
   
-  hd = m_alloc_clear (sizeof *hd);
+  hd = xcalloc (1,sizeof *hd);
   hd->found = -1;
   
   assert (used_resources <= MAX_KEYDB_RESOURCES);
@@ -271,7 +272,7 @@ keydb_new (int secret)
           hd->active[j].secret = all_resources[i].secret;
           hd->active[j].u.kr = keyring_new (all_resources[i].token, secret);
           if (!hd->active[j].u.kr) {
-            m_free (hd);
+            xfree (hd);
             return NULL; /* fixme: release all previously allocated handles*/
           }
           j++;
@@ -305,7 +306,7 @@ keydb_release (KEYDB_HANDLE hd)
         }
     }
 
-    m_free (hd);
+    xfree (hd);
 }
 
 
@@ -413,14 +414,14 @@ keydb_get_keyblock (KEYDB_HANDLE hd, KBNODE *ret_kb)
     int rc = 0;
 
     if (!hd)
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     if ( hd->found < 0 || hd->found >= hd->used) 
         return -1; /* nothing found */
 
     switch (hd->active[hd->found].type) {
       case KEYDB_RESOURCE_TYPE_NONE:
-        rc = G10ERR_GENERAL; /* oops */
+        rc = GPG_ERR_GENERAL; /* oops */
         break;
       case KEYDB_RESOURCE_TYPE_KEYRING:
         rc = keyring_get_keyblock (hd->active[hd->found].u.kr, ret_kb);
@@ -439,7 +440,7 @@ keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
     int rc = 0;
 
     if (!hd)
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     if ( hd->found < 0 || hd->found >= hd->used) 
         return -1; /* nothing found */
@@ -453,7 +454,7 @@ keydb_update_keyblock (KEYDB_HANDLE hd, KBNODE kb)
 
     switch (hd->active[hd->found].type) {
       case KEYDB_RESOURCE_TYPE_NONE:
-        rc = G10ERR_GENERAL; /* oops */
+        rc = GPG_ERR_GENERAL; /* oops */
         break;
       case KEYDB_RESOURCE_TYPE_KEYRING:
         rc = keyring_update_keyblock (hd->active[hd->found].u.kr, kb);
@@ -475,7 +476,7 @@ keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
     int idx;
 
     if (!hd) 
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     if( opt.dry_run )
        return 0;
@@ -485,7 +486,7 @@ keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
     else if ( hd->current >= 0 && hd->current < hd->used) 
         idx = hd->current;
     else
-        return G10ERR_GENERAL;
+        return GPG_ERR_GENERAL;
 
     rc = lock_all (hd);
     if (rc)
@@ -493,7 +494,7 @@ keydb_insert_keyblock (KEYDB_HANDLE hd, KBNODE kb)
 
     switch (hd->active[idx].type) {
       case KEYDB_RESOURCE_TYPE_NONE:
-        rc = G10ERR_GENERAL; /* oops */
+        rc = GPG_ERR_GENERAL; /* oops */
         break;
       case KEYDB_RESOURCE_TYPE_KEYRING:
         rc = keyring_insert_keyblock (hd->active[idx].u.kr, kb);
@@ -514,7 +515,7 @@ keydb_delete_keyblock (KEYDB_HANDLE hd)
     int rc = -1;
 
     if (!hd)
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     if ( hd->found < 0 || hd->found >= hd->used) 
         return -1; /* nothing found */
@@ -528,7 +529,7 @@ keydb_delete_keyblock (KEYDB_HANDLE hd)
 
     switch (hd->active[hd->found].type) {
       case KEYDB_RESOURCE_TYPE_NONE:
-        rc = G10ERR_GENERAL; /* oops */
+        rc = GPG_ERR_GENERAL; /* oops */
         break;
       case KEYDB_RESOURCE_TYPE_KEYRING:
         rc = keyring_delete_keyblock (hd->active[hd->found].u.kr);
@@ -551,7 +552,7 @@ keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
   int rc;
   
   if (!hd)
-    return G10ERR_INV_ARG;
+    return GPG_ERR_INV_ARG;
   
   rc = keydb_search_reset (hd); /* this does reset hd->current */
   if (rc)
@@ -613,7 +614,7 @@ keydb_rebuild_caches (void)
           rc = keyring_rebuild_cache (all_resources[i].token);
           if (rc)
             log_error (_("failed to rebuild keyring cache: %s\n"),
-                       g10_errstr (rc));
+                       gpg_strerror (rc));
           break;
         }
     }
@@ -630,7 +631,7 @@ keydb_search_reset (KEYDB_HANDLE hd)
     int i, rc = 0;
 
     if (!hd)
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     hd->current = 0; 
     hd->found = -1;
@@ -659,7 +660,7 @@ keydb_search2 (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc,
     int rc = -1;
 
     if (!hd)
-        return G10ERR_INV_ARG;
+        return GPG_ERR_INV_ARG;
 
     while (rc == -1 && hd->current >= 0 && hd->current < hd->used) {
         switch (hd->active[hd->current].type) {
index 7be5e7f..6652db3 100644 (file)
@@ -75,7 +75,7 @@ struct keyblock_pos_struct {
     enum resource_type rt;
     off_t offset;    /* position information */
     unsigned count;  /* length of the keyblock in packets */
-    IOBUF  fp;      /* used by enum_keyblocks */
+    iobuf_t  fp;            /* used by enum_keyblocks */
     int secret;      /* working on a secret keyring */
     PACKET *pkt;     /* ditto */
     int valid;
@@ -235,6 +235,7 @@ KEYDB_HANDLE get_ctx_handle(GETKEY_CTX ctx);
 
 /*-- keyid.c --*/
 int pubkey_letter( int algo );
+u32 v3_keyid (gcry_mpi_t a, u32 *ki);
 u32 keyid_from_sk( PKT_secret_key *sk, u32 *keyid );
 u32 keyid_from_pk( PKT_public_key *pk, u32 *keyid );
 u32 keyid_from_sig( PKT_signature *sig, u32 *keyid );
index d36623a..38248a3 100644 (file)
@@ -27,6 +27,7 @@
 #include <assert.h>
 #include <ctype.h>
 
+#include "gpg.h"
 #include "options.h"
 #include "packet.h"
 #include "errors.h"
@@ -107,19 +108,20 @@ print_and_check_one_sig( KBNODE keyblock, KBNODE node,
     /* TODO: Make sure a cached sig record here still has the pk that
        issued it.  See also keylist.c:list_keyblock_print */
 
-    switch( (rc = check_key_signature( keyblock, node, is_selfsig)) ) {
+    rc = check_key_signature (keyblock, node, is_selfsig);
+    switch ( gpg_err_code (rc) ) {
       case 0:
        node->flag &= ~(NODFLG_BADSIG|NODFLG_NOKEY|NODFLG_SIGERR);
        sigrc = '!';
        break;
-      case G10ERR_BAD_SIGN:
+      case GPG_ERR_BAD_SIGNATURE:
        node->flag = NODFLG_BADSIG;
        sigrc = '-';
        if( inv_sigs )
            ++*inv_sigs;
        break;
-      case G10ERR_NO_PUBKEY:
-      case G10ERR_UNU_PUBKEY:
+      case GPG_ERR_NO_PUBKEY:
+      case GPG_ERR_UNUSABLE_PUBKEY:
        node->flag = NODFLG_NOKEY;
        sigrc = '?';
        if( no_key )
@@ -146,7 +148,7 @@ print_and_check_one_sig( KBNODE keyblock, KBNODE node,
                   (sig->trust_depth>0)?'0'+sig->trust_depth:' ',
                   (ulong)sig->keyid[1], datestr_from_sig(sig));
        if( sigrc == '%' )
-           tty_printf("[%s] ", g10_errstr(rc) );
+           tty_printf("[%s] ", gpg_strerror (rc) );
        else if( sigrc == '?' )
            ;
        else if( *is_selfsig ) {
@@ -157,7 +159,7 @@ print_and_check_one_sig( KBNODE keyblock, KBNODE node,
            size_t n;
            char *p = get_user_id( sig->keyid, &n );
            tty_print_utf8_string2( p, n, 40 );
-           m_free(p);
+           xfree (p);
        }
        tty_printf("\n");
 
@@ -313,7 +315,7 @@ trustsig_prompt(byte *trust_value,byte *trust_depth,char **regexp)
        *trust_value=60;
       else if(p[0]=='2' && !p[1])
        *trust_value=120;
-      m_free(p);
+      xfree (p);
     }
 
   tty_printf("\n");
@@ -330,7 +332,7 @@ trustsig_prompt(byte *trust_value,byte *trust_depth,char **regexp)
       trim_spaces(p);
       cpr_kill_prompt();
       *trust_depth=atoi(p);
-      m_free(p);
+      xfree (p);
       if(*trust_depth<1 || *trust_depth>255)
        *trust_depth=0;
     }
@@ -351,7 +353,7 @@ trustsig_prompt(byte *trust_value,byte *trust_depth,char **regexp)
       char *q=p;
       int regexplen=100,ind;
 
-      *regexp=m_alloc(regexplen);
+      *regexp=xmalloc (regexplen);
 
       /* Now mangle the domain the user entered into a regexp.  To do
         this, \-escape everything that isn't alphanumeric, and attach
@@ -371,7 +373,7 @@ trustsig_prompt(byte *trust_value,byte *trust_depth,char **regexp)
          if((regexplen-ind)<3)
            {
              regexplen+=100;
-             *regexp=m_realloc(*regexp,regexplen);
+             *regexp=xrealloc(*regexp,regexplen);
            }
 
          q++;
@@ -381,7 +383,7 @@ trustsig_prompt(byte *trust_value,byte *trust_depth,char **regexp)
       strcat(*regexp,">$");
     }
 
-  m_free(p);
+  xfree (p);
   tty_printf("\n");
 }
 
@@ -504,7 +506,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                                     "self-signed.\n"),user);
                      }
 
-                   m_free(user);
+                   xfree (user);
                  }
            }
            else if( uidnode && node->pkt->pkttype == PKT_SIGNATURE
@@ -534,7 +536,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                            {
                              force_v4=1;
                              node->flag|=NODFLG_DELSIG;
-                             m_free(user);
+                             xfree (user);
                              continue;
                            }
                      }
@@ -558,7 +560,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                                in place. */
 
                            node->flag|=NODFLG_DELSIG;
-                           m_free(user);
+                           xfree (user);
                            continue;
                          }
                      }
@@ -583,7 +585,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                                in place. */
 
                            node->flag|=NODFLG_DELSIG;
-                           m_free(user);
+                           xfree (user);
                            continue;
                          }
                      }
@@ -606,7 +608,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                      {
                        /* Don't delete the old sig here since this is
                           an --expert thing. */
-                       m_free(user);
+                       xfree (user);
                        continue;
                      }
 
@@ -615,7 +617,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                     write_status_text (STATUS_ALREADY_SIGNED, buf);
                    uidnode->flag &= ~NODFLG_MARK_A; /* remove mark */
 
-                   m_free(user);
+                   xfree (user);
                }
            }
        }
@@ -675,7 +677,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                  }
 
                cpr_kill_prompt();
-               m_free(answer);
+               xfree (answer);
              }
          }
 
@@ -752,7 +754,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                    else
                      tty_printf(_("Invalid selection.\n"));
 
-                   m_free(answer);
+                   xfree (answer);
                  }
              }
 
@@ -764,7 +766,7 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                     "with your key: \""));
        p = get_user_id( sk_keyid, &n );
        tty_print_utf8_string( p, n );
-       m_free(p); p = NULL;
+       xfree (p); p = NULL;
        tty_printf("\" (%08lX)\n",(ulong)sk_keyid[1]);
 
        if(selfsig)
@@ -856,14 +858,14 @@ sign_uids( KBNODE keyblock, STRLIST locusr, int *ret_modified,
                                           timestamp, duration,
                                           sign_mk_attrib, &attrib );
                if( rc ) {
-                   log_error(_("signing failed: %s\n"), g10_errstr(rc));
+                   log_error(_("signing failed: %s\n"), gpg_strerror (rc));
                    goto leave;
                }
 
                *ret_modified = 1; /* we changed the keyblock */
                update_trust = 1;
 
-               pkt = m_alloc_clear( sizeof *pkt );
+               pkt = xcalloc (1, sizeof *pkt );
                pkt->pkttype = PKT_SIGNATURE;
                pkt->pkt.signature = sig;
                insert_kbnode( node, new_kbnode(pkt), PKT_SIGNATURE );
@@ -909,7 +911,7 @@ change_passphrase( KBNODE keyblock )
 
     switch( is_secret_key_protected( sk ) ) {
       case -1:
-       rc = G10ERR_PUBKEY_ALGO;
+       rc = GPG_ERR_PUBKEY_ALGO;
        break;
       case 0:
        tty_printf(_("This key is not protected.\n"));
@@ -940,10 +942,10 @@ change_passphrase( KBNODE keyblock )
     }
 
     if( rc )
-       tty_printf(_("Can't edit this key: %s\n"), g10_errstr(rc));
+       tty_printf(_("Can't edit this key: %s\n"), gpg_strerror (rc));
     else {
        DEK *dek = NULL;
-       STRING2KEY *s2k = m_alloc_secure( sizeof *s2k );
+       STRING2KEY *s2k = xmalloc_secure ( sizeof *s2k );
         const char *errtext = NULL;
 
        tty_printf(_("Enter the new passphrase for this secret key.\n\n") );
@@ -983,18 +985,18 @@ change_passphrase( KBNODE keyblock )
                    }
                }
                if( rc )
-                   log_error("protect_secret_key failed: %s\n", g10_errstr(rc) );
+                   log_error("protect_secret_key failed: %s\n", gpg_strerror (rc) );
                else
                    changed++;
                break;
            }
        }
-       m_free(s2k);
-       m_free(dek);
+       xfree (s2k);
+       xfree (dek);
     }
 
   leave:
-    m_free( passphrase );
+    xfree ( passphrase );
     set_next_passphrase( NULL );
     return changed && !rc;
 }
@@ -1172,7 +1174,7 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
            rc = keydb_get_keyblock (sec_kdbhd, &sec_keyblock);
            if (rc) {
                log_error (_("error reading secret keyblock `%s': %s\n"),
-                                               username, g10_errstr(rc));
+                                               username, gpg_strerror (rc));
            }
             else {
                 merge_keys_and_selfsig( sec_keyblock );
@@ -1207,14 +1209,14 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
            redisplay = 0;
        }
        do {
-           m_free(answer);
+           xfree (answer);
            if( have_commands ) {
                if( commands ) {
-                   answer = m_strdup( commands->d );
+                   answer = xstrdup ( commands->d );
                    commands = commands->next;
                }
                else if( opt.batch ) {
-                   answer = m_strdup("quit");
+                   answer = xstrdup ("quit");
                }
                else
                    have_commands = 0;
@@ -1543,7 +1545,7 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
              PKT_user_id *temp=keygen_get_std_prefs();
              tty_printf(_("Current preference list:\n"));
              show_prefs(temp,1);
-             m_free(temp);
+             xfree (temp);
             }
             if (cpr_get_answer_is_yes ("keyedit.updpref.okay",
                                         count_selected_uids (keyblock)?
@@ -1601,7 +1603,7 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
                if( modified ) {
                    rc = keydb_update_keyblock (kdbhd, keyblock);
                    if( rc ) {
-                       log_error(_("update failed: %s\n"), g10_errstr(rc) );
+                       log_error(_("update failed: %s\n"), gpg_strerror (rc) );
                        break;
                    }
                }
@@ -1609,7 +1611,7 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
                    rc = keydb_update_keyblock (sec_kdbhd, sec_keyblock );
                    if( rc ) {
                        log_error( _("update secret failed: %s\n"),
-                                   g10_errstr(rc) );
+                                   gpg_strerror (rc) );
                        break;
                    }
                }
@@ -1636,7 +1638,7 @@ keyedit_menu( const char *username, STRLIST locusr, STRLIST commands,
     release_kbnode( keyblock );
     release_kbnode( sec_keyblock );
     keydb_release (kdbhd);
-    m_free(answer);
+    xfree (answer);
 }
 
 
@@ -1666,7 +1668,7 @@ show_prefs (PKT_user_id *uid, int verbose)
        tty_printf (_("Cipher: "));
         for(i=any=0; prefs[i].type; i++ ) {
             if( prefs[i].type == PREFTYPE_SYM ) {
-                const char *s = cipher_algo_to_string (prefs[i].value);
+                const char *s = gcry_cipher_algo_name (prefs[i].value);
                 
                 if (any)
                     tty_printf (", ");
@@ -1683,13 +1685,13 @@ show_prefs (PKT_user_id *uid, int verbose)
         if (!des_seen) {
             if (any)
                 tty_printf (", ");
-            tty_printf ("%s",cipher_algo_to_string(CIPHER_ALGO_3DES));
+            tty_printf ("%s", gcry_cipher_algo_name (CIPHER_ALGO_3DES));
         }
         tty_printf ("\n     ");
        tty_printf (_("Digest: "));
         for(i=any=0; prefs[i].type; i++ ) {
             if( prefs[i].type == PREFTYPE_HASH ) {
-                const char *s = digest_algo_to_string (prefs[i].value);
+                const char *s = gcry_md_algo_name (prefs[i].value);
                 
                 if (any)
                     tty_printf (", ");
@@ -1706,7 +1708,7 @@ show_prefs (PKT_user_id *uid, int verbose)
         if (!sha1_seen) {
             if (any)
                 tty_printf (", ");
-            tty_printf ("%s",digest_algo_to_string(DIGEST_ALGO_SHA1));
+            tty_printf ("%s", gcry_md_algo_name (DIGEST_ALGO_SHA1));
         }
         tty_printf ("\n     ");
        tty_printf (_("Compression: "));
@@ -1984,7 +1986,7 @@ show_key_with_all_names( KBNODE keyblock, int only_marked, int with_revoker,
                         u32 r_keyid[2];
                         char *user;
                        const char *algo=
-                         pubkey_algo_to_string(pk->revkey[i].algid);
+                                  gcry_pk_algo_name (pk->revkey[i].algid);
 
                         keyid_from_fingerprint(pk->revkey[i].fpr,
                                                MAX_FINGERPRINT_LEN,r_keyid);
@@ -1996,7 +1998,7 @@ show_key_with_all_names( KBNODE keyblock, int only_marked, int with_revoker,
                         if ((pk->revkey[i].class&0x40))
                           tty_printf (_(" (sensitive)"));
                         tty_printf ("\n");
-                        m_free(user);
+                        xfree (user);
                       }
             }
 
@@ -2052,11 +2054,11 @@ show_key_with_all_names( KBNODE keyblock, int only_marked, int with_revoker,
            if( !rc )
                tty_printf( _("rev! subkey has been revoked: %s\n"),
                            datestr_from_sig( sig ) );
-           else if( rc == G10ERR_BAD_SIGN )
+           else if( gpg_err_code (rc) == GPG_ERR_BAD_SIGNATURE )
                tty_printf( _("rev- faked revocation found\n") );
            else if( rc )
                tty_printf( _("rev? problem checking revocation: %s\n"),
-                                                        g10_errstr(rc) );
+                                                        gpg_strerror (rc) );
        }
     }
     /* the user ids */
@@ -2311,13 +2313,13 @@ menu_adduid( KBNODE pub_keyblock, KBNODE sec_keyblock, int photo)
                             keygen_add_std_prefs, pk );
     free_secret_key( sk );
     if( rc ) {
-       log_error("signing failed: %s\n", g10_errstr(rc) );
+       log_error("signing failed: %s\n", gpg_strerror (rc) );
        free_user_id(uid);
        return 0;
     }
 
     /* insert/append to secret keyblock */
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_USER_ID;
     pkt->pkt.user_id = scopy_user_id(uid);
     node = new_kbnode(pkt);
@@ -2325,7 +2327,7 @@ menu_adduid( KBNODE pub_keyblock, KBNODE sec_keyblock, int photo)
        insert_kbnode( sec_where, node, 0 );
     else
        add_kbnode( sec_keyblock, node );
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = copy_signature(NULL, sig);
     if( sec_where )
@@ -2333,7 +2335,7 @@ menu_adduid( KBNODE pub_keyblock, KBNODE sec_keyblock, int photo)
     else
        add_kbnode( sec_keyblock, new_kbnode(pkt) );
     /* insert/append to public keyblock */
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_USER_ID;
     pkt->pkt.user_id = uid;
     node = new_kbnode(pkt);
@@ -2341,7 +2343,7 @@ menu_adduid( KBNODE pub_keyblock, KBNODE sec_keyblock, int photo)
        insert_kbnode( pub_where, node, 0 );
     else
        add_kbnode( pub_keyblock, node );
-    pkt = m_alloc_clear( sizeof *pkt );
+    pkt = xcalloc (1, sizeof *pkt );
     pkt->pkttype = PKT_SIGNATURE;
     pkt->pkt.signature = copy_signature(NULL, sig);
     if( pub_where )
@@ -2586,7 +2588,7 @@ menu_addrevoker( KBNODE pub_keyblock, KBNODE sec_keyblock, int sensitive )
       if(revoker_pk)
        free_public_key(revoker_pk);
 
-      revoker_pk=m_alloc_clear(sizeof(*revoker_pk));
+      revoker_pk=xcalloc (1,sizeof(*revoker_pk));
 
       tty_printf("\n");
 
@@ -2599,7 +2601,7 @@ menu_addrevoker( KBNODE pub_keyblock, KBNODE sec_keyblock, int sensitive )
 
       if(rc)
        {
-         log_error (_("key `%s' not found: %s\n"),answer,g10_errstr(rc));
+         log_error (_("key `%s' not found: %s\n"),answer,gpg_strerror (rc));
          continue;
        }
 
@@ -2667,7 +2669,7 @@ menu_addrevoker( KBNODE pub_keyblock, KBNODE sec_keyblock, int sensitive )
 
       p = get_user_id( keyid, &n );
       tty_print_utf8_string( p, n );
-      m_free(p);
+      xfree (p);
       tty_printf("\n");
       print_fingerprint(revoker_pk,NULL,2);
       tty_printf("\n");
@@ -2693,7 +2695,7 @@ menu_addrevoker( KBNODE pub_keyblock, KBNODE sec_keyblock, int sensitive )
                           keygen_add_revkey,&revkey );
   if( rc )
     {
-      log_error("signing failed: %s\n", g10_errstr(rc) );
+      log_error("signing failed: %s\n", gpg_strerror (rc) );
       goto fail;
     }
 
@@ -2701,13 +2703,13 @@ menu_addrevoker( KBNODE pub_keyblock, KBNODE sec_keyblock, int sensitive )
   sk=NULL;
 
   /* insert into secret keyblock */
-  pkt = m_alloc_clear( sizeof *pkt );
+  pkt = xcalloc (1, sizeof *pkt );
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = copy_signature(NULL, sig);
   insert_kbnode( sec_keyblock, new_kbnode(pkt), PKT_SIGNATURE );
 
   /* insert into public keyblock */
-  pkt = m_alloc_clear( sizeof *pkt );
+  pkt = xcalloc (1, sizeof *pkt );
   pkt->pkttype = PKT_SIGNATURE;
   pkt->pkt.signature = sig;
   insert_kbnode( pub_keyblock, new_kbnode(pkt), PKT_SIGNATURE );
@@ -2821,23 +2823,23 @@ menu_expire( KBNODE pub_keyblock, KBNODE sec_keyblock )
                                            sk, keygen_add_key_expire, sub_pk );
                if( rc ) {
                    log_error("make_keysig_packet failed: %s\n",
-                                                   g10_errstr(rc));
+                                                   gpg_strerror (rc));
                    free_secret_key( sk );
                    return 0;
                }
                /* replace the packet */
-               newpkt = m_alloc_clear( sizeof *newpkt );
+               newpkt = xcalloc (1, sizeof *newpkt );
                newpkt->pkttype = PKT_SIGNATURE;
                newpkt->pkt.signature = newsig;
                free_packet( node->pkt );
-               m_free( node->pkt );
+               xfree ( node->pkt );
                node->pkt = newpkt;
                if( sn ) {
-                   newpkt = m_alloc_clear( sizeof *newpkt );
+                   newpkt = xcalloc (1, sizeof *newpkt );
                    newpkt->pkttype = PKT_SIGNATURE;
                    newpkt->pkt.signature = copy_signature( NULL, newsig );
                    free_packet( sn->pkt );
-                   m_free( sn->pkt );
+                   xfree ( sn->pkt );
                    sn->pkt = newpkt;
                }
                sub_pk = NULL;
@@ -2930,7 +2932,7 @@ menu_set_primary_uid ( KBNODE pub_keyblock, KBNODE sec_keyblock )
 
                log_info(_("skipping v3 self-signature on user id \"%s\"\n"),
                         user);
-               m_free(user);
+               xfree (user);
              }
              else {
                /* This is a selfsignature which is to be replaced.
@@ -2969,16 +2971,16 @@ menu_set_primary_uid ( KBNODE pub_keyblock, KBNODE sec_keyblock )
                                                action > 0? "x":NULL );
                     if( rc ) {
                         log_error ("update_keysig_packet failed: %s\n",
-                                   g10_errstr(rc));
+                                   gpg_strerror (rc));
                         free_secret_key( sk );
                         return 0;
                     }
                     /* replace the packet */
-                    newpkt = m_alloc_clear( sizeof *newpkt );
+                    newpkt = xcalloc (1, sizeof *newpkt );
                     newpkt->pkttype = PKT_SIGNATURE;
                     newpkt->pkt.signature = newsig;
                     free_packet( node->pkt );
-                    m_free( node->pkt );
+                    xfree ( node->pkt );
                     node->pkt = newpkt;
                     modified = 1;
                }
@@ -3039,7 +3041,7 @@ menu_set_preferences (KBNODE pub_keyblock, KBNODE sec_keyblock )
 
                log_info(_("skipping v3 self-signature on user id \"%s\"\n"),
                         user);
-               m_free(user);
+               xfree (user);
              }
              else {
                /* This is a selfsignature which is to be replaced 
@@ -3056,16 +3058,16 @@ menu_set_preferences (KBNODE pub_keyblock, KBNODE sec_keyblock )
                                            NULL );
                 if( rc ) {
                     log_error ("update_keysig_packet failed: %s\n",
-                               g10_errstr(rc));
+                               gpg_strerror (rc));
                     free_secret_key( sk );
                     return 0;
                 }
                 /* replace the packet */
-                newpkt = m_alloc_clear( sizeof *newpkt );
+                newpkt = xcalloc (1, sizeof *newpkt );
                 newpkt->pkttype = PKT_SIGNATURE;
                 newpkt->pkt.signature = newsig;
                 free_packet( node->pkt );
-                m_free( node->pkt );
+                xfree ( node->pkt );
                 node->pkt = newpkt;
                 modified = 1;
              }
@@ -3397,7 +3399,7 @@ menu_revsig( KBNODE keyblock )
        attrib.non_exportable=!node->pkt->pkt.signature->flags.exportable;
 
        node->flag &= ~NODFLG_MARK_A;
-       sk = m_alloc_secure_clear( sizeof *sk );
+       sk = xcalloc_secure (1, sizeof *sk );
        if( get_seckey( sk, node->pkt->pkt.signature->keyid ) ) {
            log_info(_("no secret key\n"));
            continue;
@@ -3411,7 +3413,7 @@ menu_revsig( KBNODE keyblock )
                                       &attrib );
        free_secret_key(sk);
        if( rc ) {
-           log_error(_("signing failed: %s\n"), g10_errstr(rc));
+           log_error(_("signing failed: %s\n"), gpg_strerror (rc));
            release_revocation_reason_info( reason );
            return changed;
        }
@@ -3421,7 +3423,7 @@ menu_revsig( KBNODE keyblock )
        if(primary_pk->keyid[0]==sig->keyid[0] &&
           primary_pk->keyid[1]==sig->keyid[1])
          unode->pkt->pkt.user_id->is_revoked=1;
-       pkt = m_alloc_clear( sizeof *pkt );
+       pkt = xcalloc (1, sizeof *pkt );
        pkt->pkttype = PKT_SIGNATURE;