Fix preference setting in new keys
[gnupg.git] / g10 / gpg.c
index 75d44f6..2b7b4be 100644 (file)
--- a/g10/gpg.c
+++ b/g10/gpg.c
@@ -1,6 +1,6 @@
 /* gpg.c - The GnuPG utility (main for gpg)
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- *               2006, 2007 Free Software Foundation, Inc.
+ *               2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
 #include <sys/stat.h> /* for stat() */
 #endif
 #include <fcntl.h>
-#include <assuan.h>
 #ifdef HAVE_W32_SYSTEM
 #include <windows.h>
 #endif
 
 #define INCLUDED_BY_MAIN_MODULE 1
 #include "gpg.h"
+#include <assuan.h>
 #include "packet.h"
 #include "../common/iobuf.h"
 #include "util.h"
@@ -53,6 +53,7 @@
 #include "keyserver-internal.h"
 #include "exec.h"
 #include "gc-opt-flags.h"
+#include "asshelp.h"
 
 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
 #define MY_O_BINARY  O_BINARY
@@ -119,6 +120,7 @@ enum cmd_and_opt_values
     aListSigs,
     aSendKeys,
     aRecvKeys,
+    aLocateKeys,
     aSearchKeys,
     aRefreshKeys,
     aFetchKeys,
@@ -145,6 +147,7 @@ enum cmd_and_opt_values
     aCardStatus,
     aCardEdit,
     aChangePIN,
+    aPasswd,
     aServer,
 
     oTextmode,
@@ -206,10 +209,10 @@ enum cmd_and_opt_values
     oCompressLevel,
     oBZ2CompressLevel,
     oBZ2DecompressLowmem,
-    oPasswd,
-    oPasswdFD,
-    oPasswdFile,
-    oPasswdRepeat,
+    oPassphrase,
+    oPassphraseFD,
+    oPassphraseFile,
+    oPassphraseRepeat,
     oCommandFD,
     oCommandFile,
     oQuickRandom,
@@ -229,7 +232,11 @@ enum cmd_and_opt_values
     oHomedir,
     oWithColons,
     oWithKeyData,
+    oWithSigList,
+    oWithSigCheck,
     oSkipVerify,
+    oSkipHiddenRecipients,
+    oNoSkipHiddenRecipients,
     oCompressKeys,
     oCompressSigs,
     oAlwaysTrust,
@@ -357,6 +364,7 @@ enum cmd_and_opt_values
     oDisableDSA2,
     oAllowMultipleMessages,
     oNoAllowMultipleMessages,
+    oFakedSystemTime,
 
     oNoop
   };
@@ -364,353 +372,393 @@ enum cmd_and_opt_values
 
 static ARGPARSE_OPTS opts[] = {
 
-    { 300, NULL, 0, N_("@Commands:\n ") },
-
-    { aSign, "sign",      256, N_("|[file]|make a signature")},
-    { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
-    { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
-    { aEncr, "encrypt",   256, N_("encrypt data")},
-    { aEncrFiles, "encrypt-files", 256, "@"},
-    { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
-    { aStore, "store",     256, "@"},
-    { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
-    { aDecryptFiles, "decrypt-files", 256, "@"},
-    { aVerify, "verify"   , 256, N_("verify a signature")},
-    { aVerifyFiles, "verify-files" , 256, "@" },
-    { aListKeys, "list-keys", 256, N_("list keys")},
-    { aListKeys, "list-public-keys", 256, "@" },
-    { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
-    { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
-    { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
-    { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
-    { aKeygen,    "gen-key",  256, N_("generate a new key pair")},
-    { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
-    { aDeleteSecretKeys, "delete-secret-keys",256,
-                                   N_("remove keys from the secret keyring")},
-    { aSignKey,  "sign-key"   ,256, N_("sign a key")},
-    { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
-    { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
-    { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
-    { aDesigRevoke, "desig-revoke",256, "@" },
-    { aExport, "export"           , 256, N_("export keys") },
-    { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
-    { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
-    { aSearchKeys, "search-keys" , 256,
-                                    N_("search for keys on a key server") },
-    { aRefreshKeys, "refresh-keys", 256,
-                                    N_("update all keys from a keyserver")},
-    { aFetchKeys, "fetch-keys" , 256, "@" },
-    { aExportSecret, "export-secret-keys" , 256, "@" },
-    { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
-    { aImport, "import",      256     , N_("import/merge keys")},
-    { aFastImport, "fast-import",  256 , "@"},
+  ARGPARSE_group (300, N_("@Commands:\n ")),
+
+  ARGPARSE_c (aSign, "sign", N_("make a signature")),
+  ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature")),
+  ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
+  ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
+  ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
+  ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
+  ARGPARSE_c (aStore, "store",     "@"),
+  ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
+  ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
+  ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
+  ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
+  ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
+  ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
+  ARGPARSE_c (aListSigs, "list-sigs", N_("list keys and signatures")),
+  ARGPARSE_c (aCheckKeys, "check-sigs",N_("list and check key signatures")),
+  ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
+  ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
+  ARGPARSE_c (aKeygen,    "gen-key",  N_("generate a new key pair")),
+  ARGPARSE_c (aGenRevoke, "gen-revoke",N_("generate a revocation certificate")),
+  ARGPARSE_c (aDeleteKeys,"delete-keys", 
+              N_("remove keys from the public keyring")),
+  ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
+              N_("remove keys from the secret keyring")),
+  ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
+  ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
+  ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
+  ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
+  ARGPARSE_c (aPasswd,   "passwd",     N_("change a passphrase")),
+  ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
+  ARGPARSE_c (aExport, "export"           , N_("export keys") ),
+  ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a key server") ),
+  ARGPARSE_c (aRecvKeys, "recv-keys"     , N_("import keys from a key server") ),
+  ARGPARSE_c (aSearchKeys, "search-keys" , 
+              N_("search for keys on a key server") ),
+  ARGPARSE_c (aRefreshKeys, "refresh-keys", 
+              N_("update all keys from a keyserver")),
+  ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
+  ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
+  ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
+  ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
+  ARGPARSE_c (aImport, "import", N_("import/merge keys")),
+  ARGPARSE_c (aFastImport, "fast-import", "@"),
 #ifdef ENABLE_CARD_SUPPORT
-    { aCardStatus,  "card-status", 256, N_("print the card status")},
-    { aCardEdit,   "card-edit",  256, N_("change data on a card")},
-    { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
+  ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
+  ARGPARSE_c (aCardEdit,   "card-edit",  N_("change data on a card")),
+  ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
 #endif
-    { aListConfig, "list-config", 256, "@"},
-    { aGPGConfList, "gpgconf-list", 256, "@" },
-    { aGPGConfTest, "gpgconf-test", 256, "@" },
-    { aListPackets, "list-packets",256, "@"},
-    { aExportOwnerTrust, "export-ownertrust", 256, "@"},
-    { aImportOwnerTrust, "import-ownertrust", 256, "@"},
-    { aUpdateTrustDB,
-             "update-trustdb",0 , N_("update the trust database")},
-    { aCheckTrustDB, "check-trustdb", 0, "@"},
-    { aFixTrustDB, "fix-trustdb", 0, "@"},
-    { aDeArmor, "dearmor", 256, "@"},
-    { aDeArmor, "dearmour", 256, "@"},
-    { aEnArmor, "enarmor", 256, "@"},
-    { aEnArmor, "enarmour", 256, "@"},
-    { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
-    { aPrimegen, "gen-prime" , 256, "@" },
-    { aGenRandom, "gen-random", 256, "@" },
-    { aServer,   "server",      256, N_("run in server mode")},
-
-    { 301, NULL, 0, N_("@\nOptions:\n ") },
-
-    { oArmor, "armor",     0, N_("create ascii armored output")},
-    { oArmor, "armour",     0, "@" },
-    { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
-    { oHiddenRecipient, "hidden-recipient", 2, "@" },
-    { oRecipient, "remote-user", 2, "@"},  /* old option name */
-    { oDefRecipient, "default-recipient", 2, "@"},
-    { oDefRecipientSelf, "default-recipient-self", 0, "@"},
-    { oNoDefRecipient, "no-default-recipient", 0, "@" },
-    { oTempDir, "temp-directory", 2, "@" },
-    { oExecPath, "exec-path", 2, "@" },
-    { oEncryptTo, "encrypt-to", 2, "@" },
-    { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
-    { oNoEncryptTo, "no-encrypt-to", 0, "@" },
-    { oLocalUser, "local-user",2, N_("use this user-id to sign or decrypt")},
-    { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
-    { oCompressLevel, "compress-level", 1, "@" },
-    { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
-    { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
-    { oTextmodeShort, NULL,   0, "@"},
-    { oTextmode, "textmode",  0, N_("use canonical text mode")},
-    { oNoTextmode, "no-textmode",  0, "@"},
-    { oExpert, "expert",   0, "@"},
-    { oNoExpert, "no-expert",   0, "@"},
-    { oDefSigExpire, "default-sig-expire", 2, "@"},
-    { oAskSigExpire, "ask-sig-expire",   0, "@"},
-    { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
-    { oDefCertExpire, "default-cert-expire", 2, "@"},
-    { oAskCertExpire, "ask-cert-expire",   0, "@"},
-    { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
-    { oDefCertLevel, "default-cert-level", 1, "@"},
-    { oMinCertLevel, "min-cert-level", 1, "@"},
-    { oAskCertLevel, "ask-cert-level",   0, "@"},
-    { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
-    { oOutput, "output",    2, N_("|FILE|write output to FILE")},
-    { oMaxOutput, "max-output", 16|4, "@" },
-    { oVerbose, "verbose",   0, N_("verbose") },
-    { oQuiet,  "quiet",   0, "@"},
-    { oNoTTY, "no-tty", 0, "@"},
-    { oForceV3Sigs, "force-v3-sigs", 0, "@"},
-    { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
-    { oForceV4Certs, "force-v4-certs", 0, "@"},
-    { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
-    { oForceMDC, "force-mdc", 0, "@"},
-    { oNoForceMDC, "no-force-mdc", 0, "@" },
-    { oDisableMDC, "disable-mdc", 0, "@"},
-    { oNoDisableMDC, "no-disable-mdc", 0, "@" },
-    { oDryRun, "dry-run",   0, N_("do not make any changes") },
-    { oInteractive, "interactive", 0, N_("prompt before overwriting") },
-    { oUseAgent, "use-agent",0, "@"},
-    { oNoUseAgent, "no-use-agent",0, "@"},
-    { oGpgAgentInfo, "gpg-agent-info",2, "@"},
-    { oBatch, "batch", 0, "@"},
-    { oAnswerYes, "yes", 0, "@"},
-    { oAnswerNo, "no", 0, "@"},
-    { oKeyring, "keyring", 2, "@"},
-    { oPrimaryKeyring, "primary-keyring",2, "@" },
-    { oSecretKeyring, "secret-keyring", 2, "@"},
-    { oShowKeyring, "show-keyring", 0, "@"},
-    { oDefaultKey, "default-key", 2, "@"},
-    { oKeyServer, "keyserver", 2, "@"},
-    { oKeyServerOptions, "keyserver-options",2,"@"},
-    { oImportOptions, "import-options",2,"@"},
-    { oExportOptions, "export-options",2,"@"},
-    { oListOptions, "list-options",2,"@"},
-    { oVerifyOptions, "verify-options",2,"@"},
-    { oDisplayCharset, "display-charset", 2, "@"},
-    { oDisplayCharset, "charset", 2, "@"},
-    { oOptions, "options", 2, "@"},
-    { oDebug, "debug"     ,4|16, "@"},
-    { oDebugLevel, "debug-level" ,2, "@"},
-    { oDebugAll, "debug-all" ,0, "@"},
-    { oStatusFD, "status-fd" ,1, "@"},
-    { oStatusFile, "status-file" ,2, "@"},
-    { oAttributeFD, "attribute-fd" ,1, "@" },
-    { oAttributeFile, "attribute-file" ,2, "@" },
-    { oNoop, "sk-comments", 0,   "@"},
-    { oNoop, "no-sk-comments", 0,   "@"},
-    { oCompletesNeeded, "completes-needed", 1, "@"},
-    { oMarginalsNeeded, "marginals-needed", 1, "@"},
-    { oMaxCertDepth,   "max-cert-depth", 1, "@" },
-    { oTrustedKey, "trusted-key", 2, "@"},
-    { oLoadExtension, "load-extension", 2, "@"},
-    { oGnuPG, "gnupg",   0, "@"},
-    { oGnuPG, "no-pgp2", 0, "@"},
-    { oGnuPG, "no-pgp6", 0, "@"},
-    { oGnuPG, "no-pgp7", 0, "@"},
-    { oGnuPG, "no-pgp8", 0, "@"},
-    { oRFC1991, "rfc1991",   0, "@"},
-    { oRFC2440, "rfc2440", 0, "@" },
-    { oRFC4880, "rfc4880", 0, "@" },
-    { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
-    { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
-    { oPGP6, "pgp6", 0, "@"},
-    { oPGP7, "pgp7", 0, "@"},
-    { oPGP8, "pgp8", 0, "@"},
-    { oRFC2440Text, "rfc2440-text", 0, "@"},
-    { oNoRFC2440Text, "no-rfc2440-text", 0, "@"},
-    { oS2KMode, "s2k-mode", 1, "@"},
-    { oS2KDigest, "s2k-digest-algo", 2, "@"},
-    { oS2KCipher, "s2k-cipher-algo", 2, "@"},
-    { oS2KCount, "s2k-count", 1, "@"},
-    { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
-    { oCipherAlgo, "cipher-algo", 2, "@"},
-    { oDigestAlgo, "digest-algo", 2, "@"},
-    { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
-    { oCompressAlgo,"compress-algo", 2, "@"},
-    { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
-    { oThrowKeyids, "throw-keyid", 0, "@"},
-    { oThrowKeyids, "throw-keyids", 0, "@"},
-    { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
-    { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
-    { oShowPhotos,   "show-photos", 0, "@" },
-    { oNoShowPhotos, "no-show-photos", 0, "@" },
-    { oPhotoViewer,  "photo-viewer", 2, "@" },
-    { oSetNotation,  "set-notation", 2, "@" },
-    { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
-    { oSigNotation,  "sig-notation", 2, "@" },
-    { oCertNotation, "cert-notation", 2, "@" },
-
-    { 302, NULL, 0, N_(
+  ARGPARSE_c (aListConfig, "list-config", "@"),
+  ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
+  ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
+  ARGPARSE_c (aListPackets, "list-packets","@"),
+  ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
+  ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
+  ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
+              N_("update the trust database")),
+  ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
+  ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
+  ARGPARSE_c (aDeArmor, "dearmor", "@"),
+  ARGPARSE_c (aDeArmor, "dearmour", "@"),
+  ARGPARSE_c (aEnArmor, "enarmor", "@"),
+  ARGPARSE_c (aEnArmor, "enarmour", "@"),
+  ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
+  ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
+  ARGPARSE_c (aGenRandom,"gen-random", "@" ),
+  ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
+
+  ARGPARSE_group (301, N_("@\nOptions:\n ")),
+
+  ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
+  ARGPARSE_s_n (oArmor, "armour", "@"),
+
+  ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
+  ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
+  ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
+  ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
+  ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
+  ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
+
+  ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
+  ARGPARSE_s_s (oExecPath, "exec-path", "@"),
+  ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
+  ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
+  ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
+  ARGPARSE_s_s (oLocalUser, "local-user",
+                N_("|USER-ID|use USER-ID to sign or decrypt")),
+
+  ARGPARSE_s_i (oCompress, NULL,
+                N_("|N|set compress level to N (0 disables)")),
+  ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
+  ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
+  ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
+
+  ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
+  ARGPARSE_s_n (oTextmode,      "textmode", N_("use canonical text mode")),
+  ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
+
+  ARGPARSE_s_n (oExpert,      "expert", "@"),
+  ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
+
+  ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
+  ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
+  ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
+  ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
+  ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
+  ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
+  ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
+  ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
+  ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
+  ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
+
+  ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
+  ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
+
+  ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
+  ARGPARSE_s_n (oQuiet,          "quiet",   "@"),
+  ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
+
+  ARGPARSE_s_n (oForceV3Sigs,      "force-v3-sigs", "@"),
+  ARGPARSE_s_n (oNoForceV3Sigs, "no-force-v3-sigs", "@"),
+  ARGPARSE_s_n (oForceV4Certs,     "force-v4-certs", "@"),
+  ARGPARSE_s_n (oNoForceV4Certs, "no-force-v4-certs", "@"),
+  ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
+  ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
+  ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
+  ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
+
+  ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
+  ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
+
+  ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
+  ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
+  ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
+
+  ARGPARSE_s_n (oBatch, "batch", "@"),
+  ARGPARSE_s_n (oAnswerYes, "yes", "@"),
+  ARGPARSE_s_n (oAnswerNo, "no", "@"),
+  ARGPARSE_s_s (oKeyring, "keyring", "@"),
+  ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
+  ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
+  ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
+  ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
+
+  ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
+  ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
+  ARGPARSE_s_s (oImportOptions, "import-options", "@"),
+  ARGPARSE_s_s (oExportOptions, "export-options", "@"),
+  ARGPARSE_s_s (oListOptions,   "list-options", "@"),
+  ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
+
+  ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
+  ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
+  ARGPARSE_s_s (oOptions, "options", "@"),
+
+  ARGPARSE_p_u (oDebug, "debug", "@"),
+  ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
+  ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
+  ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
+  ARGPARSE_s_s (oStatusFile, "status-file", "@"),
+  ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
+  ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
+
+  ARGPARSE_s_n (oNoop, "sk-comments", "@"),
+  ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
+
+  ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
+  ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
+  ARGPARSE_s_i (oMaxCertDepth, "max-cert-depth", "@" ),
+  ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
+
+  ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
+
+  ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
+  ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
+  ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
+  ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
+  ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
+  ARGPARSE_s_n (oRFC1991, "rfc1991", "@"),
+  ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
+  ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
+  ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
+  ARGPARSE_s_n (oPGP2, "pgp2", "@"),
+  ARGPARSE_s_n (oPGP6, "pgp6", "@"),
+  ARGPARSE_s_n (oPGP7, "pgp7", "@"),
+  ARGPARSE_s_n (oPGP8, "pgp8", "@"),
+
+  ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
+  ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
+  ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
+  ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
+  ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
+  ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
+  ARGPARSE_s_n (oSimpleSKChecksum, "simple-sk-checksum", "@"),
+  ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
+  ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
+  ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
+  ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
+  ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
+  ARGPARSE_s_n (oThrowKeyids, "throw-keyid", "@"),
+  ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
+  ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyid", "@"),
+  ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
+  ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
+  ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
+  ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
+  ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
+  ARGPARSE_s_s (oSetNotation,  "notation-data", "@"), /* Alias */
+  ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
+  ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
+
+  ARGPARSE_group (302, N_(
   "@\n(See the man page for a complete listing of all commands and options)\n"
-                     )},
+                     )),
 
-    { 303, NULL, 0, N_("@\nExamples:\n\n"
+  ARGPARSE_group (303, N_("@\nExamples:\n\n"
     " -se -r Bob [file]          sign and encrypt for user Bob\n"
     " --clearsign [file]         make a clear text signature\n"
     " --detach-sign [file]       make a detached signature\n"
     " --list-keys [names]        show keys\n"
-    " --fingerprint [names]      show fingerprints\n"  ) },
-
-  /* hidden options */
-    { aPrintMDs, "print-mds" , 256, "@"}, /* old */
-    { aListTrustDB, "list-trustdb",0 , "@"},
-    /* Not yet used */
-    /* { aListTrustPath, "list-trust-path",0, "@"}, */
-    { oPasswd, "passphrase",2, "@" },
-    { oPasswdFD, "passphrase-fd",1, "@" },
-    { oPasswdFile, "passphrase-file",2, "@" },
-    { oPasswdRepeat, "passphrase-repeat", 1, "@"},
-    { oCommandFD, "command-fd",1, "@" },
-    { oCommandFile, "command-file",2, "@" },
-    { oQuickRandom, "debug-quick-random", 0, "@"},
-    { oNoVerbose, "no-verbose", 0, "@"},
-    { oTrustDBName, "trustdb-name", 2, "@" },
-    { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
-    { oRequireSecmem,"require-secmem", 0, "@" },
-    { oNoRequireSecmem,"no-require-secmem", 0, "@" },
-    { oNoPermissionWarn, "no-permission-warning", 0, "@" },
-    { oNoMDCWarn, "no-mdc-warning", 0, "@" },
-    { oNoArmor, "no-armor",   0, "@"},
-    { oNoArmor, "no-armour",   0, "@"},
-    { oNoDefKeyring, "no-default-keyring", 0, "@" },
-    { oNoGreeting, "no-greeting", 0, "@" },
-    { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
-    { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
-    { oNoBatch, "no-batch", 0, "@" },
-    { oWithColons, "with-colons", 0, "@"},
-    { oWithKeyData,"with-key-data", 0, "@"},
-    { aListKeys, "list-key", 0, "@" }, /* alias */
-    { aListSigs, "list-sig", 0, "@" }, /* alias */
-    { aCheckKeys, "check-sig",0, "@" }, /* alias */
-    { oSkipVerify, "skip-verify",0, "@" },
-    { oCompressKeys, "compress-keys",0, "@"},
-    { oCompressSigs, "compress-sigs",0, "@"},
-    { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
-    { oAlwaysTrust, "always-trust", 0, "@"},
-    { oTrustModel, "trust-model", 2, "@"},
-    { oForceOwnertrust, "force-ownertrust", 2, "@"},
-    { oSetFilename, "set-filename", 2, "@" },
-    { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
-    { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
-    { oSetPolicyURL, "set-policy-url", 2, "@" },
-    { oSigPolicyURL, "sig-policy-url", 2, "@" },
-    { oCertPolicyURL, "cert-policy-url", 2, "@" },
-    { oShowPolicyURL, "show-policy-url", 0, "@" },
-    { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
-    { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
-    { oShowNotation, "show-notation", 0, "@" },
-    { oNoShowNotation, "no-show-notation", 0, "@" },
-    { oComment, "comment", 2, "@" },
-    { oDefaultComment, "default-comment", 0, "@" },
-    { oNoComments, "no-comments", 0, "@" },
-    { oEmitVersion, "emit-version", 0, "@"},
-    { oNoEmitVersion, "no-emit-version", 0, "@"},
-    { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
-    { oNotDashEscaped, "not-dash-escaped", 0, "@" },
-    { oEscapeFrom, "escape-from-lines", 0, "@" },
-    { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
-    { oLockOnce, "lock-once", 0, "@" },
-    { oLockMultiple, "lock-multiple", 0, "@" },
-    { oLockNever, "lock-never", 0, "@" },
-    { oLoggerFD, "logger-fd",1, "@" },
-    { oLoggerFile, "log-file",2, "@" },
-    { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
-    { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
-    { oUtf8Strings, "utf8-strings", 0, "@" },
-    { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
-    { oWithFingerprint, "with-fingerprint", 0, "@" },
-    { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
-    { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
-    { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
-    { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
-    { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
-    { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
-    { oNoLiteral, "no-literal", 0, "@" },
-    { oSetFilesize, "set-filesize", 20, "@" },
-    { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
-    { oFastListMode,"fast-list-mode", 0, "@" },
-    { oFixedListMode,"fixed-list-mode", 0, "@" },
-    { oListOnly, "list-only", 0, "@"},
-    { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
-    { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
-    { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
-    { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
-    { oShowSessionKey, "show-session-key", 0, "@" },
-    { oOverrideSessionKey, "override-session-key", 2, "@" },
-    { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
-    { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
-    { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
-    { oNoSigCache,         "no-sig-cache", 0, "@" },
-    { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
-    { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
-    { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
-    { oMergeOnly,        "merge-only", 0, "@" },
-    { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
-    { oTryAllSecrets,  "try-all-secrets", 0, "@" },
-    { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
-    { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
-    { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
-    { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
-    { oPreservePermissions, "preserve-permissions", 0, "@"},
-    { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
-    { oDefaultKeyserverURL,  "default-keyserver-url", 2, "@"},
-    { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
-    { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
-    { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
-    /* Aliases.  I constantly mistype these, and assume other people
-       do as well. */
-    { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
-    { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
-    { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
-    { oAgentProgram, "agent-program", 2 , "@" },
-    { oDisplay,    "display",     2, "@" },
-    { oTTYname,    "ttyname",     2, "@" },
-    { oTTYtype,    "ttytype",     2, "@" },
-    { oLCctype,    "lc-ctype",    2, "@" },
-    { oLCmessages, "lc-messages", 2, "@" },
-    { oXauthority, "xauthority",  2, "@" },
-    { oGroup,      "group",       2, "@" },
-    { oUnGroup,    "ungroup",     2, "@" },
-    { oNoGroups,   "no-groups",    0, "@" },
-    { oStrict,     "strict",      0, "@" },
-    { oNoStrict,   "no-strict",   0, "@" },
-    { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
-    { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
-    { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
-    { oMultifile, "multifile", 0, "@" },
-    { oKeyidFormat, "keyid-format", 2, "@" },
-    { oExitOnStatusWriteError, "exit-on-status-write-error", 0, "@" },
-    { oLimitCardInsertTries, "limit-card-insert-tries", 1, "@"},
-
-    { oAllowMultisigVerification, "allow-multisig-verification", 0, "@"},
-    { oEnableDSA2, "enable-dsa2", 0, "@"},
-    { oDisableDSA2, "disable-dsa2", 0, "@"},
-    { oAllowMultipleMessages, "allow-multiple-messages", 0, "@"},
-    { oNoAllowMultipleMessages, "no-allow-multiple-messages", 0, "@"},
-
-    /* These two are aliases to help users of the PGP command line
-       product use gpg with minimal pain.  Many commands are common
-       already as they seem to have borrowed commands from us.  Now
-       I'm returning the favor. */
-    { oLocalUser, "sign-with", 2, "@" },
-    { oRecipient, "user", 2, "@" },
-    { oRequireCrossCert, "require-backsigs", 0, "@"},
-    { oRequireCrossCert, "require-cross-certification", 0, "@"},
-    { oNoRequireCrossCert, "no-require-backsigs", 0, "@"},
-    { oNoRequireCrossCert, "no-require-cross-certification", 0, "@"},
-    { oAutoKeyLocate, "auto-key-locate", 2, "@"},
-    { oNoAutoKeyLocate, "no-auto-key-locate", 0, "@"},
-
-    {0,NULL,0,NULL}
+    " --fingerprint [names]      show fingerprints\n")),
+
+  /* More hidden commands and options. */
+  ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
+  ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
+  /* Not yet used: 
+     ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
+  ARGPARSE_c (aDeleteSecretAndPublicKeys,
+              "delete-secret-and-public-keys", "@"),
+  ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
+
+  ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
+  ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
+  ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
+  ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
+  ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
+  ARGPARSE_s_s (oCommandFile, "command-file", "@"),
+  ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
+  ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
+  ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
+  ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
+  ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
+  ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
+  ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
+  ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
+  ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
+  ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
+  ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
+  ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
+  ARGPARSE_s_n (oNoOptions, "no-options", "@"), 
+  ARGPARSE_s_s (oHomedir, "homedir", "@"), 
+  ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
+  ARGPARSE_s_n (oWithColons, "with-colons", "@"),
+  ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
+  ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
+  ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
+  ARGPARSE_s_n (aListKeys, "list-key", "@"),   /* alias */
+  ARGPARSE_s_n (aListSigs, "list-sig", "@"),   /* alias */
+  ARGPARSE_s_n (aCheckKeys, "check-sig", "@"), /* alias */
+  ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
+  ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
+  ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
+  ARGPARSE_s_n (oCompressKeys, "compress-keys", "@"),
+  ARGPARSE_s_n (oCompressSigs, "compress-sigs", "@"),
+  ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
+  ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
+  ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
+  ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
+  ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
+  ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
+  ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
+  ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
+  ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
+  ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
+  ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
+  ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
+  ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
+  ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
+  ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
+  ARGPARSE_s_s (oComment, "comment", "@"),
+  ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
+  ARGPARSE_s_n (oNoComments, "no-comments", "@"),
+  ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
+  ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
+  ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
+  ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
+  ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
+  ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
+  ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
+  ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
+  ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
+  ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
+  ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
+  ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
+  ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
+  ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
+  ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
+  ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
+  ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
+  ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
+  ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
+  ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
+  ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
+  ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
+  ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
+  ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
+  ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
+  ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
+  ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
+  ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
+  ARGPARSE_s_n (oListOnly, "list-only", "@"),
+  ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
+  ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
+  ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
+  ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
+  ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
+  ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
+  ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
+  ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
+  ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
+  ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
+  ARGPARSE_s_n (oNoSigCreateCheck,   "no-sig-create-check", "@"),
+  ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
+  ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
+  ARGPARSE_s_n (oMergeOnly,      "merge-only", "@" ),
+  ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
+  ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
+  ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
+  ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
+  ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
+  ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
+  ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
+  ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
+  ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
+  ARGPARSE_s_s (oPersonalCompressPreferences,
+                                         "personal-compress-preferences", "@"),
+  ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
+
+  /* Aliases.  I constantly mistype these, and assume other people do
+     as well. */
+  ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
+  ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
+  ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
+  ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
+  ARGPARSE_s_s (oDisplay,    "display",    "@"),
+  ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
+  ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
+  ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
+  ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
+  ARGPARSE_s_s (oXauthority, "xauthority", "@"),
+  ARGPARSE_s_s (oGroup,      "group",      "@"),
+  ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
+  ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
+  ARGPARSE_s_n (oStrict,     "strict",     "@"),
+  ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
+  ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
+  ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
+  ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
+  ARGPARSE_s_n (oMultifile, "multifile", "@"),
+  ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
+  ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
+  ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
+  
+  ARGPARSE_s_n (oAllowMultisigVerification, 
+                "allow-multisig-verification", "@"),
+  ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
+  ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
+  ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
+  ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
+
+  /* These two are aliases to help users of the PGP command line
+     product use gpg with minimal pain.  Many commands are common
+     already as they seem to have borrowed commands from us.  Now I'm
+     returning the favor. */
+  ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
+  ARGPARSE_s_s (oRecipient, "user", "@"),
+
+  ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
+  ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
+  ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
+  ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
+
+  /* New options.  Fixme: Should go more to the top.  */
+  ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
+  ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
+
+  ARGPARSE_end ()
 };
 
 
@@ -728,7 +776,6 @@ static int maybe_setuid = 1;
 
 static char *build_list( const char *text, char letter,
                         const char *(*mapf)(int), int (*chkf)(int) );
-static char *build_lib_list (const char *text);
 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
                        enum cmd_and_opt_values new_cmd );
 static void print_mds( const char *fname, int algo );
@@ -738,28 +785,51 @@ static void add_keyserver_url( const char *string, int which );
 static void emergency_cleanup (void);
 
 
+static char *
+make_libversion (const char *libname, const char *(*getfnc)(const char*))
+{
+  const char *s;
+  char *result;
+  
+  if (maybe_setuid)
+    {
+      gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
+      maybe_setuid = 0;
+    }
+  s = getfnc (NULL);
+  result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
+  strcpy (stpcpy (stpcpy (result, libname), " "), s);
+  return result;
+}
+
+
 static const char *
 my_strusage( int level )
 {
-  static char *digests, *pubkeys, *ciphers, *zips, *libs;
-    const char *p;
+  static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
+  const char *p;
+
     switch( level ) {
       case 11: p = "gpg (GnuPG)";
        break;
       case 13: p = VERSION; break;
       case 17: p = PRINTABLE_OS_NAME; break;
-      case 19: p =
-           _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
-       break;
+      case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
+
+    case 20:
+      if (!ver_gcry)
+        ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
+      p = ver_gcry;
+      break;
 
 #ifdef IS_DEVELOPMENT_VERSION
-      case 20:
+      case 25:
        p="NOTE: THIS IS A DEVELOPMENT VERSION!";
        break;
-      case 21:
+      case 26:
        p="It is only intended for test purposes and should NOT be";
        break;
-      case 22:
+      case 27:
        p="used in a production environment or with production keys!";
        break;
 #endif
@@ -809,11 +879,6 @@ my_strusage( int level )
                               check_compress_algo);
        p = zips;
        break;
-      case 38:
-       if (!libs)
-          libs = build_lib_list(_("Used libraries:"));
-       p = libs;
-       break;
 
       default: p = NULL;
     }
@@ -876,46 +941,6 @@ build_list( const char *text, char letter,
 }
 
 
-static char *
-build_lib_list (const char *text)
-{
-  struct { const char *name; const char *version; } array[3];
-  int idx;
-  size_t n;
-  char *list, *p;
-
-  if (maybe_setuid)
-    gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
-
-  idx = 0;
-  array[idx].name = "gcrypt";
-  array[idx++].version = gcry_check_version (NULL);
-  array[idx].name = NULL;
-  array[idx++].version = NULL;
-
-  n = strlen (text) + 1;
-  for (idx=0; array[idx].name; idx++)
-    {
-      n += 2 + strlen (array[idx].name);
-      if (array[idx].version)
-        n += 1 + strlen (array[idx].version) + 1;
-    }
-  n++;
-  list = xmalloc (n+1);
-  p = stpcpy (stpcpy (list, text), " ");
-  for (idx=0; array[idx].name; idx++)
-    {
-      if (idx)
-        p = stpcpy (p, ", ");
-      p = stpcpy (p, array[idx].name);
-      if (array[idx].version)
-        p = stpcpy (stpcpy (stpcpy (p, "("), array[idx].version), ")");
-    }
-  strcpy (p, "\n");
-  return list;
-}
-
-
 static void
 wrong_args( const char *text)
 {
@@ -938,6 +963,17 @@ make_username( const char *string )
 }
 
 
+static void
+set_opt_session_env (const char *name, const char *value)
+{
+  gpg_error_t err;
+  
+  err = session_env_setenv (opt.session_env, name, value);
+  if (err)
+    log_fatal ("error setting session environment: %s\n",
+               gpg_strerror (err));
+}
+
 /* Setup the debugging.  With a LEVEL of NULL only the active debug
    flags are propagated to the subsystems.  With LEVEL set, a specific
    set of debug flags is set; thus overriding all flags already
@@ -945,19 +981,30 @@ make_username( const char *string )
 static void
 set_debug (const char *level)
 {
+  int numok = (level && digitp (level));
+  int numlvl = numok? atoi (level) : 0;
+
   if (!level)
     ;
-  else if (!strcmp (level, "none"))
+  else if (!strcmp (level, "none") || (numok && numlvl < 1))
     opt.debug = 0;
-  else if (!strcmp (level, "basic"))
+  else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
     opt.debug = DBG_MEMSTAT_VALUE;
-  else if (!strcmp (level, "advanced"))
+  else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
-  else if (!strcmp (level, "expert"))
+  else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
                  |DBG_CACHE_VALUE|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
-  else if (!strcmp (level, "guru"))
-    opt.debug = ~0;
+  else if (!strcmp (level, "guru") || numok)
+    {
+      opt.debug = ~0;
+      /* Unless the "guru" string has been used we don't want to allow
+         hashing debugging.  The rationale is that people tend to
+         select the highest debug value and would then clutter their
+         disk with debug files which may reveal confidential data.  */ 
+      if (numok)
+        opt.debug &= ~(DBG_HASHING_VALUE);
+    }
   else
     {
       log_error (_("invalid debug-level `%s' given\n"), level);
@@ -975,6 +1022,22 @@ set_debug (const char *level)
   if (opt.debug & DBG_IOBUF_VALUE )
     iobuf_debug_mode = 1;
   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
+
+  if (opt.debug)
+    log_info ("enabled debug flags:%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
+              (opt.debug & DBG_PACKET_VALUE )? " packet":"",    
+              (opt.debug & DBG_MPI_VALUE    )? " mpi":"",    
+              (opt.debug & DBG_CIPHER_VALUE )? " cipher":"",    
+              (opt.debug & DBG_FILTER_VALUE )? " filter":"", 
+              (opt.debug & DBG_IOBUF_VALUE  )? " iobuf":"", 
+              (opt.debug & DBG_MEMORY_VALUE )? " memory":"", 
+              (opt.debug & DBG_CACHE_VALUE  )? " cache":"", 
+              (opt.debug & DBG_MEMSTAT_VALUE)? " memstat":"", 
+              (opt.debug & DBG_TRUST_VALUE  )? " trust":"", 
+              (opt.debug & DBG_HASHING_VALUE)? " hashing":"", 
+              (opt.debug & DBG_EXTPROG_VALUE)? " extprog":"", 
+              (opt.debug & DBG_CARD_IO_VALUE)? " cardio":"",
+              (opt.debug & DBG_ASSUAN_VALUE )? " assuan":"");
 }
 
 
@@ -1019,9 +1082,9 @@ set_screen_dimensions(void)
    used with --status-file etc functions.  Not generally useful but it
    avoids the riscos specific functions and well some Windows people
    might like it too.  Prints an error message and returns -1 on
-   error. On success the file descriptor is returned.  */
+   error.  On success the file descriptor is returned.  */
 static int
-open_info_file (const char *fname, int for_write)
+open_info_file (const char *fname, int for_write, int binary)
 {
 #ifdef __riscos__
   return riscos_fdopenfile (fname, for_write);
@@ -1031,24 +1094,30 @@ open_info_file (const char *fname, int for_write)
      similar to the option file but in that case it is unlikely that
      sensitive information may be retrieved by means of error
      messages.  */
+  (void)fname;
+  (void)for_write;
+  (void)binary;
   return -1;
 #else 
   int fd;
 
+  if (binary)
+    binary = MY_O_BINARY;
+
 /*   if (is_secured_filename (fname)) */
 /*     { */
 /*       fd = -1; */
-/*       errno = EPERM; */
+/*       gpg_err_set_errno (EPERM); */
 /*     } */
 /*   else */
 /*     { */
       do
         {
           if (for_write)
-            fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
+            fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
           else
-            fd = open (fname, O_RDONLY | MY_O_BINARY);
+            fd = open (fname, O_RDONLY | binary);
         }
       while (fd == -1 && errno == EINTR);
 /*     } */
@@ -1173,7 +1242,7 @@ rm_group(char *name)
 
    Returns true if the item is unsafe. */
 static int
-check_permissions(const char *path,int item)
+check_permissions (const char *path, int item)
 {
 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
   static int homedir_cache=-1;
@@ -1359,12 +1428,15 @@ check_permissions(const char *path,int item)
 
   return ret;
 
-#endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
-
+#else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
+  (void)path;
+  (void)item;
   return 0;
+#endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
 }
 
 
+/* Print the OpenPGP defined algo numbers.  */
 static void
 print_algo_numbers(int (*checker)(int))
 {
@@ -1427,9 +1499,10 @@ list_config(char *items)
            {
              strlist_t sl;
 
-             printf("cfg:group:");
-             print_string(stdout,iter->name,strlen(iter->name),':');
-             printf(":");
+             es_fprintf (es_stdout, "cfg:group:");
+             es_write_sanitized (es_stdout, iter->name, strlen(iter->name),
+                                  ":", NULL);
+             es_putc (':', es_stdout);
 
              for(sl=iter->values;sl;sl=sl->next)
                {
@@ -1447,7 +1520,7 @@ list_config(char *items)
       if(show_all || ascii_strcasecmp(name,"version")==0)
        {
          printf("cfg:version:");
-         print_string(stdout,VERSION,strlen(VERSION),':');
+         es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
          printf("\n");
          any=1;
        }
@@ -1548,6 +1621,15 @@ gpgconf_list (const char *configfile)
   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
   printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
   printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
+  printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
+  printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
+  printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
+  printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
+
+  /* The next one is an info only item and should match the macros at
+     the top of keygen.c  */
+  printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
+          "RSA-2048");
 
   xfree (configfile_esc);
 }
@@ -1720,39 +1802,13 @@ parse_trust_model(const char *model)
 }
 
 
-/* Pack an s2k iteration count into the form specified in 2440.  If
-   we're in between valid values, round up. */
-static unsigned char
-encode_s2k_iterations(int iterations)
-{
-  unsigned char c=0,result;
-  unsigned int count;
-
-  if(iterations<=1024)
-    return 0;
-
-  if(iterations>=65011712)
-    return 255;
-
-  /* Need count to be in the range 16-31 */
-  for(count=iterations>>6;count>=32;count>>=1)
-    c++;
-
-  result=(c<<4)|(count-16);
-
-  if(S2K_DECODE_COUNT(result)<iterations)
-    result++;
-
-  return result;
-}
-
-
 /* This fucntion called to initialized a new control object.  It is
    assumed that this object has been zeroed out before calling this
    function. */
 static void
 gpg_init_default_ctrl (ctrl_t ctrl)
 {
+  (void)ctrl;
 }
 
 
@@ -1761,12 +1817,69 @@ gpg_init_default_ctrl (ctrl_t ctrl)
 static void
 gpg_deinit_default_ctrl (ctrl_t ctrl)
 {
+  (void)ctrl;
 }
 
 
+char *
+get_default_configname (void)
+{
+  char *configname = NULL;
+  char *name = xstrdup ("gpg" EXTSEP_S "conf-" SAFE_VERSION);
+  char *ver = &name[strlen ("gpg" EXTSEP_S "conf-")];
+
+  do
+    {
+      if (configname)
+       {
+         char *tok;
+         
+         xfree (configname);
+         configname = NULL;
+
+         if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
+           *tok='\0';
+         else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
+           *tok='\0';
+         else
+           break;
+       }
+      
+      configname = make_filename (opt.homedir, name, NULL);
+    }
+  while (access (configname, R_OK));
+
+  xfree(name);
+  
+  if (! configname)
+    configname = make_filename (opt.homedir, "gpg" EXTSEP_S "conf", NULL);
+  if (! access (configname, R_OK))
+    {
+      /* Print a warning when both config files are present.  */
+      char *p = make_filename (opt.homedir, "options", NULL);
+      if (! access (p, R_OK))
+       log_info (_("NOTE: old default options file `%s' ignored\n"), p);
+      xfree (p);
+    }
+  else
+    {
+      /* Use the old default only if it exists.  */
+      char *p = make_filename (opt.homedir, "options", NULL);
+      if (!access (p, R_OK))
+       {
+         xfree (configname);
+         configname = p;
+       }
+      else
+       xfree (p);
+    }
+
+  return configname;
+}
+
 
 int
-main (int argc, char **argv )
+main (int argc, char **argv)
 {
     ARGPARSE_ARGS pargs;
     IOBUF a;
@@ -1777,12 +1890,13 @@ main (int argc, char **argv )
     char *username;
     int may_coredump;
     strlist_t sl, remusr= NULL, locusr=NULL;
-    strlist_t nrings=NULL, sec_nrings=NULL;
+    strlist_t nrings = NULL;
     armor_filter_context_t *afx = NULL;
     int detached_sig = 0;
     FILE *configfp = NULL;
     char *configname = NULL;
     char *save_configname = NULL;
+    char *default_configname = NULL;
     unsigned configlineno;
     int parse_debug = 0;
     int default_config = 1;
@@ -1806,9 +1920,10 @@ main (int argc, char **argv )
     int eyes_only=0;
     int multifile=0;
     int pwfd = -1;
-    int with_fpr = 0; /* make an option out of --fingerprint */
+    int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
     int any_explicit_recipient = 0;
     int require_secmem=0,got_secmem=0;
+    struct assuan_malloc_hooks malloc_hooks;
 
 #ifdef __riscos__
     opt.lock_once = 1;
@@ -1823,13 +1938,11 @@ main (int argc, char **argv )
     gnupg_rl_initialize ();
     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);
     log_set_prefix ("gpg", 1);
 
     /* Make sure that our subsystems are ready.  */
-    init_common_subsystems ();
+    i18n_init();
+    init_common_subsystems (&argc, &argv);
 
     /* Check that the libraries are suitable.  Do it right here because the
        option parsing may need services of the library.  */
@@ -1848,7 +1961,10 @@ main (int argc, char **argv )
 
     create_dotlock(NULL); /* Register locking cleanup. */
 
-    i18n_init();
+    opt.session_env = session_env_new ();
+    if (!opt.session_env)
+      log_fatal ("error allocating session environment block: %s\n",
+                 strerror (errno));
 
     opt.command_fd = -1; /* no command fd */
     opt.compress_level = -1; /* defaults to standard compress level */
@@ -1859,7 +1975,7 @@ main (int argc, char **argv )
     opt.cert_digest_algo = 0;
     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
     opt.s2k_mode = 3; /* iterated+salted */
-    opt.s2k_count = 96; /* 65536 iterations */
+    opt.s2k_count = 0; /* Auto-calibrate when needed.  */
 #ifdef USE_CAST5
     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
 #else
@@ -1887,7 +2003,7 @@ main (int argc, char **argv )
     opt.def_sig_expire="0";
     opt.def_cert_expire="0";
     set_homedir ( default_homedir () );
-    opt.passwd_repeat=1;
+    opt.passphrase_repeat=1;
 
     /* Check whether we have a config file on the command line.  */
     orig_argc = argc;
@@ -1905,8 +2021,11 @@ main (int argc, char **argv )
            default_config = 0;
        }
        else if( pargs.r_opt == oNoOptions )
+          {
            default_config = 0; /* --no-options */
-       else if( pargs.r_opt == oHomedir )
+            opt.no_homedir_creation = 1;
+          }
+        else if( pargs.r_opt == oHomedir )
            set_homedir ( pargs.r.ret_str );
        else if( pargs.r_opt == oNoPermissionWarn )
            opt.no_perm_warn=1;
@@ -1943,62 +2062,26 @@ main (int argc, char **argv )
 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
     /* There should be no way to get to this spot while still carrying
        setuid privs.  Just in case, bomb out if we are. */
-    if(getuid()!=geteuid())
-      BUG();
+    if ( getuid () != geteuid () )
+      BUG ();
 #endif
     maybe_setuid = 0;
 
     /* Okay, we are now working under our real uid */
 
     /* malloc hooks go here ... */
-    assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
-    assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
+    malloc_hooks.malloc = gcry_malloc;
+    malloc_hooks.realloc = gcry_realloc;
+    malloc_hooks.free = gcry_free;
+    assuan_set_malloc_hooks (&malloc_hooks);
+    assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
+    setup_libassuan_logging (&opt.debug);
  
-
     /* Try for a version specific config file first */
-    if( default_config )
-      {
-       char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
-       char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
-
-       do
-         {
-           if(configname)
-             {
-               char *tok;
-
-               xfree(configname);
-               configname=NULL;
+    default_configname = get_default_configname ();
+    if (default_config)
+      configname = xstrdup (default_configname);
 
-               if((tok=strrchr(ver,SAFE_VERSION_DASH)))
-                 *tok='\0';
-               else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
-                 *tok='\0';
-               else
-                 break;
-             }
-
-           configname = make_filename(opt.homedir,name,NULL);
-         }
-       while(access(configname,R_OK));
-
-       xfree(name);
-
-       if(!configname)
-         configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
-        if (!access (configname, R_OK))
-          { /* Print a warning when both config files are present. */
-            char *p = make_filename(opt.homedir, "options", NULL );
-            if (!access (p, R_OK))
-              log_info (_("NOTE: old default options file `%s' ignored\n"), p);
-            xfree (p);
-          }
-        else
-          { /* Keep on using the old default one. */
-            xfree (configname);
-            configname = make_filename(opt.homedir, "options", NULL );
-          }
-      }
     argc = orig_argc;
     argv = orig_argv;
     pargs.argc = &argc;
@@ -2027,7 +2110,7 @@ main (int argc, char **argv )
           {
             fclose (configfp);
             configfp = NULL;
-            errno = EPERM;
+            gpg_err_set_errno (EPERM);
           }
        if( !configfp ) {
            if( default_config ) {
@@ -2071,6 +2154,7 @@ main (int argc, char **argv )
           case aChangePIN:
 #endif /* ENABLE_CARD_SUPPORT*/
          case aListKeys: 
+         case aLocateKeys:
          case aListSigs: 
          case aExportSecret: 
          case aExportSecretSub: 
@@ -2104,6 +2188,7 @@ main (int argc, char **argv )
          case aDeleteSecretKeys:
          case aDeleteSecretAndPublicKeys:
          case aDeleteKeys:
+          case aPasswd:
             set_cmd (&cmd, pargs.r_opt);
             greeting=1;
             break;
@@ -2170,16 +2255,16 @@ main (int argc, char **argv )
           case oDebugLevel: debug_level = pargs.r.ret_str; break;
 
          case oStatusFD:
-            set_status_fd( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
+            set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
             break;
          case oStatusFile:
-            set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
+            set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
             break;
          case oAttributeFD:
-            set_attrib_fd(translate_sys2libc_fd_int (pargs.r.ret_int, 1));
+            set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
             break;
          case oAttributeFile:
-            set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
+            set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
             break;
          case oLoggerFD:
             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
@@ -2190,11 +2275,17 @@ main (int argc, char **argv )
 
          case oWithFingerprint:
             opt.with_fingerprint = 1;
-            with_fpr=1; /*fall thru*/
-         case oFingerprint: opt.fingerprint++; break;
+            opt.fingerprint++;
+            break;
+         case oFingerprint:
+            opt.fingerprint++;
+            fpr_maybe_cmd = 1;
+            break;
+
          case oSecretKeyring:
-            append_to_strlist( &sec_nrings, pargs.r.ret_str);
+            /* Ignore this old option.  */
             break;
+
          case oOptions:
            /* config files may not be nested (silently ignore them) */
            if( !configfp ) {
@@ -2236,10 +2327,18 @@ main (int argc, char **argv )
          case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
          case oHomedir: break;
          case oNoBatch: opt.batch = 0; break;
-         case oWithKeyData: opt.with_key_data=1; /* fall thru */
+
+         case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
          case oWithColons: opt.with_colons=':'; break;
 
+          case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
+          case oWithSigList: opt.list_sigs = 1; break;  
+
          case oSkipVerify: opt.skip_verify=1; break;
+
+         case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
+         case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
+
          case oCompressKeys: opt.compress_keys = 1; break;
          case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
            /* There are many programs (like mutt) that call gpg with
@@ -2401,7 +2500,10 @@ main (int argc, char **argv )
          case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
          case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
          case oS2KCount:
-           opt.s2k_count=encode_s2k_iterations(pargs.r.ret_int);
+           if (pargs.r.ret_int)
+              opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
+            else
+              opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
            break;
           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
          case oNoEncryptTo: opt.no_encrypt_to = 1; break;
@@ -2465,21 +2567,21 @@ main (int argc, char **argv )
          case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
          case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
          case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
-         case oPasswd:
+         case oPassphrase:
            set_passphrase_from_string(pargs.r.ret_str);
            break;
-         case oPasswdFD:
+         case oPassphraseFD:
             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
             break;
-         case oPasswdFile:
-            pwfd = open_info_file (pargs.r.ret_str, 0);
+         case oPassphraseFile:
+            pwfd = open_info_file (pargs.r.ret_str, 0, 1);
             break;
-         case oPasswdRepeat: opt.passwd_repeat=pargs.r.ret_int; break;
+         case oPassphraseRepeat: opt.passphrase_repeat=pargs.r.ret_int; break;
          case oCommandFD:
             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
             break;
          case oCommandFile:
-            opt.command_fd = open_info_file (pargs.r.ret_str, 0);
+            opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
             break;
          case oCipherAlgo: 
             def_cipher_string = xstrdup(pargs.r.ret_str);
@@ -2695,7 +2797,7 @@ main (int argc, char **argv )
                                   "--keyserver-options ","http-proxy");
                break;
          case oFastListMode: opt.fast_list_mode = 1; break;
-         case oFixedListMode: opt.fixed_list_mode = 1; break;
+         case oFixedListMode: /* Dummy */ break;
          case oListOnly: opt.list_only=1; break;
          case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
          case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
@@ -2760,12 +2862,23 @@ main (int argc, char **argv )
            pers_compress_list=pargs.r.ret_str;
            break;
           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
-          case oDisplay: opt.display = pargs.r.ret_str; break;
-          case oTTYname: opt.ttyname = pargs.r.ret_str; break;
-          case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
+
+          case oDisplay:
+            set_opt_session_env ("DISPLAY", pargs.r.ret_str);
+            break;
+          case oTTYname:
+            set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
+            break;
+          case oTTYtype:
+            set_opt_session_env ("TERM", pargs.r.ret_str);
+            break;
+          case oXauthority:
+            set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
+            break;
+
           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
-          case oXauthority: opt.xauthority = pargs.r.ret_str; break;
+
          case oGroup: add_group(pargs.r.ret_str); break;
          case oUnGroup: rm_group(pargs.r.ret_str); break;
          case oNoGroups:
@@ -2837,9 +2950,20 @@ main (int argc, char **argv )
            opt.flags.allow_multiple_messages=0;
            break;
 
+          case oFakedSystemTime:
+            {
+              time_t faked_time = isotime2epoch (pargs.r.ret_str); 
+              if (faked_time == (time_t)(-1))
+                faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
+              gnupg_set_time (faked_time, 0);
+            }
+            break;
+
          case oNoop: break;
 
-         default : pargs.err = configfp? 1:2; break;
+         default: 
+            pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
+            break;
          }
       }
 
@@ -2863,10 +2987,11 @@ main (int argc, char **argv )
        directly after the option parsing. */
     if (cmd == aGPGConfList)
       {
-        gpgconf_list (save_configname);
+        gpgconf_list (save_configname ? save_configname : default_configname);
         g10_exit (0);
       }
     xfree (save_configname);
+    xfree (default_configname);
 
     if( nogreeting )
        greeting = 0;
@@ -2877,15 +3002,15 @@ main (int argc, char **argv )
        fprintf(stderr, "%s\n", strusage(15) );
     }
 #ifdef IS_DEVELOPMENT_VERSION
-    if( !opt.batch )
+    if (!opt.batch)
       {
        const char *s;
 
-       if((s=strusage(20)))
+       if((s=strusage(25)))
          log_info("%s\n",s);
-       if((s=strusage(21)))
+       if((s=strusage(26)))
          log_info("%s\n",s);
-       if((s=strusage(22)))
+       if((s=strusage(27)))
          log_info("%s\n",s);
       }
 #endif
@@ -2900,14 +3025,14 @@ main (int argc, char **argv )
         log_set_prefix (NULL, 1|2|4);
       }
 
-#ifdef USE_CAMELLIA    
-    /* We better also print a runtime warning if people build it with
-       support for Camellia (which is not yet defined by OpenPGP). */
-    log_info ("WARNING: This version has been built with support for the "
-              "Camellia cipher.\n");
-    log_info ("         It is for testing only and is NOT for production "
-              "use!\n");
-#endif
+    /* Older Libgcrypts fail with an assertion during DSA key
+       generation.  Better disable DSA2 entirely. */
+    if (opt.flags.dsa2 && !gcry_check_version ("1.4.0") )
+      {
+        log_info ("WARNING: "
+                  "DSA2 is only available with Libgcrypt 1.4 and later\n");
+        opt.flags.dsa2 = 0;
+      }
 
     if (opt.verbose > 2)
         log_info ("using character set `%s'\n", get_native_charset ());
@@ -2940,6 +3065,17 @@ main (int argc, char **argv )
     if( opt.batch )
        tty_batchmode( 1 );
 
+    if (gnupg_faked_time_p ())
+      {
+        gnupg_isotime_t tbuf;
+        
+        log_info (_("WARNING: running with faked system time: "));
+        gnupg_get_isotime (tbuf);
+        dump_isotime (tbuf);
+        log_printf ("\n");
+      }
+    
+
     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
 
     if(require_secmem && !got_secmem)
@@ -3025,6 +3161,7 @@ main (int argc, char **argv )
       }
     else if(PGP6)
       {
+       opt.disable_mdc=1;
        opt.escape_from=1;
        opt.force_v3_sigs=1;
        opt.ask_sig_expire=0;
@@ -3106,11 +3243,6 @@ main (int argc, char **argv )
        keygen_set_std_prefs(opt.def_preference_list,0))
       log_error(_("invalid default preferences\n"));
 
-    /* We provide defaults for the personal digest list.  This is
-       SHA-1. */
-    if(!pers_digest_list)
-      pers_digest_list="h2";
-
     if(pers_cipher_list &&
        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
       log_error(_("invalid personal cipher preferences\n"));
@@ -3232,20 +3364,14 @@ main (int argc, char **argv )
        xfree(p);
     }
 
-    if( !cmd && opt.fingerprint && !with_fpr ) {
-       set_cmd( &cmd, aListKeys);
-    }
-
-    /* kludge to let -sat generate a clear text signature */
-    if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
+    /* If there is no command but the --fingerprint is given, default
+       to the --list-keys command.  */
+    if (!cmd && fpr_maybe_cmd)
       {
-        log_info ("compatibility note:\n");
-        log_info ("\"-sat\" won't generate clear signed messages in "
-                  "future versions\n");
-        log_info ("Use \"--clearsign\" instead of \"-sat\"\n");
-       cmd = aClearsign;
+       set_cmd (&cmd, aListKeys);
       }
 
+
     if( opt.verbose > 1 )
        set_packet_list_mode(1);
 
@@ -3260,22 +3386,12 @@ main (int argc, char **argv )
     if( ALWAYS_ADD_KEYRINGS 
         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) ) 
       {
-        if (ALWAYS_ADD_KEYRINGS
-            || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
-                && cmd != aVerify && cmd != aSym))
-          {
-            if (!sec_nrings || default_keyring) /* add default secret rings */
-              keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
-            for (sl = sec_nrings; sl; sl = sl->next)
-              keydb_add_resource ( sl->d, 0, 1 );
-          }
-       if( !nrings || default_keyring )  /* add default ring */
-           keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
-       for(sl = nrings; sl; sl = sl->next )
-           keydb_add_resource ( sl->d, sl->flags, 0 );
+       if (!nrings || default_keyring)  /* Add default ring. */
+           keydb_add_resource ("pubring" EXTSEP_S "gpg", 4);
+       for (sl = nrings; sl; sl = sl->next )
+          keydb_add_resource (sl->d, sl->flags);
       }
     FREE_STRLIST(nrings);
-    FREE_STRLIST(sec_nrings);
 
     if (cmd == aGPGConfTest)
       g10_exit(0);
@@ -3296,8 +3412,8 @@ main (int argc, char **argv )
       case aGenRandom:
       case aDeArmor:
       case aEnArmor:
-      case aFixTrustDB:
        break;
+      case aFixTrustDB:
       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
       default: rc = setup_trustdb(1, trustdb_name ); break;
@@ -3336,26 +3452,26 @@ main (int argc, char **argv )
       case aStore: /* only store the file */
        if( argc > 1 )
            wrong_args(_("--store [filename]"));
-       if( (rc = encode_store(fname)) )
+       if( (rc = encrypt_store(fname)) )
            log_error ("storing `%s' failed: %s\n",
                        print_fname_stdin(fname),g10_errstr(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)) )
+       if( (rc = encrypt_symmetric(fname)) )
             log_error (_("symmetric encryption of `%s' failed: %s\n"),
                         print_fname_stdin(fname),g10_errstr(rc) );
        break;
 
       case aEncr: /* encrypt the given file */
        if(multifile)
-         encode_crypt_files(argc, argv, remusr);
+         encrypt_crypt_files(argc, argv, remusr);
        else
          {
            if( argc > 1 )
              wrong_args(_("--encrypt [filename]"));
-           if( (rc = encode_crypt(fname,remusr,0)) )
+           if( (rc = encrypt_crypt (-1, fname, remusr, 0, NULL, -1)) )
              log_error("%s: encryption failed: %s\n",
                        print_fname_stdin(fname), g10_errstr(rc) );
          }
@@ -3376,7 +3492,7 @@ main (int argc, char **argv )
                      " while in %s mode\n"),compliance_option_string());
        else
          {
-           if( (rc = encode_crypt(fname,remusr,1)) )
+           if( (rc = encrypt_crypt (-1, fname, remusr, 1, NULL, -1)) )
              log_error("%s: encryption failed: %s\n",
                        print_fname_stdin(fname), g10_errstr(rc) );
          }
@@ -3503,7 +3619,7 @@ main (int argc, char **argv )
 
        append_to_strlist( &sl, "save" );
        username = make_username( fname );
-       keyedit_menu(fname, locusr, sl, 0, 0 );
+       keyedit_menu (username, locusr, sl, 0, 0 );
        xfree(username);
        free_strlist(sl);
        break;
@@ -3524,6 +3640,17 @@ main (int argc, char **argv )
        xfree(username);
        break;
 
+      case aPasswd:
+        if (argc != 1)
+          wrong_args (_("--passwd <user-id>"));
+        else
+          {
+            username = make_username (fname);
+            keyedit_passwd (username);
+            xfree (username);
+          }
+        break;
+
       case aDeleteKeys:
       case aDeleteSecretKeys:
       case aDeleteSecretAndPublicKeys:
@@ -3545,7 +3672,7 @@ main (int argc, char **argv )
        sl = NULL;
        for( ; argc; argc--, argv++ )
            add_to_strlist2( &sl, *argv, utf8_strings );
-       public_key_list( sl );
+       public_key_list( sl, 0 );
        free_strlist(sl);
        break;
       case aListSecretKeys:
@@ -3555,6 +3682,13 @@ main (int argc, char **argv )
        secret_key_list( sl );
        free_strlist(sl);
        break;
+      case aLocateKeys:
+       sl = NULL;
+       for (; argc; argc--, argv++)
+          add_to_strlist2( &sl, *argv, utf8_strings );
+       public_key_list (sl, 1);
+       free_strlist (sl);
+       break;
 
       case aKeygen: /* generate a key */
        if( opt.batch ) {
@@ -3688,29 +3822,30 @@ main (int argc, char **argv )
        {   int mode = argc < 2 ? 0 : atoi(*argv);
 
            if( mode == 1 && argc == 2 ) {
-               mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
+               mpi_print (es_stdout,
+                           generate_public_prime( atoi(argv[1]) ), 1);
            }
            else if( mode == 2 && argc == 3 ) {
-               mpi_printstdout, generate_elg_prime(
+               mpi_print (es_stdout, generate_elg_prime(
                                             0, atoi(argv[1]),
                                             atoi(argv[2]), NULL,NULL ), 1);
            }
            else if( mode == 3 && argc == 3 ) {
                MPI *factors;
-               mpi_printstdout, generate_elg_prime(
+               mpi_print (es_stdout, generate_elg_prime(
                                             1, atoi(argv[1]),
                                             atoi(argv[2]), NULL,&factors ), 1);
                putchar('\n');
-               mpi_printstdout, factors[0], 1 ); /* print q */
+               mpi_print (es_stdout, factors[0], 1 ); /* print q */
            }
            else if( mode == 4 && argc == 3 ) {
                MPI g = mpi_alloc(1);
-               mpi_printstdout, generate_elg_prime(
+               mpi_print (es_stdout, generate_elg_prime(
                                                 0, atoi(argv[1]),
                                                 atoi(argv[2]), g, NULL ), 1);
                putchar('\n');
-               mpi_printstdout, g, 1 );
-               mpi_free(g);
+               mpi_print (es_stdout, g, 1 );
+               mpi_free (g);
            }
            else
                wrong_args("--gen-prime mode bits [qbits] ");
@@ -3812,9 +3947,7 @@ main (int argc, char **argv )
        break;
 
       case aFixTrustDB:
-       log_error("this command is not yet implemented.\n");
-       log_error("A workaround is to use \"--export-ownertrust\", remove\n");
-       log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
+        how_to_fix_the_trustdb ();
        break;
 
       case aListTrustPath:
@@ -3849,7 +3982,7 @@ main (int argc, char **argv )
       case aCardStatus:
         if (argc)
             wrong_args ("--card-status");
-        card_status (stdout, NULL, 0);
+        card_status (es_stdout, NULL, 0);
         break;
 
       case aCardEdit:
@@ -3888,8 +4021,10 @@ main (int argc, char **argv )
        if( argc > 1 )
            wrong_args(_("[filename]"));
        /* Issue some output for the unix newbie */
-       if( !fname && !opt.outfile && isatty( fileno(stdin) )
-               && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
+       if (!fname && !opt.outfile
+            && gnupg_isatty (fileno (stdin))
+            && gnupg_isatty (fileno (stdout))
+            && gnupg_isatty (fileno (stderr)))
            log_info(_("Go ahead and type your message ...\n"));
 
        a = iobuf_open(fname);
@@ -3897,7 +4032,7 @@ main (int argc, char **argv )
           {
             iobuf_close (a);
             a = NULL;
-            errno = EPERM;
+            gpg_err_set_errno (EPERM);
           }
        if( !a )
            log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
@@ -4084,7 +4219,7 @@ print_mds( const char *fname, int algo )
           {
             fclose (fp);
             fp = NULL;
-            errno = EPERM;
+            gpg_err_set_errno (EPERM);
           }
     }
     if( !fp ) {
@@ -4099,8 +4234,8 @@ print_mds( const char *fname, int algo )
        gcry_md_enable (md, GCRY_MD_MD5);
        gcry_md_enable (md, GCRY_MD_SHA1);
        gcry_md_enable (md, GCRY_MD_RMD160);
-        if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
-          gcry_md_enable (md, DIGEST_ALGO_SHA224);
+        if (!openpgp_md_test_algo (GCRY_MD_SHA224))
+          gcry_md_enable (md, GCRY_MD_SHA224);
         if (!openpgp_md_test_algo (GCRY_MD_SHA256))
           gcry_md_enable (md, GCRY_MD_SHA256);
         if (!openpgp_md_test_algo (GCRY_MD_SHA384))
@@ -4121,9 +4256,10 @@ print_mds( const char *fname, int algo )
             else {
                 print_hashline( md, GCRY_MD_MD5, fname );
                 print_hashline( md, GCRY_MD_SHA1, fname );
-                print_hashline( md, GCRY_MD_RMD160, fname );
-                if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
-                    print_hashline (md, DIGEST_ALGO_SHA224, fname);
+                if (!gcry_md_test_algo (GCRY_MD_RMD160))
+                    print_hashline( md, GCRY_MD_RMD160, fname );
+                if (!gcry_md_test_algo (GCRY_MD_SHA224))
+                    print_hashline (md, GCRY_MD_SHA224, fname);
                 if (!gcry_md_test_algo (GCRY_MD_SHA256))
                     print_hashline( md, GCRY_MD_SHA256, fname );
                 if (!gcry_md_test_algo (GCRY_MD_SHA384))
@@ -4138,9 +4274,10 @@ print_mds( const char *fname, int algo )
             else {
                 print_hex( md, GCRY_MD_MD5, fname );
                 print_hex( md, GCRY_MD_SHA1, fname );
-                print_hex( md, GCRY_MD_RMD160, fname );
-                if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
-                    print_hex (md, DIGEST_ALGO_SHA224, fname);
+                if (!gcry_md_test_algo (GCRY_MD_RMD160))
+                    print_hex( md, GCRY_MD_RMD160, fname );
+                if (!gcry_md_test_algo (GCRY_MD_SHA224))
+                    print_hex (md, GCRY_MD_SHA224, fname);
                 if (!gcry_md_test_algo (GCRY_MD_SHA256))
                     print_hex( md, GCRY_MD_SHA256, fname );
                 if (!gcry_md_test_algo (GCRY_MD_SHA384))
@@ -4248,4 +4385,3 @@ add_keyserver_url( const char *string, int which )
   if(critical)
     sl->flags |= 1;    
 }
-