g10/gpg.c

   1 /* gpg.c - The GnuPG utility (main for gpg)
   2  * Copyright (C) 1998-2011 Free Software Foundation, Inc.
   3  * Copyright (C) 1997-2016 Werner Koch
   4  * Copyright (C) 2015-2016 g10 Code GmbH
   5  *
   6  * This file is part of GnuPG.
   7  *
   8  * GnuPG is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * GnuPG is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <errno.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <unistd.h>
  29 #ifdef HAVE_STAT
  30 #include <sys/stat.h> /* for stat() */
  31 #endif
  32 #include <fcntl.h>
  33 #ifdef HAVE_W32_SYSTEM
  34 # ifdef HAVE_WINSOCK2_H
  35 #  include <winsock2.h>
  36 # endif
  37 # include <windows.h>
  38 #endif
  39
  40 #define INCLUDED_BY_MAIN_MODULE 1
  41 #include "gpg.h"
  42 #include <assuan.h>
  43 #include "../common/iobuf.h"
  44 #include "util.h"
  45 #include "packet.h"
  46 #include "membuf.h"
  47 #include "main.h"
  48 #include "options.h"
  49 #include "keydb.h"
  50 #include "trustdb.h"
  51 #include "filter.h"
  52 #include "ttyio.h"
  53 #include "i18n.h"
  54 #include "sysutils.h"
  55 #include "status.h"
  56 #include "keyserver-internal.h"
  57 #include "exec.h"
  58 #include "gc-opt-flags.h"
  59 #include "asshelp.h"
  60 #include "call-dirmngr.h"
  61 #include "tofu.h"
  62 #include "../common/init.h"
  63 #include "../common/mbox-util.h"
  64 #include "../common/shareddefs.h"
  65
  66 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
  67 #define MY_O_BINARY  O_BINARY
  68 #ifndef S_IRGRP
  69 # define S_IRGRP 0
  70 # define S_IWGRP 0
  71 #endif
  72 #else
  73 #define MY_O_BINARY  0
  74 #endif
  75
  76
  77 enum cmd_and_opt_values
  78   {
  79     aNull = 0,
  80     oArmor        = 'a',
  81     aDetachedSign = 'b',
  82     aSym          = 'c',
  83     aDecrypt      = 'd',
  84     aEncr         = 'e',
  85     oRecipientFile       = 'f',
  86     oHiddenRecipientFile = 'F',
  87     oInteractive  = 'i',
  88     aListKeys     = 'k',
  89     oDryRun       = 'n',
  90     oOutput       = 'o',
  91     oQuiet        = 'q',
  92     oRecipient    = 'r',
  93     oHiddenRecipient = 'R',
  94     aSign         = 's',
  95     oTextmodeShort= 't',
  96     oLocalUser    = 'u',
  97     oVerbose      = 'v',
  98     oCompress     = 'z',
  99     oSetNotation  = 'N',
 100     aListSecretKeys = 'K',
 101     oBatch        = 500,
 102     oMaxOutput,
 103     oInputSizeHint,
 104     oSigNotation,
 105     oCertNotation,
 106     oShowNotation,
 107     oNoShowNotation,
 108     aEncrFiles,
 109     aEncrSym,
 110     aDecryptFiles,
 111     aClearsign,
 112     aStore,
 113     aQuickKeygen,
 114     aFullKeygen,
 115     aKeygen,
 116     aSignEncr,
 117     aSignEncrSym,
 118     aSignSym,
 119     aSignKey,
 120     aLSignKey,
 121     aQuickSignKey,
 122     aQuickLSignKey,
 123     aQuickAddUid,
 124     aQuickAddKey,
 125     aQuickRevUid,
 126     aQuickSetExpire,
 127     aListConfig,
 128     aListGcryptConfig,
 129     aGPGConfList,
 130     aGPGConfTest,
 131     aListPackets,
 132     aEditKey,
 133     aDeleteKeys,
 134     aDeleteSecretKeys,
 135     aDeleteSecretAndPublicKeys,
 136     aImport,
 137     aFastImport,
 138     aVerify,
 139     aVerifyFiles,
 140     aListSigs,
 141     aSendKeys,
 142     aRecvKeys,
 143     aLocateKeys,
 144     aSearchKeys,
 145     aRefreshKeys,
 146     aFetchKeys,
 147     aExport,
 148     aExportSecret,
 149     aExportSecretSub,
 150     aExportSshKey,
 151     aCheckKeys,
 152     aGenRevoke,
 153     aDesigRevoke,
 154     aPrimegen,
 155     aPrintMD,
 156     aPrintMDs,
 157     aCheckTrustDB,
 158     aUpdateTrustDB,
 159     aFixTrustDB,
 160     aListTrustDB,
 161     aListTrustPath,
 162     aExportOwnerTrust,
 163     aImportOwnerTrust,
 164     aDeArmor,
 165     aEnArmor,
 166     aGenRandom,
 167     aRebuildKeydbCaches,
 168     aCardStatus,
 169     aCardEdit,
 170     aChangePIN,
 171     aPasswd,
 172     aServer,
 173     aTOFUPolicy,
 174
 175     oMimemode,
 176     oTextmode,
 177     oNoTextmode,
 178     oExpert,
 179     oNoExpert,
 180     oDefSigExpire,
 181     oAskSigExpire,
 182     oNoAskSigExpire,
 183     oDefCertExpire,
 184     oAskCertExpire,
 185     oNoAskCertExpire,
 186     oDefCertLevel,
 187     oMinCertLevel,
 188     oAskCertLevel,
 189     oNoAskCertLevel,
 190     oFingerprint,
 191     oWithFingerprint,
 192     oWithSubkeyFingerprint,
 193     oWithICAOSpelling,
 194     oWithKeygrip,
 195     oWithSecret,
 196     oWithWKDHash,
 197     oWithColons,
 198     oWithKeyData,
 199     oWithTofuInfo,
 200     oWithSigList,
 201     oWithSigCheck,
 202     oAnswerYes,
 203     oAnswerNo,
 204     oKeyring,
 205     oPrimaryKeyring,
 206     oSecretKeyring,
 207     oShowKeyring,
 208     oDefaultKey,
 209     oDefRecipient,
 210     oDefRecipientSelf,
 211     oNoDefRecipient,
 212     oTrySecretKey,
 213     oOptions,
 214     oDebug,
 215     oDebugLevel,
 216     oDebugAll,
 217     oDebugIOLBF,
 218     oStatusFD,
 219     oStatusFile,
 220     oAttributeFD,
 221     oAttributeFile,
 222     oEmitVersion,
 223     oNoEmitVersion,
 224     oCompletesNeeded,
 225     oMarginalsNeeded,
 226     oMaxCertDepth,
 227     oLoadExtension,
 228     oCompliance,
 229     oGnuPG,
 230     oRFC2440,
 231     oRFC4880,
 232     oRFC4880bis,
 233     oOpenPGP,
 234     oPGP6,
 235     oPGP7,
 236     oPGP8,
 237     oDE_VS,
 238     oRFC2440Text,
 239     oNoRFC2440Text,
 240     oCipherAlgo,
 241     oDigestAlgo,
 242     oCertDigestAlgo,
 243     oCompressAlgo,
 244     oCompressLevel,
 245     oBZ2CompressLevel,
 246     oBZ2DecompressLowmem,
 247     oPassphrase,
 248     oPassphraseFD,
 249     oPassphraseFile,
 250     oPassphraseRepeat,
 251     oPinentryMode,
 252     oCommandFD,
 253     oCommandFile,
 254     oQuickRandom,
 255     oNoVerbose,
 256     oTrustDBName,
 257     oNoSecmemWarn,
 258     oRequireSecmem,
 259     oNoRequireSecmem,
 260     oNoPermissionWarn,
 261     oNoMDCWarn,
 262     oNoArmor,
 263     oNoDefKeyring,
 264     oNoKeyring,
 265     oNoGreeting,
 266     oNoTTY,
 267     oNoOptions,
 268     oNoBatch,
 269     oHomedir,
 270     oSkipVerify,
 271     oSkipHiddenRecipients,
 272     oNoSkipHiddenRecipients,
 273     oAlwaysTrust,
 274     oTrustModel,
 275     oForceOwnertrust,
 276     oSetFilename,
 277     oForYourEyesOnly,
 278     oNoForYourEyesOnly,
 279     oSetPolicyURL,
 280     oSigPolicyURL,
 281     oCertPolicyURL,
 282     oShowPolicyURL,
 283     oNoShowPolicyURL,
 284     oSigKeyserverURL,
 285     oUseEmbeddedFilename,
 286     oNoUseEmbeddedFilename,
 287     oComment,
 288     oDefaultComment,
 289     oNoComments,
 290     oThrowKeyids,
 291     oNoThrowKeyids,
 292     oShowPhotos,
 293     oNoShowPhotos,
 294     oPhotoViewer,
 295     oForceMDC,
 296     oNoForceMDC,
 297     oDisableMDC,
 298     oNoDisableMDC,
 299     oS2KMode,
 300     oS2KDigest,
 301     oS2KCipher,
 302     oS2KCount,
 303     oDisplayCharset,
 304     oNotDashEscaped,
 305     oEscapeFrom,
 306     oNoEscapeFrom,
 307     oLockOnce,
 308     oLockMultiple,
 309     oLockNever,
 310     oKeyServer,
 311     oKeyServerOptions,
 312     oImportOptions,
 313     oImportFilter,
 314     oExportOptions,
 315     oExportFilter,
 316     oListOptions,
 317     oVerifyOptions,
 318     oTempDir,
 319     oExecPath,
 320     oEncryptTo,
 321     oHiddenEncryptTo,
 322     oNoEncryptTo,
 323     oEncryptToDefaultKey,
 324     oLoggerFD,
 325     oLoggerFile,
 326     oUtf8Strings,
 327     oNoUtf8Strings,
 328     oDisableCipherAlgo,
 329     oDisablePubkeyAlgo,
 330     oAllowNonSelfsignedUID,
 331     oNoAllowNonSelfsignedUID,
 332     oAllowFreeformUID,
 333     oNoAllowFreeformUID,
 334     oAllowSecretKeyImport,
 335     oEnableSpecialFilenames,
 336     oNoLiteral,
 337     oSetFilesize,
 338     oHonorHttpProxy,
 339     oFastListMode,
 340     oListOnly,
 341     oIgnoreTimeConflict,
 342     oIgnoreValidFrom,
 343     oIgnoreCrcError,
 344     oIgnoreMDCError,
 345     oShowSessionKey,
 346     oOverrideSessionKey,
 347     oOverrideSessionKeyFD,
 348     oNoRandomSeedFile,
 349     oAutoKeyRetrieve,
 350     oNoAutoKeyRetrieve,
 351     oUseAgent,
 352     oNoUseAgent,
 353     oGpgAgentInfo,
 354     oMergeOnly,
 355     oTryAllSecrets,
 356     oTrustedKey,
 357     oNoExpensiveTrustChecks,
 358     oFixedListMode,
 359     oLegacyListMode,
 360     oNoSigCache,
 361     oAutoCheckTrustDB,
 362     oNoAutoCheckTrustDB,
 363     oPreservePermissions,
 364     oDefaultPreferenceList,
 365     oDefaultKeyserverURL,
 366     oPersonalCipherPreferences,
 367     oPersonalDigestPreferences,
 368     oPersonalCompressPreferences,
 369     oAgentProgram,
 370     oDirmngrProgram,
 371     oDisplay,
 372     oTTYname,
 373     oTTYtype,
 374     oLCctype,
 375     oLCmessages,
 376     oXauthority,
 377     oGroup,
 378     oUnGroup,
 379     oNoGroups,
 380     oStrict,
 381     oNoStrict,
 382     oMangleDosFilenames,
 383     oNoMangleDosFilenames,
 384     oEnableProgressFilter,
 385     oMultifile,
 386     oKeyidFormat,
 387     oExitOnStatusWriteError,
 388     oLimitCardInsertTries,
 389     oReaderPort,
 390     octapiDriver,
 391     opcscDriver,
 392     oDisableCCID,
 393     oRequireCrossCert,
 394     oNoRequireCrossCert,
 395     oAutoKeyLocate,
 396     oNoAutoKeyLocate,
 397     oAllowMultisigVerification,
 398     oEnableLargeRSA,
 399     oDisableLargeRSA,
 400     oEnableDSA2,
 401     oDisableDSA2,
 402     oAllowMultipleMessages,
 403     oNoAllowMultipleMessages,
 404     oAllowWeakDigestAlgos,
 405     oFakedSystemTime,
 406     oNoAutostart,
 407     oPrintPKARecords,
 408     oPrintDANERecords,
 409     oTOFUDefaultPolicy,
 410     oTOFUDBFormat,
 411     oDefaultNewKeyAlgo,
 412     oWeakDigest,
 413     oUnwrap,
 414     oOnlySignTextIDs,
 415     oDisableSignerUID,
 416     oSender,
 417
 418     oNoop
 419   };
 420
 421
 422 static ARGPARSE_OPTS opts[] = {
 423
 424   ARGPARSE_group (300, N_("@Commands:\n ")),
 425
 426   ARGPARSE_c (aSign, "sign", N_("make a signature")),
 427   ARGPARSE_c (aClearsign, "clear-sign", N_("make a clear text signature")),
 428   ARGPARSE_c (aClearsign, "clearsign", "@"),
 429   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
 430   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
 431   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
 432   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
 433   ARGPARSE_c (aStore, "store",     "@"),
 434   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
 435   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
 436   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
 437   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
 438   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
 439   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
 440   ARGPARSE_c (aListSigs, "list-signatures", N_("list keys and signatures")),
 441   ARGPARSE_c (aListSigs, "list-sigs", "@"),
 442   ARGPARSE_c (aCheckKeys, "check-signatures",
 443               N_("list and check key signatures")),
 444   ARGPARSE_c (aCheckKeys, "check-sigs", "@"),
 445   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
 446   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
 447   ARGPARSE_c (aKeygen,      "generate-key",
 448               N_("generate a new key pair")),
 449   ARGPARSE_c (aKeygen,      "gen-key", "@"),
 450   ARGPARSE_c (aQuickKeygen, "quick-generate-key" ,
 451               N_("quickly generate a new key pair")),
 452   ARGPARSE_c (aQuickKeygen, "quick-gen-key", "@"),
 453   ARGPARSE_c (aQuickAddUid,  "quick-add-uid",
 454               N_("quickly add a new user-id")),
 455   ARGPARSE_c (aQuickAddUid,  "quick-adduid", "@"),
 456   ARGPARSE_c (aQuickAddKey,  "quick-add-key", "@"),
 457   ARGPARSE_c (aQuickAddKey,  "quick-addkey", "@"),
 458   ARGPARSE_c (aQuickRevUid,  "quick-revoke-uid",
 459               N_("quickly revoke a user-id")),
 460   ARGPARSE_c (aQuickRevUid,  "quick-revuid", "@"),
 461   ARGPARSE_c (aQuickSetExpire,  "quick-set-expire",
 462               N_("quickly set a new expiration date")),
 463   ARGPARSE_c (aFullKeygen,  "full-generate-key" ,
 464               N_("full featured key pair generation")),
 465   ARGPARSE_c (aFullKeygen,  "full-gen-key", "@"),
 466   ARGPARSE_c (aGenRevoke, "generate-revocation",
 467               N_("generate a revocation certificate")),
 468   ARGPARSE_c (aGenRevoke, "gen-revoke", "@"),
 469   ARGPARSE_c (aDeleteKeys,"delete-keys",
 470               N_("remove keys from the public keyring")),
 471   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
 472               N_("remove keys from the secret keyring")),
 473   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
 474               N_("quickly sign a key")),
 475   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
 476               N_("quickly sign a key locally")),
 477   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
 478   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
 479   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
 480   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
 481   ARGPARSE_c (aPasswd,   "change-passphrase", N_("change a passphrase")),
 482   ARGPARSE_c (aPasswd,   "passwd", "@"),
 483   ARGPARSE_c (aDesigRevoke, "generate-designated-revocation", "@"),
 484   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
 485   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
 486   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a keyserver") ),
 487   ARGPARSE_c (aRecvKeys, "receive-keys" , N_("import keys from a keyserver") ),
 488   ARGPARSE_c (aRecvKeys, "recv-keys"     , "@"),
 489   ARGPARSE_c (aSearchKeys, "search-keys" ,
 490               N_("search for keys on a keyserver") ),
 491   ARGPARSE_c (aRefreshKeys, "refresh-keys",
 492               N_("update all keys from a keyserver")),
 493   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
 494   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
 495   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
 496   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
 497   ARGPARSE_c (aExportSshKey, "export-ssh-key", "@" ),
 498   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
 499   ARGPARSE_c (aFastImport, "fast-import", "@"),
 500 #ifdef ENABLE_CARD_SUPPORT
 501   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
 502   ARGPARSE_c (aCardEdit,   "edit-card",  N_("change data on a card")),
 503   ARGPARSE_c (aCardEdit,   "card-edit", "@"),
 504   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
 505 #endif
 506   ARGPARSE_c (aListConfig, "list-config", "@"),
 507   ARGPARSE_c (aListGcryptConfig, "list-gcrypt-config", "@"),
 508   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
 509   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
 510   ARGPARSE_c (aListPackets, "list-packets","@"),
 511
 512 #ifndef NO_TRUST_MODELS
 513   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
 514   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
 515   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
 516               N_("update the trust database")),
 517   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
 518   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
 519 #endif
 520
 521   ARGPARSE_c (aDeArmor, "dearmor", "@"),
 522   ARGPARSE_c (aDeArmor, "dearmour", "@"),
 523   ARGPARSE_c (aEnArmor, "enarmor", "@"),
 524   ARGPARSE_c (aEnArmor, "enarmour", "@"),
 525   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
 526   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
 527   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
 528   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
 529   ARGPARSE_c (aTOFUPolicy, "tofu-policy",
 530               N_("|VALUE|set the TOFU policy for a key")),
 531
 532   ARGPARSE_group (301, N_("@\nOptions:\n ")),
 533
 534   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
 535   ARGPARSE_s_n (oArmor, "armour", "@"),
 536
 537   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
 538   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
 539   ARGPARSE_s_s (oRecipientFile, "recipient-file", "@"),
 540   ARGPARSE_s_s (oHiddenRecipientFile, "hidden-recipient-file", "@"),
 541   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
 542   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
 543   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
 544   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
 545
 546   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
 547   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
 548   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
 549   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
 550   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
 551   ARGPARSE_s_n (oEncryptToDefaultKey, "encrypt-to-default-key", "@"),
 552   ARGPARSE_s_s (oLocalUser, "local-user",
 553                 N_("|USER-ID|use USER-ID to sign or decrypt")),
 554   ARGPARSE_s_s (oSender, "sender", "@"),
 555
 556   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
 557
 558   ARGPARSE_s_i (oCompress, NULL,
 559                 N_("|N|set compress level to N (0 disables)")),
 560   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
 561   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
 562   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
 563
 564   ARGPARSE_s_n (oMimemode, "mimemode", "@"),
 565   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
 566   ARGPARSE_s_n (oTextmode,   "textmode", N_("use canonical text mode")),
 567   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
 568
 569   ARGPARSE_s_n (oExpert,      "expert", "@"),
 570   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
 571
 572   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
 573   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
 574   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
 575   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
 576   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
 577   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
 578   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
 579   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
 580   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
 581   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
 582
 583   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
 584   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
 585   ARGPARSE_s_s (oInputSizeHint, "input-size-hint", "@"),
 586
 587   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
 588   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
 589   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
 590
 591   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
 592   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
 593   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
 594   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
 595
 596   ARGPARSE_s_n (oDisableSignerUID, "disable-signer-uid", "@"),
 597
 598   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
 599   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
 600
 601   ARGPARSE_s_n (oBatch, "batch", "@"),
 602   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
 603   ARGPARSE_s_n (oAnswerNo, "no", "@"),
 604   ARGPARSE_s_s (oKeyring, "keyring", "@"),
 605   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
 606   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
 607   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
 608   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
 609
 610   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
 611   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
 612   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
 613   ARGPARSE_s_s (oImportFilter,  "import-filter", "@"),
 614   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
 615   ARGPARSE_s_s (oExportFilter,  "export-filter", "@"),
 616   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
 617   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
 618
 619   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
 620   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
 621   ARGPARSE_s_s (oOptions, "options", "@"),
 622
 623   ARGPARSE_s_s (oDebug, "debug", "@"),
 624   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
 625   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
 626   ARGPARSE_s_n (oDebugIOLBF, "debug-iolbf", "@"),
 627   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
 628   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
 629   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
 630   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
 631
 632   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
 633   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
 634   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
 635   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
 636
 637   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
 638
 639   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
 640   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
 641   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
 642   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
 643   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
 644   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
 645   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
 646   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
 647   ARGPARSE_s_n (oRFC4880bis, "rfc4880bis", "@"),
 648   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
 649   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
 650   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
 651   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
 652
 653   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
 654   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
 655   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
 656   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
 657   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
 658   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
 659   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
 660   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
 661   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
 662   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
 663   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
 664   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
 665   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
 666   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
 667   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
 668   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
 669   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
 670   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
 671   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
 672
 673   ARGPARSE_group (302, N_(
 674   "@\n(See the man page for a complete listing of all commands and options)\n"
 675                       )),
 676
 677   ARGPARSE_group (303, N_("@\nExamples:\n\n"
 678     " -se -r Bob [file]          sign and encrypt for user Bob\n"
 679     " --clear-sign [file]        make a clear text signature\n"
 680     " --detach-sign [file]       make a detached signature\n"
 681     " --list-keys [names]        show keys\n"
 682     " --fingerprint [names]      show fingerprints\n")),
 683
 684   /* More hidden commands and options. */
 685   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
 686 #ifndef NO_TRUST_MODELS
 687   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
 688 #endif
 689
 690   /* Not yet used:
 691      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
 692   ARGPARSE_c (aDeleteSecretAndPublicKeys,
 693               "delete-secret-and-public-keys", "@"),
 694   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
 695
 696   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
 697   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
 698   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
 699   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
 700   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
 701   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
 702   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
 703   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
 704   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
 705
 706 #ifndef NO_TRUST_MODELS
 707   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
 708   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
 709   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
 710   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
 711 #endif
 712
 713   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
 714   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
 715   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
 716   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
 717   ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
 718   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
 719   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
 720   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
 721   ARGPARSE_s_n (oNoKeyring, "no-keyring", "@"),
 722   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
 723   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
 724   ARGPARSE_s_s (oHomedir, "homedir", "@"),
 725   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
 726   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
 727   ARGPARSE_s_n (oWithTofuInfo,"with-tofu-info", "@"),
 728   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
 729   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
 730   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
 731   ARGPARSE_c (aListKeys, "list-key", "@"),   /* alias */
 732   ARGPARSE_c (aListSigs, "list-sig", "@"),   /* alias */
 733   ARGPARSE_c (aCheckKeys, "check-sig", "@"), /* alias */
 734   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
 735   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
 736   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
 737   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
 738 #ifndef NO_TRUST_MODELS
 739   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
 740 #endif
 741   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
 742   ARGPARSE_s_s (oTOFUDefaultPolicy, "tofu-default-policy", "@"),
 743   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
 744   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
 745   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
 746   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
 747   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
 748   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
 749   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
 750   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
 751   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
 752   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
 753   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
 754   ARGPARSE_s_s (oComment, "comment", "@"),
 755   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
 756   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
 757   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
 758   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
 759   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
 760   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
 761   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
 762   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
 763   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
 764   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
 765   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
 766   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
 767   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
 768   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
 769   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
 770   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
 771   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
 772   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
 773   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
 774   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprint", "@"),
 775   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprints", "@"),
 776   ARGPARSE_s_n (oWithICAOSpelling, "with-icao-spelling", "@"),
 777   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
 778   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
 779   ARGPARSE_s_n (oWithWKDHash,     "with-wkd-hash", "@"),
 780   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
 781   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
 782   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
 783   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
 784   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
 785   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
 786   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
 787   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
 788   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
 789   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
 790   ARGPARSE_s_n (oLegacyListMode, "legacy-list-mode", "@"),
 791   ARGPARSE_s_n (oListOnly, "list-only", "@"),
 792   ARGPARSE_s_n (oPrintPKARecords, "print-pka-records", "@"),
 793   ARGPARSE_s_n (oPrintDANERecords, "print-dane-records", "@"),
 794   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
 795   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
 796   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
 797   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
 798   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
 799   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
 800   ARGPARSE_s_i (oOverrideSessionKeyFD, "override-session-key-fd", "@"),
 801   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
 802   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
 803   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
 804   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
 805   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
 806   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
 807   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
 808   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
 809   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
 810   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
 811   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
 812   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
 813   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
 814   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
 815   ARGPARSE_s_s (oPersonalCompressPreferences,
 816                                          "personal-compress-preferences", "@"),
 817   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
 818   ARGPARSE_s_s (oWeakDigest, "weak-digest","@"),
 819   ARGPARSE_s_n (oUnwrap, "unwrap", "@"),
 820   ARGPARSE_s_n (oOnlySignTextIDs, "only-sign-text-ids", "@"),
 821
 822   /* Aliases.  I constantly mistype these, and assume other people do
 823      as well. */
 824   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
 825   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
 826   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
 827
 828   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
 829   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
 830   ARGPARSE_s_s (oDisplay,    "display",    "@"),
 831   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
 832   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
 833   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
 834   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
 835   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
 836   ARGPARSE_s_s (oGroup,      "group",      "@"),
 837   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
 838   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
 839   ARGPARSE_s_n (oStrict,     "strict",     "@"),
 840   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
 841   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
 842   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
 843   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
 844   ARGPARSE_s_n (oMultifile, "multifile", "@"),
 845   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
 846   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
 847   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
 848
 849   ARGPARSE_s_n (oAllowMultisigVerification,
 850                 "allow-multisig-verification", "@"),
 851   ARGPARSE_s_n (oEnableLargeRSA, "enable-large-rsa", "@"),
 852   ARGPARSE_s_n (oDisableLargeRSA, "disable-large-rsa", "@"),
 853   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
 854   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
 855   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
 856   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
 857   ARGPARSE_s_n (oAllowWeakDigestAlgos, "allow-weak-digest-algos", "@"),
 858
 859   ARGPARSE_s_s (oDefaultNewKeyAlgo, "default-new-key-algo", "@"),
 860
 861   /* These two are aliases to help users of the PGP command line
 862      product use gpg with minimal pain.  Many commands are common
 863      already as they seem to have borrowed commands from us.  Now I'm
 864      returning the favor. */
 865   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
 866   ARGPARSE_s_s (oRecipient, "user", "@"),
 867
 868   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
 869   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
 870   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
 871   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
 872
 873   /* New options.  Fixme: Should go more to the top.  */
 874   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
 875   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
 876   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
 877
 878   /* Dummy options with warnings.  */
 879   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
 880   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
 881   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
 882   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
 883   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
 884   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
 885   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
 886   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
 887   ARGPARSE_s_s (oTOFUDBFormat, "tofu-db-format", "@"),
 888
 889   /* Dummy options.  */
 890   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
 891   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
 892   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
 893   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
 894   ARGPARSE_s_n (oNoop, "force-v3-sigs", "@"),
 895   ARGPARSE_s_n (oNoop, "no-force-v3-sigs", "@"),
 896   ARGPARSE_s_n (oNoop, "force-v4-certs", "@"),
 897   ARGPARSE_s_n (oNoop, "no-force-v4-certs", "@"),
 898
 899   ARGPARSE_end ()
 900 };
 901
 902
 903 /* The list of supported debug flags.  */
 904 static struct debug_flags_s debug_flags [] =
 905   {
 906     { DBG_PACKET_VALUE , "packet"  },
 907     { DBG_MPI_VALUE    , "mpi"     },
 908     { DBG_CRYPTO_VALUE , "crypto"  },
 909     { DBG_FILTER_VALUE , "filter"  },
 910     { DBG_IOBUF_VALUE  , "iobuf"   },
 911     { DBG_MEMORY_VALUE , "memory"  },
 912     { DBG_CACHE_VALUE  , "cache"   },
 913     { DBG_MEMSTAT_VALUE, "memstat" },
 914     { DBG_TRUST_VALUE  , "trust"   },
 915     { DBG_HASHING_VALUE, "hashing" },
 916     { DBG_IPC_VALUE    , "ipc"     },
 917     { DBG_CLOCK_VALUE  , "clock"   },
 918     { DBG_LOOKUP_VALUE , "lookup"  },
 919     { DBG_EXTPROG_VALUE, "extprog" },
 920     { 0, NULL }
 921   };
 922
 923
 924 #ifdef ENABLE_SELINUX_HACKS
 925 #define ALWAYS_ADD_KEYRINGS 1
 926 #else
 927 #define ALWAYS_ADD_KEYRINGS 0
 928 #endif
 929
 930
 931 int g10_errors_seen = 0;
 932
 933 static int utf8_strings = 0;
 934 static int maybe_setuid = 1;
 935
 936 static char *build_list( const char *text, char letter,
 937                          const char *(*mapf)(int), int (*chkf)(int) );
 938 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
 939                         enum cmd_and_opt_values new_cmd );
 940 static void print_mds( const char *fname, int algo );
 941 static void add_notation_data( const char *string, int which );
 942 static void add_policy_url( const char *string, int which );
 943 static void add_keyserver_url( const char *string, int which );
 944 static void emergency_cleanup (void);
 945 static void read_sessionkey_from_fd (int fd);
 946
 947
 948 static char *
 949 make_libversion (const char *libname, const char *(*getfnc)(const char*))
 950 {
 951   const char *s;
 952   char *result;
 953
 954   if (maybe_setuid)
 955     {
 956       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
 957       maybe_setuid = 0;
 958     }
 959   s = getfnc (NULL);
 960   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
 961   strcpy (stpcpy (stpcpy (result, libname), " "), s);
 962   return result;
 963 }
 964
 965
 966 static int
 967 build_list_pk_test_algo (int algo)
 968 {
 969   /* Show only one "RSA" string.  If RSA_E or RSA_S is available RSA
 970      is also available.  */
 971   if (algo == PUBKEY_ALGO_RSA_E
 972       || algo == PUBKEY_ALGO_RSA_S)
 973     return GPG_ERR_DIGEST_ALGO;
 974
 975   return openpgp_pk_test_algo (algo);
 976 }
 977
 978 static const char *
 979 build_list_pk_algo_name (int algo)
 980 {
 981   return openpgp_pk_algo_name (algo);
 982 }
 983
 984 static int
 985 build_list_cipher_test_algo (int algo)
 986 {
 987   return openpgp_cipher_test_algo (algo);
 988 }
 989
 990 static const char *
 991 build_list_cipher_algo_name (int algo)
 992 {
 993   return openpgp_cipher_algo_name (algo);
 994 }
 995
 996 static int
 997 build_list_md_test_algo (int algo)
 998 {
 999   /* By default we do not accept MD5 based signatures.  To avoid
1000      confusion we do not announce support for it either.  */
1001   if (algo == DIGEST_ALGO_MD5)
1002     return GPG_ERR_DIGEST_ALGO;
1003
1004   return openpgp_md_test_algo (algo);
1005 }
1006
1007 static const char *
1008 build_list_md_algo_name (int algo)
1009 {
1010   return openpgp_md_algo_name (algo);
1011 }
1012
1013
1014 static const char *
1015 my_strusage( int level )
1016 {
1017   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
1018   const char *p;
1019
1020     switch( level ) {
1021       case 11: p = "@GPG@ (@GNUPG@)";
1022         break;
1023       case 13: p = VERSION; break;
1024       case 17: p = PRINTABLE_OS_NAME; break;
1025       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
1026
1027     case 20:
1028       if (!ver_gcry)
1029         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
1030       p = ver_gcry;
1031       break;
1032
1033 #ifdef IS_DEVELOPMENT_VERSION
1034       case 25:
1035         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
1036         break;
1037       case 26:
1038         p="It is only intended for test purposes and should NOT be";
1039         break;
1040       case 27:
1041         p="used in a production environment or with production keys!";
1042         break;
1043 #endif
1044
1045       case 1:
1046       case 40:  p =
1047             _("Usage: @GPG@ [options] [files] (-h for help)");
1048         break;
1049       case 41:  p =
1050             _("Syntax: @GPG@ [options] [files]\n"
1051               "Sign, check, encrypt or decrypt\n"
1052               "Default operation depends on the input data\n");
1053         break;
1054
1055       case 31: p = "\nHome: "; break;
1056 #ifndef __riscos__
1057       case 32: p = gnupg_homedir (); break;
1058 #else /* __riscos__ */
1059       case 32: p = make_filename(gnupg_homedir (), NULL); break;
1060 #endif /* __riscos__ */
1061       case 33: p = _("\nSupported algorithms:\n"); break;
1062       case 34:
1063         if (!pubkeys)
1064             pubkeys = build_list (_("Pubkey: "), 1,
1065                                   build_list_pk_algo_name,
1066                                   build_list_pk_test_algo );
1067         p = pubkeys;
1068         break;
1069       case 35:
1070         if( !ciphers )
1071             ciphers = build_list(_("Cipher: "), 'S',
1072                                  build_list_cipher_algo_name,
1073                                  build_list_cipher_test_algo );
1074         p = ciphers;
1075         break;
1076       case 36:
1077         if( !digests )
1078             digests = build_list(_("Hash: "), 'H',
1079                                  build_list_md_algo_name,
1080                                  build_list_md_test_algo );
1081         p = digests;
1082         break;
1083       case 37:
1084         if( !zips )
1085             zips = build_list(_("Compression: "),'Z',
1086                               compress_algo_to_string,
1087                               check_compress_algo);
1088         p = zips;
1089         break;
1090
1091       default:  p = NULL;
1092     }
1093     return p;
1094 }
1095
1096
1097 static char *
1098 build_list (const char *text, char letter,
1099             const char * (*mapf)(int), int (*chkf)(int))
1100 {
1101   membuf_t mb;
1102   int indent;
1103   int i, j, len;
1104   const char *s;
1105   char *string;
1106
1107   if (maybe_setuid)
1108     gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
1109
1110   indent = utf8_charcount (text, -1);
1111   len = 0;
1112   init_membuf (&mb, 512);
1113
1114   for (i=0; i <= 110; i++ )
1115     {
1116       if (!chkf (i) && (s = mapf (i)))
1117         {
1118           if (mb.len - len > 60)
1119             {
1120               put_membuf_str (&mb, ",\n");
1121               len = mb.len;
1122               for (j=0; j < indent; j++)
1123                 put_membuf_str (&mb, " ");
1124             }
1125           else if (mb.len)
1126             put_membuf_str (&mb, ", ");
1127           else
1128             put_membuf_str (&mb, text);
1129
1130           put_membuf_str (&mb, s);
1131           if (opt.verbose && letter)
1132             {
1133               char num[20];
1134               if (letter == 1)
1135                 snprintf (num, sizeof num, " (%d)", i);
1136               else
1137                 snprintf (num, sizeof num, " (%c%d)", letter, i);
1138               put_membuf_str (&mb, num);
1139             }
1140         }
1141     }
1142   if (mb.len)
1143     put_membuf_str (&mb, "\n");
1144   put_membuf (&mb, "", 1);
1145
1146   string = get_membuf (&mb, NULL);
1147   return xrealloc (string, strlen (string)+1);
1148 }
1149
1150
1151 static void
1152 wrong_args( const char *text)
1153 {
1154   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), GPG_NAME, text);
1155   g10_exit(2);
1156 }
1157
1158
1159 static char *
1160 make_username( const char *string )
1161 {
1162     char *p;
1163     if( utf8_strings )
1164         p = xstrdup(string);
1165     else
1166         p = native_to_utf8( string );
1167     return p;
1168 }
1169
1170
1171 static void
1172 set_opt_session_env (const char *name, const char *value)
1173 {
1174   gpg_error_t err;
1175
1176   err = session_env_setenv (opt.session_env, name, value);
1177   if (err)
1178     log_fatal ("error setting session environment: %s\n",
1179                gpg_strerror (err));
1180 }
1181
1182
1183 /* Setup the debugging.  With a LEVEL of NULL only the active debug
1184    flags are propagated to the subsystems.  With LEVEL set, a specific
1185    set of debug flags is set; thus overriding all flags already
1186    set. */
1187 static void
1188 set_debug (const char *level)
1189 {
1190   int numok = (level && digitp (level));
1191   int numlvl = numok? atoi (level) : 0;
1192
1193   if (!level)
1194     ;
1195   else if (!strcmp (level, "none") || (numok && numlvl < 1))
1196     opt.debug = 0;
1197   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
1198     opt.debug = DBG_MEMSTAT_VALUE;
1199   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
1200     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
1201   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
1202     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
1203                  |DBG_CACHE_VALUE|DBG_LOOKUP|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
1204   else if (!strcmp (level, "guru") || numok)
1205     {
1206       opt.debug = ~0;
1207       /* Unless the "guru" string has been used we don't want to allow
1208          hashing debugging.  The rationale is that people tend to
1209          select the highest debug value and would then clutter their
1210          disk with debug files which may reveal confidential data.  */
1211       if (numok)
1212         opt.debug &= ~(DBG_HASHING_VALUE);
1213     }
1214   else
1215     {
1216       log_error (_("invalid debug-level '%s' given\n"), level);
1217       g10_exit (2);
1218     }
1219
1220   if ((opt.debug & DBG_MEMORY_VALUE))
1221     memory_debug_mode = 1;
1222   if ((opt.debug & DBG_MEMSTAT_VALUE))
1223     memory_stat_debug_mode = 1;
1224   if (DBG_MPI)
1225     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
1226   if (DBG_CRYPTO)
1227     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
1228   if ((opt.debug & DBG_IOBUF_VALUE))
1229     iobuf_debug_mode = 1;
1230   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1231
1232   if (opt.debug)
1233     parse_debug_flag (NULL, &opt.debug, debug_flags);
1234 }
1235
1236
1237 /* We set the screen dimensions for UI purposes.  Do not allow screens
1238    smaller than 80x24 for the sake of simplicity. */
1239 static void
1240 set_screen_dimensions(void)
1241 {
1242 #ifndef HAVE_W32_SYSTEM
1243   char *str;
1244
1245   str=getenv("COLUMNS");
1246   if(str)
1247     opt.screen_columns=atoi(str);
1248
1249   str=getenv("LINES");
1250   if(str)
1251     opt.screen_lines=atoi(str);
1252 #endif
1253
1254   if(opt.screen_columns<80 || opt.screen_columns>255)
1255     opt.screen_columns=80;
1256
1257   if(opt.screen_lines<24 || opt.screen_lines>255)
1258     opt.screen_lines=24;
1259 }
1260
1261
1262 /* Helper to open a file FNAME either for reading or writing to be
1263    used with --status-file etc functions.  Not generally useful but it
1264    avoids the riscos specific functions and well some Windows people
1265    might like it too.  Prints an error message and returns -1 on
1266    error.  On success the file descriptor is returned.  */
1267 static int
1268 open_info_file (const char *fname, int for_write, int binary)
1269 {
1270 #ifdef __riscos__
1271   return riscos_fdopenfile (fname, for_write);
1272 #elif defined (ENABLE_SELINUX_HACKS)
1273   /* We can't allow these even when testing for a secured filename
1274      because files to be secured might not yet been secured.  This is
1275      similar to the option file but in that case it is unlikely that
1276      sensitive information may be retrieved by means of error
1277      messages.  */
1278   (void)fname;
1279   (void)for_write;
1280   (void)binary;
1281   return -1;
1282 #else
1283   int fd;
1284
1285   if (binary)
1286     binary = MY_O_BINARY;
1287
1288 /*   if (is_secured_filename (fname)) */
1289 /*     { */
1290 /*       fd = -1; */
1291 /*       gpg_err_set_errno (EPERM); */
1292 /*     } */
1293 /*   else */
1294 /*     { */
1295       do
1296         {
1297           if (for_write)
1298             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
1299                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1300           else
1301             fd = open (fname, O_RDONLY | binary);
1302         }
1303       while (fd == -1 && errno == EINTR);
1304 /*     } */
1305   if ( fd == -1)
1306     log_error ( for_write? _("can't create '%s': %s\n")
1307                          : _("can't open '%s': %s\n"), fname, strerror(errno));
1308
1309   return fd;
1310 #endif
1311 }
1312
1313 static void
1314 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1315 {
1316     enum cmd_and_opt_values cmd = *ret_cmd;
1317
1318     if( !cmd || cmd == new_cmd )
1319         cmd = new_cmd;
1320     else if( cmd == aSign && new_cmd == aEncr )
1321         cmd = aSignEncr;
1322     else if( cmd == aEncr && new_cmd == aSign )
1323         cmd = aSignEncr;
1324     else if( cmd == aSign && new_cmd == aSym )
1325         cmd = aSignSym;
1326     else if( cmd == aSym && new_cmd == aSign )
1327         cmd = aSignSym;
1328     else if( cmd == aSym && new_cmd == aEncr )
1329         cmd = aEncrSym;
1330     else if( cmd == aEncr && new_cmd == aSym )
1331         cmd = aEncrSym;
1332     else if (cmd == aSignEncr && new_cmd == aSym)
1333         cmd = aSignEncrSym;
1334     else if (cmd == aSignSym && new_cmd == aEncr)
1335         cmd = aSignEncrSym;
1336     else if (cmd == aEncrSym && new_cmd == aSign)
1337         cmd = aSignEncrSym;
1338     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1339              || ( cmd == aClearsign && new_cmd == aSign )  )
1340         cmd = aClearsign;
1341     else {
1342         log_error(_("conflicting commands\n"));
1343         g10_exit(2);
1344     }
1345
1346     *ret_cmd = cmd;
1347 }
1348
1349
1350 static void
1351 add_group(char *string)
1352 {
1353   char *name,*value;
1354   struct groupitem *item;
1355
1356   /* Break off the group name */
1357   name=strsep(&string,"=");
1358   if(string==NULL)
1359     {
1360       log_error(_("no = sign found in group definition '%s'\n"),name);
1361       return;
1362     }
1363
1364   trim_trailing_ws(name,strlen(name));
1365
1366   /* Does this group already exist? */
1367   for(item=opt.grouplist;item;item=item->next)
1368     if(strcasecmp(item->name,name)==0)
1369       break;
1370
1371   if(!item)
1372     {
1373       item=xmalloc(sizeof(struct groupitem));
1374       item->name=name;
1375       item->next=opt.grouplist;
1376       item->values=NULL;
1377       opt.grouplist=item;
1378     }
1379
1380   /* Break apart the values */
1381   while ((value= strsep(&string," \t")))
1382     {
1383       if (*value)
1384         add_to_strlist2(&item->values,value,utf8_strings);
1385     }
1386 }
1387
1388
1389 static void
1390 rm_group(char *name)
1391 {
1392   struct groupitem *item,*last=NULL;
1393
1394   trim_trailing_ws(name,strlen(name));
1395
1396   for(item=opt.grouplist;item;last=item,item=item->next)
1397     {
1398       if(strcasecmp(item->name,name)==0)
1399         {
1400           if(last)
1401             last->next=item->next;
1402           else
1403             opt.grouplist=item->next;
1404
1405           free_strlist(item->values);
1406           xfree(item);
1407           break;
1408         }
1409     }
1410 }
1411
1412
1413 /* We need to check three things.
1414
1415    0) The homedir.  It must be x00, a directory, and owned by the
1416    user.
1417
1418    1) The options/gpg.conf file.  Okay unless it or its containing
1419    directory is group or other writable or not owned by us.  Disable
1420    exec in this case.
1421
1422    2) Extensions.  Same as #1.
1423
1424    Returns true if the item is unsafe. */
1425 static int
1426 check_permissions (const char *path, int item)
1427 {
1428 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1429   static int homedir_cache=-1;
1430   char *tmppath,*dir;
1431   struct stat statbuf,dirbuf;
1432   int homedir=0,ret=0,checkonly=0;
1433   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1434
1435   if(opt.no_perm_warn)
1436     return 0;
1437
1438   log_assert(item==0 || item==1 || item==2);
1439
1440   /* extensions may attach a path */
1441   if(item==2 && path[0]!=DIRSEP_C)
1442     {
1443       if(strchr(path,DIRSEP_C))
1444         tmppath=make_filename(path,NULL);
1445       else
1446         tmppath=make_filename(gnupg_libdir (),path,NULL);
1447     }
1448   else
1449     tmppath=xstrdup(path);
1450
1451   /* If the item is located in the homedir, but isn't the homedir,
1452      don't continue if we already checked the homedir itself.  This is
1453      to avoid user confusion with an extra options file warning which
1454      could be rectified if the homedir itself had proper
1455      permissions. */
1456   if(item!=0 && homedir_cache>-1
1457      && !ascii_strncasecmp (gnupg_homedir (), tmppath,
1458                             strlen (gnupg_homedir ())))
1459     {
1460       ret=homedir_cache;
1461       goto end;
1462     }
1463
1464   /* It's okay if the file or directory doesn't exist */
1465   if(stat(tmppath,&statbuf)!=0)
1466     {
1467       ret=0;
1468       goto end;
1469     }
1470
1471   /* Now check the enclosing directory.  Theoretically, we could walk
1472      this test up to the root directory /, but for the sake of sanity,
1473      I'm stopping at one level down. */
1474   dir=make_dirname(tmppath);
1475
1476   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1477     {
1478       /* Weird error */
1479       ret=1;
1480       goto end;
1481     }
1482
1483   xfree(dir);
1484
1485   /* Assume failure */
1486   ret=1;
1487
1488   if(item==0)
1489     {
1490       /* The homedir must be x00, a directory, and owned by the user. */
1491
1492       if(S_ISDIR(statbuf.st_mode))
1493         {
1494           if(statbuf.st_uid==getuid())
1495             {
1496               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1497                 ret=0;
1498               else
1499                 perm=1;
1500             }
1501           else
1502             own=1;
1503
1504           homedir_cache=ret;
1505         }
1506     }
1507   else if(item==1 || item==2)
1508     {
1509       /* The options or extension file.  Okay unless it or its
1510          containing directory is group or other writable or not owned
1511          by us or root. */
1512
1513       if(S_ISREG(statbuf.st_mode))
1514         {
1515           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1516             {
1517               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1518                 {
1519                   /* it's not writable, so make sure the enclosing
1520                      directory is also not writable */
1521                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1522                     {
1523                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1524                         ret=0;
1525                       else
1526                         enc_dir_perm=1;
1527                     }
1528                   else
1529                     enc_dir_own=1;
1530                 }
1531               else
1532                 {
1533                   /* it's writable, so the enclosing directory had
1534                      better not let people get to it. */
1535                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1536                     {
1537                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1538                         ret=0;
1539                       else
1540                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1541                     }
1542                   else
1543                     enc_dir_own=1;
1544                 }
1545             }
1546           else
1547             own=1;
1548         }
1549     }
1550   else
1551     BUG();
1552
1553   if(!checkonly)
1554     {
1555       if(own)
1556         {
1557           if(item==0)
1558             log_info(_("WARNING: unsafe ownership on"
1559                        " homedir '%s'\n"),tmppath);
1560           else if(item==1)
1561             log_info(_("WARNING: unsafe ownership on"
1562                        " configuration file '%s'\n"),tmppath);
1563           else
1564             log_info(_("WARNING: unsafe ownership on"
1565                        " extension '%s'\n"),tmppath);
1566         }
1567       if(perm)
1568         {
1569           if(item==0)
1570             log_info(_("WARNING: unsafe permissions on"
1571                        " homedir '%s'\n"),tmppath);
1572           else if(item==1)
1573             log_info(_("WARNING: unsafe permissions on"
1574                        " configuration file '%s'\n"),tmppath);
1575           else
1576             log_info(_("WARNING: unsafe permissions on"
1577                        " extension '%s'\n"),tmppath);
1578         }
1579       if(enc_dir_own)
1580         {
1581           if(item==0)
1582             log_info(_("WARNING: unsafe enclosing directory ownership on"
1583                        " homedir '%s'\n"),tmppath);
1584           else if(item==1)
1585             log_info(_("WARNING: unsafe enclosing directory ownership on"
1586                        " configuration file '%s'\n"),tmppath);
1587           else
1588             log_info(_("WARNING: unsafe enclosing directory ownership on"
1589                        " extension '%s'\n"),tmppath);
1590         }
1591       if(enc_dir_perm)
1592         {
1593           if(item==0)
1594             log_info(_("WARNING: unsafe enclosing directory permissions on"
1595                        " homedir '%s'\n"),tmppath);
1596           else if(item==1)
1597             log_info(_("WARNING: unsafe enclosing directory permissions on"
1598                        " configuration file '%s'\n"),tmppath);
1599           else
1600             log_info(_("WARNING: unsafe enclosing directory permissions on"
1601                        " extension '%s'\n"),tmppath);
1602         }
1603     }
1604
1605  end:
1606   xfree(tmppath);
1607
1608   if(homedir)
1609     homedir_cache=ret;
1610
1611   return ret;
1612
1613 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1614   (void)path;
1615   (void)item;
1616   return 0;
1617 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1618 }
1619
1620
1621 /* Print the OpenPGP defined algo numbers.  */
1622 static void
1623 print_algo_numbers(int (*checker)(int))
1624 {
1625   int i,first=1;
1626
1627   for(i=0;i<=110;i++)
1628     {
1629       if(!checker(i))
1630         {
1631           if(first)
1632             first=0;
1633           else
1634             es_printf (";");
1635           es_printf ("%d",i);
1636         }
1637     }
1638 }
1639
1640
1641 static void
1642 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1643 {
1644   int i,first=1;
1645
1646   for(i=0;i<=110;i++)
1647     {
1648       if(!checker(i))
1649         {
1650           if(first)
1651             first=0;
1652           else
1653             es_printf (";");
1654           es_printf ("%s",mapper(i));
1655         }
1656     }
1657 }
1658
1659 /* In the future, we can do all sorts of interesting configuration
1660    output here.  For now, just give "group" as the Enigmail folks need
1661    it, and pubkey, cipher, hash, and compress as they may be useful
1662    for frontends. */
1663 static void
1664 list_config(char *items)
1665 {
1666   int show_all = !items;
1667   char *name = NULL;
1668   const char *s;
1669   struct groupitem *giter;
1670   int first, iter;
1671
1672   if(!opt.with_colons)
1673     return;
1674
1675   while(show_all || (name=strsep(&items," ")))
1676     {
1677       int any=0;
1678
1679       if(show_all || ascii_strcasecmp(name,"group")==0)
1680         {
1681           for (giter = opt.grouplist; giter; giter = giter->next)
1682             {
1683               strlist_t sl;
1684
1685               es_fprintf (es_stdout, "cfg:group:");
1686               es_write_sanitized (es_stdout, giter->name, strlen(giter->name),
1687                                   ":", NULL);
1688               es_putc (':', es_stdout);
1689
1690               for(sl=giter->values; sl; sl=sl->next)
1691                 {
1692                   es_write_sanitized (es_stdout, sl->d, strlen (sl->d),
1693                                       ":;", NULL);
1694                   if(sl->next)
1695                     es_printf(";");
1696                 }
1697
1698               es_printf("\n");
1699             }
1700
1701           any=1;
1702         }
1703
1704       if(show_all || ascii_strcasecmp(name,"version")==0)
1705         {
1706           es_printf("cfg:version:");
1707           es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
1708           es_printf ("\n");
1709           any=1;
1710         }
1711
1712       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1713         {
1714           es_printf ("cfg:pubkey:");
1715           print_algo_numbers (build_list_pk_test_algo);
1716           es_printf ("\n");
1717           any=1;
1718         }
1719
1720       if(show_all || ascii_strcasecmp(name,"pubkeyname")==0)
1721         {
1722           es_printf ("cfg:pubkeyname:");
1723           print_algo_names (build_list_pk_test_algo,
1724                             build_list_pk_algo_name);
1725           es_printf ("\n");
1726           any=1;
1727         }
1728
1729       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1730         {
1731           es_printf ("cfg:cipher:");
1732           print_algo_numbers (build_list_cipher_test_algo);
1733           es_printf ("\n");
1734           any=1;
1735         }
1736
1737       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1738         {
1739           es_printf ("cfg:ciphername:");
1740           print_algo_names (build_list_cipher_test_algo,
1741                             build_list_cipher_algo_name);
1742           es_printf ("\n");
1743           any = 1;
1744         }
1745
1746       if(show_all
1747          || ascii_strcasecmp(name,"digest")==0
1748          || ascii_strcasecmp(name,"hash")==0)
1749         {
1750           es_printf ("cfg:digest:");
1751           print_algo_numbers (build_list_md_test_algo);
1752           es_printf ("\n");
1753           any=1;
1754         }
1755
1756       if (show_all
1757           || !ascii_strcasecmp(name,"digestname")
1758           || !ascii_strcasecmp(name,"hashname"))
1759         {
1760           es_printf ("cfg:digestname:");
1761           print_algo_names (build_list_md_test_algo,
1762                             build_list_md_algo_name);
1763           es_printf ("\n");
1764           any=1;
1765         }
1766
1767       if(show_all || ascii_strcasecmp(name,"compress")==0)
1768         {
1769           es_printf ("cfg:compress:");
1770           print_algo_numbers(check_compress_algo);
1771           es_printf ("\n");
1772           any=1;
1773         }
1774
1775       if(show_all || ascii_strcasecmp (name, "compressname") == 0)
1776         {
1777           es_printf ("cfg:compressname:");
1778           print_algo_names (check_compress_algo,
1779                             compress_algo_to_string);
1780           es_printf ("\n");
1781           any=1;
1782         }
1783
1784       if (show_all || !ascii_strcasecmp(name,"ccid-reader-id"))
1785         {
1786           /* We ignore this for GnuPG 1.4 backward compatibility.  */
1787           any=1;
1788         }
1789
1790       if (show_all || !ascii_strcasecmp (name,"curve"))
1791         {
1792           es_printf ("cfg:curve:");
1793           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first=0)
1794             es_printf ("%s%s", first?"":";", s);
1795           es_printf ("\n");
1796           any=1;
1797         }
1798
1799       /* Curve OIDs are rarely useful and thus only printed if requested.  */
1800       if (name && !ascii_strcasecmp (name,"curveoid"))
1801         {
1802           es_printf ("cfg:curveoid:");
1803           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first = 0)
1804             {
1805               s = openpgp_curve_to_oid (s, NULL);
1806               es_printf ("%s%s", first?"":";", s? s:"[?]");
1807             }
1808           es_printf ("\n");
1809           any=1;
1810         }
1811
1812       if(show_all)
1813         break;
1814
1815       if(!any)
1816         log_error(_("unknown configuration item '%s'\n"),name);
1817     }
1818 }
1819
1820
1821 /* List options and default values in the GPG Conf format.  This is a
1822    new tool distributed with gnupg 1.9.x but we also want some limited
1823    support in older gpg versions.  The output is the name of the
1824    configuration file and a list of options available for editing by
1825    gpgconf.  */
1826 static void
1827 gpgconf_list (const char *configfile)
1828 {
1829   char *configfile_esc = percent_escape (configfile, NULL);
1830
1831   es_printf ("%s-%s.conf:%lu:\"%s\n",
1832              GPGCONF_NAME, GPG_NAME,
1833              GC_OPT_FLAG_DEFAULT,
1834              configfile_esc ? configfile_esc : "/dev/null");
1835   es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1836   es_printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1837   es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1838   es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1839   es_printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1840   es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1841   es_printf ("try-secret-key:%lu:\n", GC_OPT_FLAG_NONE);
1842   es_printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1843   es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1844   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1845   es_printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1846   es_printf ("compliance:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, "gnupg");
1847   es_printf ("default-new-key-algo:%lu:\n", GC_OPT_FLAG_NONE);
1848
1849   /* The next one is an info only item and should match the macros at
1850      the top of keygen.c  */
1851   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1852              get_default_pubkey_algo ());
1853
1854   xfree (configfile_esc);
1855 }
1856
1857
1858 static int
1859 parse_subpacket_list(char *list)
1860 {
1861   char *tok;
1862   byte subpackets[128],i;
1863   int count=0;
1864
1865   if(!list)
1866     {
1867       /* No arguments means all subpackets */
1868       memset(subpackets+1,1,sizeof(subpackets)-1);
1869       count=127;
1870     }
1871   else
1872     {
1873       memset(subpackets,0,sizeof(subpackets));
1874
1875       /* Merge with earlier copy */
1876       if(opt.show_subpackets)
1877         {
1878           byte *in;
1879
1880           for(in=opt.show_subpackets;*in;in++)
1881             {
1882               if(*in>127 || *in<1)
1883                 BUG();
1884
1885               if(!subpackets[*in])
1886                 count++;
1887               subpackets[*in]=1;
1888             }
1889         }
1890
1891       while((tok=strsep(&list," ,")))
1892         {
1893           if(!*tok)
1894             continue;
1895
1896           i=atoi(tok);
1897           if(i>127 || i<1)
1898             return 0;
1899
1900           if(!subpackets[i])
1901             count++;
1902           subpackets[i]=1;
1903         }
1904     }
1905
1906   xfree(opt.show_subpackets);
1907   opt.show_subpackets=xmalloc(count+1);
1908   opt.show_subpackets[count--]=0;
1909
1910   for(i=1;i<128 && count>=0;i++)
1911     if(subpackets[i])
1912       opt.show_subpackets[count--]=i;
1913
1914   return 1;
1915 }
1916
1917
1918 static int
1919 parse_list_options(char *str)
1920 {
1921   char *subpackets=""; /* something that isn't NULL */
1922   struct parse_options lopts[]=
1923     {
1924       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1925        N_("display photo IDs during key listings")},
1926       {"show-usage",LIST_SHOW_USAGE,NULL,
1927        N_("show key usage information during key listings")},
1928       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1929        N_("show policy URLs during signature listings")},
1930       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1931        N_("show all notations during signature listings")},
1932       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1933        N_("show IETF standard notations during signature listings")},
1934       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1935        NULL},
1936       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1937        N_("show user-supplied notations during signature listings")},
1938       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1939        N_("show preferred keyserver URLs during signature listings")},
1940       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1941        N_("show user ID validity during key listings")},
1942       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1943        N_("show revoked and expired user IDs in key listings")},
1944       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1945        N_("show revoked and expired subkeys in key listings")},
1946       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1947        N_("show the keyring name in key listings")},
1948       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1949        N_("show expiration dates during signature listings")},
1950       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1951        NULL},
1952       {NULL,0,NULL,NULL}
1953     };
1954
1955   /* C99 allows for non-constant initializers, but we'd like to
1956      compile everywhere, so fill in the show-sig-subpackets argument
1957      here.  Note that if the parse_options array changes, we'll have
1958      to change the subscript here. */
1959   lopts[13].value=&subpackets;
1960
1961   if(parse_options(str,&opt.list_options,lopts,1))
1962     {
1963       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1964         {
1965           /* Unset so users can pass multiple lists in. */
1966           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1967           if(!parse_subpacket_list(subpackets))
1968             return 0;
1969         }
1970       else if(subpackets==NULL && opt.show_subpackets)
1971         {
1972           /* User did 'no-show-subpackets' */
1973           xfree(opt.show_subpackets);
1974           opt.show_subpackets=NULL;
1975         }
1976
1977       return 1;
1978     }
1979   else
1980     return 0;
1981 }
1982
1983
1984 /* Collapses argc/argv into a single string that must be freed */
1985 static char *
1986 collapse_args(int argc,char *argv[])
1987 {
1988   char *str=NULL;
1989   int i,first=1,len=0;
1990
1991   for(i=0;i<argc;i++)
1992     {
1993       len+=strlen(argv[i])+2;
1994       str=xrealloc(str,len);
1995       if(first)
1996         {
1997           str[0]='\0';
1998           first=0;
1999         }
2000       else
2001         strcat(str," ");
2002
2003       strcat(str,argv[i]);
2004     }
2005
2006   return str;
2007 }
2008
2009
2010 #ifndef NO_TRUST_MODELS
2011 static void
2012 parse_trust_model(const char *model)
2013 {
2014   if(ascii_strcasecmp(model,"pgp")==0)
2015     opt.trust_model=TM_PGP;
2016   else if(ascii_strcasecmp(model,"classic")==0)
2017     opt.trust_model=TM_CLASSIC;
2018   else if(ascii_strcasecmp(model,"always")==0)
2019     opt.trust_model=TM_ALWAYS;
2020   else if(ascii_strcasecmp(model,"direct")==0)
2021     opt.trust_model=TM_DIRECT;
2022 #ifdef USE_TOFU
2023   else if(ascii_strcasecmp(model,"tofu")==0)
2024     opt.trust_model=TM_TOFU;
2025   else if(ascii_strcasecmp(model,"tofu+pgp")==0)
2026     opt.trust_model=TM_TOFU_PGP;
2027 #endif /*USE_TOFU*/
2028   else if(ascii_strcasecmp(model,"auto")==0)
2029     opt.trust_model=TM_AUTO;
2030   else
2031     log_error("unknown trust model '%s'\n",model);
2032 }
2033 #endif /*NO_TRUST_MODELS*/
2034
2035
2036 static int
2037 parse_tofu_policy (const char *policystr)
2038 {
2039 #ifdef USE_TOFU
2040   struct { const char *keyword; int policy; } list[] = {
2041     { "auto",    TOFU_POLICY_AUTO },
2042     { "good",    TOFU_POLICY_GOOD },
2043     { "unknown", TOFU_POLICY_UNKNOWN },
2044     { "bad",     TOFU_POLICY_BAD },
2045     { "ask",     TOFU_POLICY_ASK }
2046   };
2047   int i;
2048
2049   if (!ascii_strcasecmp (policystr, "help"))
2050     {
2051       log_info (_("valid values for option '%s':\n"), "--tofu-policy");
2052       for (i=0; i < DIM (list); i++)
2053         log_info ("  %s\n", list[i].keyword);
2054       g10_exit (1);
2055     }
2056
2057   for (i=0; i < DIM (list); i++)
2058     if (!ascii_strcasecmp (policystr, list[i].keyword))
2059       return list[i].policy;
2060 #endif /*USE_TOFU*/
2061
2062   log_error (_("unknown TOFU policy '%s'\n"), policystr);
2063   if (!opt.quiet)
2064     log_info (_("(use \"help\" to list choices)\n"));
2065   g10_exit (1);
2066 }
2067
2068
2069 /* Parse the value of --compliance.  */
2070 static int
2071 parse_compliance_option (const char *string)
2072 {
2073   struct { const char *keyword; enum cmd_and_opt_values option; } list[] = {
2074     { "gnupg",      oGnuPG },
2075     { "openpgp",    oOpenPGP },
2076     { "rfc4880bis", oRFC4880bis },
2077     { "rfc4880",    oRFC4880 },
2078     { "rfc2440",    oRFC2440 },
2079     { "pgp6",       oPGP6 },
2080     { "pgp7",       oPGP7 },
2081     { "pgp8",       oPGP8 },
2082     { "de-vs",      oDE_VS }
2083   };
2084   int i;
2085
2086   if (!ascii_strcasecmp (string, "help"))
2087     {
2088       log_info (_("valid values for option '%s':\n"), "--compliance");
2089       for (i=0; i < DIM (list); i++)
2090         log_info ("  %s\n", list[i].keyword);
2091       g10_exit (1);
2092     }
2093
2094   for (i=0; i < DIM (list); i++)
2095     if (!ascii_strcasecmp (string, list[i].keyword))
2096       return list[i].option;
2097
2098   log_error (_("invalid value for option '%s'\n"), "--compliance");
2099   if (!opt.quiet)
2100     log_info (_("(use \"help\" to list choices)\n"));
2101   g10_exit (1);
2102 }
2103
2104
2105
2106 /* Helper to set compliance related options.  This is a separte
2107  * function so that it can also be used by the --compliance option
2108  * parser.  */
2109 static void
2110 set_compliance_option (enum cmd_and_opt_values option)
2111 {
2112   switch (option)
2113     {
2114     case oRFC4880bis:
2115       opt.flags.rfc4880bis = 1;
2116       /* fall through.  */
2117     case oOpenPGP:
2118     case oRFC4880:
2119       /* This is effectively the same as RFC2440, but with
2120          "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2121          --require-cross-certification". */
2122       opt.compliance = CO_RFC4880;
2123       opt.flags.dsa2 = 1;
2124       opt.flags.require_cross_cert = 1;
2125       opt.rfc2440_text = 0;
2126       opt.allow_non_selfsigned_uid = 1;
2127       opt.allow_freeform_uid = 1;
2128       opt.escape_from = 1;
2129       opt.not_dash_escaped = 0;
2130       opt.def_cipher_algo = 0;
2131       opt.def_digest_algo = 0;
2132       opt.cert_digest_algo = 0;
2133       opt.compress_algo = -1;
2134       opt.s2k_mode = 3; /* iterated+salted */
2135       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2136       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2137       break;
2138     case oRFC2440:
2139       opt.compliance = CO_RFC2440;
2140       opt.flags.dsa2 = 0;
2141       opt.rfc2440_text = 1;
2142       opt.allow_non_selfsigned_uid = 1;
2143       opt.allow_freeform_uid = 1;
2144       opt.escape_from = 0;
2145       opt.not_dash_escaped = 0;
2146       opt.def_cipher_algo = 0;
2147       opt.def_digest_algo = 0;
2148       opt.cert_digest_algo = 0;
2149       opt.compress_algo = -1;
2150       opt.s2k_mode = 3; /* iterated+salted */
2151       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2152       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2153       break;
2154     case oPGP6:  opt.compliance = CO_PGP6;  break;
2155     case oPGP7:  opt.compliance = CO_PGP7;  break;
2156     case oPGP8:  opt.compliance = CO_PGP8;  break;
2157     case oGnuPG: opt.compliance = CO_GNUPG; break;
2158
2159     case oDE_VS:
2160       set_compliance_option (oOpenPGP);
2161       opt.compliance = CO_DE_VS;
2162       /* Fixme: Change other options.  */
2163       break;
2164
2165     default:
2166       BUG ();
2167     }
2168 }
2169
2170
2171
2172
2173
2174
2175 /* This function called to initialized a new control object.  It is
2176    assumed that this object has been zeroed out before calling this
2177    function. */
2178 static void
2179 gpg_init_default_ctrl (ctrl_t ctrl)
2180 {
2181   (void)ctrl;
2182 }
2183
2184
2185 /* This function is called to deinitialize a control object.  It is
2186    not deallocated. */
2187 static void
2188 gpg_deinit_default_ctrl (ctrl_t ctrl)
2189 {
2190 #ifdef USE_TOFU
2191   tofu_closedbs (ctrl);
2192 #endif
2193   gpg_dirmngr_deinit_session_data (ctrl);
2194 }
2195
2196
2197 char *
2198 get_default_configname (void)
2199 {
2200   char *configname = NULL;
2201   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2202   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2203
2204   do
2205     {
2206       if (configname)
2207         {
2208           char *tok;
2209
2210           xfree (configname);
2211           configname = NULL;
2212
2213           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2214             *tok='\0';
2215           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2216             *tok='\0';
2217           else
2218             break;
2219         }
2220
2221       configname = make_filename (gnupg_homedir (), name, NULL);
2222     }
2223   while (access (configname, R_OK));
2224
2225   xfree(name);
2226
2227   if (! configname)
2228     configname = make_filename (gnupg_homedir (),
2229                                 GPG_NAME EXTSEP_S "conf", NULL);
2230   if (! access (configname, R_OK))
2231     {
2232       /* Print a warning when both config files are present.  */
2233       char *p = make_filename (gnupg_homedir (), "options", NULL);
2234       if (! access (p, R_OK))
2235         log_info (_("Note: old default options file '%s' ignored\n"), p);
2236       xfree (p);
2237     }
2238   else
2239     {
2240       /* Use the old default only if it exists.  */
2241       char *p = make_filename (gnupg_homedir (), "options", NULL);
2242       if (!access (p, R_OK))
2243         {
2244           xfree (configname);
2245           configname = p;
2246         }
2247       else
2248         xfree (p);
2249     }
2250
2251   return configname;
2252 }
2253
2254 int
2255 main (int argc, char **argv)
2256 {
2257     ARGPARSE_ARGS pargs;
2258     IOBUF a;
2259     int rc=0;
2260     int orig_argc;
2261     char **orig_argv;
2262     const char *fname;
2263     char *username;
2264     int may_coredump;
2265     strlist_t sl;
2266     strlist_t remusr = NULL;
2267     strlist_t locusr = NULL;
2268     strlist_t nrings = NULL;
2269     armor_filter_context_t *afx = NULL;
2270     int detached_sig = 0;
2271     FILE *configfp = NULL;
2272     char *configname = NULL;
2273     char *save_configname = NULL;
2274     char *default_configname = NULL;
2275     unsigned configlineno;
2276     int parse_debug = 0;
2277     int default_config = 1;
2278     int default_keyring = 1;
2279     int greeting = 0;
2280     int nogreeting = 0;
2281     char *logfile = NULL;
2282     int use_random_seed = 1;
2283     enum cmd_and_opt_values cmd = 0;
2284     const char *debug_level = NULL;
2285 #ifndef NO_TRUST_MODELS
2286     const char *trustdb_name = NULL;
2287 #endif /*!NO_TRUST_MODELS*/
2288     char *def_cipher_string = NULL;
2289     char *def_digest_string = NULL;
2290     char *compress_algo_string = NULL;
2291     char *cert_digest_string = NULL;
2292     char *s2k_cipher_string = NULL;
2293     char *s2k_digest_string = NULL;
2294     char *pers_cipher_list = NULL;
2295     char *pers_digest_list = NULL;
2296     char *pers_compress_list = NULL;
2297     int eyes_only=0;
2298     int multifile=0;
2299     int pwfd = -1;
2300     int ovrseskeyfd = -1;
2301     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2302     int any_explicit_recipient = 0;
2303     int require_secmem = 0;
2304     int got_secmem = 0;
2305     struct assuan_malloc_hooks malloc_hooks;
2306     ctrl_t ctrl;
2307
2308     static int print_dane_records;
2309     static int print_pka_records;
2310
2311
2312 #ifdef __riscos__
2313     opt.lock_once = 1;
2314 #endif /* __riscos__ */
2315
2316     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2317        when adding any stuff between here and the call to
2318        secmem_init() somewhere after the option parsing. */
2319     early_system_init ();
2320     gnupg_reopen_std (GPG_NAME);
2321     trap_unaligned ();
2322     gnupg_rl_initialize ();
2323     set_strusage (my_strusage);
2324     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2325     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
2326
2327     /* Make sure that our subsystems are ready.  */
2328     i18n_init();
2329     init_common_subsystems (&argc, &argv);
2330
2331     /* Use our own logging handler for Libcgrypt.  */
2332     setup_libgcrypt_logging ();
2333
2334     /* Put random number into secure memory */
2335     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2336
2337     may_coredump = disable_core_dumps();
2338
2339     gnupg_init_signals (0, emergency_cleanup);
2340
2341     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2342
2343     opt.autostart = 1;
2344     opt.session_env = session_env_new ();
2345     if (!opt.session_env)
2346       log_fatal ("error allocating session environment block: %s\n",
2347                  strerror (errno));
2348
2349     opt.command_fd = -1; /* no command fd */
2350     opt.compress_level = -1; /* defaults to standard compress level */
2351     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2352     /* note: if you change these lines, look at oOpenPGP */
2353     opt.def_cipher_algo = 0;
2354     opt.def_digest_algo = 0;
2355     opt.cert_digest_algo = 0;
2356     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2357     opt.s2k_mode = 3; /* iterated+salted */
2358     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2359     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2360     opt.completes_needed = 1;
2361     opt.marginals_needed = 3;
2362     opt.max_cert_depth = 5;
2363     opt.escape_from = 1;
2364     opt.flags.require_cross_cert = 1;
2365     opt.import_options = 0;
2366     opt.export_options = EXPORT_ATTRIBUTES;
2367     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2368     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2369     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2370     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2371                           | VERIFY_SHOW_POLICY_URLS
2372                           | VERIFY_SHOW_STD_NOTATIONS
2373                           | VERIFY_SHOW_KEYSERVER_URLS);
2374     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2375                           | LIST_SHOW_USAGE);
2376 #ifdef NO_TRUST_MODELS
2377     opt.trust_model = TM_ALWAYS;
2378 #else
2379     opt.trust_model = TM_AUTO;
2380 #endif
2381     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2382     opt.mangle_dos_filenames = 0;
2383     opt.min_cert_level = 2;
2384     set_screen_dimensions ();
2385     opt.keyid_format = KF_NONE;
2386     opt.def_sig_expire = "0";
2387     opt.def_cert_expire = "0";
2388     gnupg_set_homedir (NULL);
2389     opt.passphrase_repeat = 1;
2390     opt.emit_version = 0;
2391     opt.weak_digests = NULL;
2392     additional_weak_digest("MD5");
2393
2394     /* Check whether we have a config file on the command line.  */
2395     orig_argc = argc;
2396     orig_argv = argv;
2397     pargs.argc = &argc;
2398     pargs.argv = &argv;
2399     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2400     while( arg_parse( &pargs, opts) ) {
2401         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2402             parse_debug++;
2403         else if (pargs.r_opt == oDebugIOLBF)
2404             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2405         else if( pargs.r_opt == oOptions ) {
2406             /* yes there is one, so we do not try the default one, but
2407              * read the option file when it is encountered at the commandline
2408              */
2409             default_config = 0;
2410         }
2411         else if( pargs.r_opt == oNoOptions )
2412           {
2413             default_config = 0; /* --no-options */
2414             opt.no_homedir_creation = 1;
2415           }
2416         else if( pargs.r_opt == oHomedir )
2417             gnupg_set_homedir (pargs.r.ret_str);
2418         else if( pargs.r_opt == oNoPermissionWarn )
2419             opt.no_perm_warn=1;
2420         else if (pargs.r_opt == oStrict )
2421           {
2422             /* Not used */
2423           }
2424         else if (pargs.r_opt == oNoStrict )
2425           {
2426             /* Not used */
2427           }
2428     }
2429
2430 #ifdef HAVE_DOSISH_SYSTEM
2431     if ( strchr (gnupg_homedir (), '\\') ) {
2432       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2433       const char *s;
2434       for (d=buf, s = gnupg_homedir (); *s; s++)
2435           {
2436             *d++ = *s == '\\'? '/': *s;
2437 #ifdef HAVE_W32_SYSTEM
2438             if (s[1] && IsDBCSLeadByte (*s))
2439               *d++ = *++s;
2440 #endif
2441           }
2442         *d = 0;
2443         gnupg_set_homedir (buf);
2444     }
2445 #endif
2446
2447     /* Initialize the secure memory. */
2448     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2449       got_secmem = 1;
2450 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2451     /* There should be no way to get to this spot while still carrying
2452        setuid privs.  Just in case, bomb out if we are. */
2453     if ( getuid () != geteuid () )
2454       BUG ();
2455 #endif
2456     maybe_setuid = 0;
2457
2458     /* Okay, we are now working under our real uid */
2459
2460     /* malloc hooks go here ... */
2461     malloc_hooks.malloc = gcry_malloc;
2462     malloc_hooks.realloc = gcry_realloc;
2463     malloc_hooks.free = gcry_free;
2464     assuan_set_malloc_hooks (&malloc_hooks);
2465     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2466     setup_libassuan_logging (&opt.debug, NULL);
2467
2468     /* Try for a version specific config file first */
2469     default_configname = get_default_configname ();
2470     if (default_config)
2471       configname = xstrdup (default_configname);
2472
2473     argc = orig_argc;
2474     argv = orig_argv;
2475     pargs.argc = &argc;
2476     pargs.argv = &argv;
2477     pargs.flags= ARGPARSE_FLAG_KEEP;
2478
2479     /* By this point we have a homedir, and cannot change it. */
2480     check_permissions (gnupg_homedir (), 0);
2481
2482   next_pass:
2483     if( configname ) {
2484       if(check_permissions(configname,1))
2485         {
2486           /* If any options file is unsafe, then disable any external
2487              programs for keyserver calls or photo IDs.  Since the
2488              external program to call is set in the options file, a
2489              unsafe options file can lead to an arbitrary program
2490              being run. */
2491
2492           opt.exec_disable=1;
2493         }
2494
2495         configlineno = 0;
2496         configfp = fopen( configname, "r" );
2497         if (configfp && is_secured_file (fileno (configfp)))
2498           {
2499             fclose (configfp);
2500             configfp = NULL;
2501             gpg_err_set_errno (EPERM);
2502           }
2503         if( !configfp ) {
2504             if( default_config ) {
2505                 if( parse_debug )
2506                     log_info(_("Note: no default option file '%s'\n"),
2507                                                             configname );
2508             }
2509             else {
2510                 log_error(_("option file '%s': %s\n"),
2511                                     configname, strerror(errno) );
2512                 g10_exit(2);
2513             }
2514             xfree(configname); configname = NULL;
2515         }
2516         if( parse_debug && configname )
2517             log_info(_("reading options from '%s'\n"), configname );
2518         default_config = 0;
2519     }
2520
2521     while( optfile_parse( configfp, configname, &configlineno,
2522                                                 &pargs, opts) )
2523       {
2524         switch( pargs.r_opt )
2525           {
2526           case aListConfig:
2527           case aListGcryptConfig:
2528           case aGPGConfList:
2529           case aGPGConfTest:
2530             set_cmd (&cmd, pargs.r_opt);
2531             /* Do not register a keyring for these commands.  */
2532             default_keyring = -1;
2533             break;
2534
2535           case aCheckKeys:
2536           case aListPackets:
2537           case aImport:
2538           case aFastImport:
2539           case aSendKeys:
2540           case aRecvKeys:
2541           case aSearchKeys:
2542           case aRefreshKeys:
2543           case aFetchKeys:
2544           case aExport:
2545 #ifdef ENABLE_CARD_SUPPORT
2546           case aCardStatus:
2547           case aCardEdit:
2548           case aChangePIN:
2549 #endif /* ENABLE_CARD_SUPPORT*/
2550           case aListKeys:
2551           case aLocateKeys:
2552           case aListSigs:
2553           case aExportSecret:
2554           case aExportSecretSub:
2555           case aExportSshKey:
2556           case aSym:
2557           case aClearsign:
2558           case aGenRevoke:
2559           case aDesigRevoke:
2560           case aPrimegen:
2561           case aGenRandom:
2562           case aPrintMD:
2563           case aPrintMDs:
2564           case aListTrustDB:
2565           case aCheckTrustDB:
2566           case aUpdateTrustDB:
2567           case aFixTrustDB:
2568           case aListTrustPath:
2569           case aDeArmor:
2570           case aEnArmor:
2571           case aSign:
2572           case aQuickSignKey:
2573           case aQuickLSignKey:
2574           case aSignKey:
2575           case aLSignKey:
2576           case aStore:
2577           case aQuickKeygen:
2578           case aQuickAddUid:
2579           case aQuickAddKey:
2580           case aQuickRevUid:
2581           case aQuickSetExpire:
2582           case aExportOwnerTrust:
2583           case aImportOwnerTrust:
2584           case aRebuildKeydbCaches:
2585             set_cmd (&cmd, pargs.r_opt);
2586             break;
2587
2588           case aKeygen:
2589           case aFullKeygen:
2590           case aEditKey:
2591           case aDeleteSecretKeys:
2592           case aDeleteSecretAndPublicKeys:
2593           case aDeleteKeys:
2594           case aPasswd:
2595             set_cmd (&cmd, pargs.r_opt);
2596             greeting=1;
2597             break;
2598
2599           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2600
2601           case aDecryptFiles: multifile=1; /* fall through */
2602           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2603
2604           case aEncrFiles: multifile=1; /* fall through */
2605           case aEncr: set_cmd( &cmd, aEncr); break;
2606
2607           case aVerifyFiles: multifile=1; /* fall through */
2608           case aVerify: set_cmd( &cmd, aVerify); break;
2609
2610           case aServer:
2611             set_cmd (&cmd, pargs.r_opt);
2612             opt.batch = 1;
2613             break;
2614
2615           case aTOFUPolicy:
2616             set_cmd (&cmd, pargs.r_opt);
2617             break;
2618
2619           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2620           case oOutput: opt.outfile = pargs.r.ret_str; break;
2621
2622           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2623
2624           case oInputSizeHint:
2625             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2626             break;
2627
2628           case oQuiet: opt.quiet = 1; break;
2629           case oNoTTY: tty_no_terminal(1); break;
2630           case oDryRun: opt.dry_run = 1; break;
2631           case oInteractive: opt.interactive = 1; break;
2632           case oVerbose:
2633             opt.verbose++;
2634             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2635             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2636             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2637             break;
2638
2639           case oBatch:
2640             opt.batch = 1;
2641             nogreeting = 1;
2642             break;
2643
2644           case oUseAgent: /* Dummy. */
2645             break;
2646
2647           case oNoUseAgent:
2648             obsolete_option (configname, configlineno, "no-use-agent");
2649             break;
2650           case oGpgAgentInfo:
2651             obsolete_option (configname, configlineno, "gpg-agent-info");
2652             break;
2653           case oReaderPort:
2654             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2655             break;
2656           case octapiDriver:
2657             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2658             break;
2659           case opcscDriver:
2660             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2661             break;
2662           case oDisableCCID:
2663             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2664             break;
2665           case oHonorHttpProxy:
2666             obsolete_option (configname, configlineno, "honor-http-proxy");
2667             break;
2668
2669           case oAnswerYes: opt.answer_yes = 1; break;
2670           case oAnswerNo: opt.answer_no = 1; break;
2671           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2672           case oPrimaryKeyring:
2673             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2674             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2675             break;
2676           case oShowKeyring:
2677             deprecated_warning(configname,configlineno,"--show-keyring",
2678                                "--list-options ","show-keyring");
2679             opt.list_options|=LIST_SHOW_KEYRING;
2680             break;
2681
2682           case oDebug:
2683             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2684               {
2685                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2686                 pargs.err = ARGPARSE_PRINT_ERROR;
2687               }
2688             break;
2689
2690           case oDebugAll: opt.debug = ~0; break;
2691           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2692
2693           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2694
2695           case oStatusFD:
2696             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2697             break;
2698           case oStatusFile:
2699             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2700             break;
2701           case oAttributeFD:
2702             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2703             break;
2704           case oAttributeFile:
2705             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2706             break;
2707           case oLoggerFD:
2708             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2709             break;
2710           case oLoggerFile:
2711             logfile = pargs.r.ret_str;
2712             break;
2713
2714           case oWithFingerprint:
2715             opt.with_fingerprint = 1;
2716             opt.fingerprint++;
2717             break;
2718           case oWithSubkeyFingerprint:
2719             opt.with_subkey_fingerprint = 1;
2720             break;
2721           case oWithICAOSpelling:
2722             opt.with_icao_spelling = 1;
2723             break;
2724           case oFingerprint:
2725             opt.fingerprint++;
2726             fpr_maybe_cmd = 1;
2727             break;
2728
2729           case oWithKeygrip:
2730             opt.with_keygrip = 1;
2731             break;
2732
2733           case oWithSecret:
2734             opt.with_secret = 1;
2735             break;
2736
2737           case oWithWKDHash:
2738             opt.with_wkd_hash = 1;
2739             break;
2740
2741           case oSecretKeyring:
2742             /* Ignore this old option.  */
2743             break;
2744
2745           case oOptions:
2746             /* config files may not be nested (silently ignore them) */
2747             if( !configfp ) {
2748                 xfree(configname);
2749                 configname = xstrdup(pargs.r.ret_str);
2750                 goto next_pass;
2751             }
2752             break;
2753           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2754
2755           case oNoDefKeyring:
2756             if (default_keyring > 0)
2757               default_keyring = 0;
2758             break;
2759           case oNoKeyring:
2760             default_keyring = -1;
2761             break;
2762
2763           case oNoGreeting: nogreeting = 1; break;
2764           case oNoVerbose:
2765             opt.verbose = 0;
2766             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2767             opt.list_sigs=0;
2768             break;
2769           case oQuickRandom:
2770             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2771             break;
2772           case oEmitVersion: opt.emit_version++; break;
2773           case oNoEmitVersion: opt.emit_version=0; break;
2774           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2775           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2776           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2777
2778 #ifndef NO_TRUST_MODELS
2779           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2780
2781 #endif /*!NO_TRUST_MODELS*/
2782           case oDefaultKey:
2783             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2784             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2785             if (configfp)
2786               sl->flags |= PK_LIST_CONFIG;
2787             break;
2788           case oDefRecipient:
2789             if( *pargs.r.ret_str )
2790               {
2791                 xfree (opt.def_recipient);
2792                 opt.def_recipient = make_username(pargs.r.ret_str);
2793               }
2794             break;
2795           case oDefRecipientSelf:
2796             xfree(opt.def_recipient); opt.def_recipient = NULL;
2797             opt.def_recipient_self = 1;
2798             break;
2799           case oNoDefRecipient:
2800             xfree(opt.def_recipient); opt.def_recipient = NULL;
2801             opt.def_recipient_self = 0;
2802             break;
2803           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2804           case oHomedir: break;
2805           case oNoBatch: opt.batch = 0; break;
2806
2807           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2808
2809           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2810           case oWithColons: opt.with_colons=':'; break;
2811
2812           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2813           case oWithSigList: opt.list_sigs = 1; break;
2814
2815           case oSkipVerify: opt.skip_verify=1; break;
2816
2817           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2818           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2819
2820           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2821
2822 #ifndef NO_TRUST_MODELS
2823             /* There are many programs (like mutt) that call gpg with
2824                --always-trust so keep this option around for a long
2825                time. */
2826           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2827           case oTrustModel:
2828             parse_trust_model(pargs.r.ret_str);
2829             break;
2830 #endif /*!NO_TRUST_MODELS*/
2831           case oTOFUDefaultPolicy:
2832             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2833             break;
2834           case oTOFUDBFormat:
2835             obsolete_option (configname, configlineno, "tofu-db-format");
2836             break;
2837
2838           case oForceOwnertrust:
2839             log_info(_("Note: %s is not for normal use!\n"),
2840                      "--force-ownertrust");
2841             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2842             if(opt.force_ownertrust==-1)
2843               {
2844                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2845                 opt.force_ownertrust=0;
2846               }
2847             break;
2848           case oLoadExtension:
2849             /* Dummy so that gpg 1.4 conf files can work. Should
2850                eventually be removed.  */
2851             break;
2852
2853           case oCompliance:
2854             set_compliance_option (parse_compliance_option (pargs.r.ret_str));
2855             break;
2856           case oOpenPGP:
2857           case oRFC2440:
2858           case oRFC4880:
2859           case oRFC4880bis:
2860           case oPGP6:
2861           case oPGP7:
2862           case oPGP8:
2863           case oGnuPG:
2864             set_compliance_option (pargs.r_opt);
2865             break;
2866
2867           case oRFC2440Text: opt.rfc2440_text=1; break;
2868           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2869
2870           case oSetFilename:
2871             if(utf8_strings)
2872               opt.set_filename = pargs.r.ret_str;
2873             else
2874               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2875             break;
2876           case oForYourEyesOnly: eyes_only = 1; break;
2877           case oNoForYourEyesOnly: eyes_only = 0; break;
2878           case oSetPolicyURL:
2879             add_policy_url(pargs.r.ret_str,0);
2880             add_policy_url(pargs.r.ret_str,1);
2881             break;
2882           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2883           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2884           case oShowPolicyURL:
2885             deprecated_warning(configname,configlineno,"--show-policy-url",
2886                                "--list-options ","show-policy-urls");
2887             deprecated_warning(configname,configlineno,"--show-policy-url",
2888                                "--verify-options ","show-policy-urls");
2889             opt.list_options|=LIST_SHOW_POLICY_URLS;
2890             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2891             break;
2892           case oNoShowPolicyURL:
2893             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2894                                "--list-options ","no-show-policy-urls");
2895             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2896                                "--verify-options ","no-show-policy-urls");
2897             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2898             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2899             break;
2900           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2901           case oUseEmbeddedFilename:
2902             opt.flags.use_embedded_filename=1;
2903             break;
2904           case oNoUseEmbeddedFilename:
2905             opt.flags.use_embedded_filename=0;
2906             break;
2907           case oComment:
2908             if(pargs.r.ret_str[0])
2909               append_to_strlist(&opt.comments,pargs.r.ret_str);
2910             break;
2911           case oDefaultComment:
2912             deprecated_warning(configname,configlineno,
2913                                "--default-comment","--no-comments","");
2914             /* fall through */
2915           case oNoComments:
2916             free_strlist(opt.comments);
2917             opt.comments=NULL;
2918             break;
2919           case oThrowKeyids: opt.throw_keyids = 1; break;
2920           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2921           case oShowPhotos:
2922             deprecated_warning(configname,configlineno,"--show-photos",
2923                                "--list-options ","show-photos");
2924             deprecated_warning(configname,configlineno,"--show-photos",
2925                                "--verify-options ","show-photos");
2926             opt.list_options|=LIST_SHOW_PHOTOS;
2927             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2928             break;
2929           case oNoShowPhotos:
2930             deprecated_warning(configname,configlineno,"--no-show-photos",
2931                                "--list-options ","no-show-photos");
2932             deprecated_warning(configname,configlineno,"--no-show-photos",
2933                                "--verify-options ","no-show-photos");
2934             opt.list_options&=~LIST_SHOW_PHOTOS;
2935             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2936             break;
2937           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2938
2939           case oForceMDC: opt.force_mdc = 1; break;
2940           case oNoForceMDC: opt.force_mdc = 0; break;
2941           case oDisableMDC: opt.disable_mdc = 1; break;
2942           case oNoDisableMDC: opt.disable_mdc = 0; break;
2943
2944           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2945
2946           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2947           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2948           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2949           case oS2KCount:
2950             if (pargs.r.ret_int)
2951               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2952             else
2953               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2954             break;
2955
2956           case oRecipient:
2957           case oHiddenRecipient:
2958           case oRecipientFile:
2959           case oHiddenRecipientFile:
2960             /* Store the recipient.  Note that we also store the
2961              * option as private data in the flags.  This is achieved
2962              * by shifting the option value to the left so to keep
2963              * enough space for the flags.  */
2964             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2965             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2966             if (configfp)
2967               sl->flags |= PK_LIST_CONFIG;
2968             if (pargs.r_opt == oHiddenRecipient
2969                 || pargs.r_opt == oHiddenRecipientFile)
2970               sl->flags |= PK_LIST_HIDDEN;
2971             if (pargs.r_opt == oRecipientFile
2972                 || pargs.r_opt == oHiddenRecipientFile)
2973               sl->flags |= PK_LIST_FROM_FILE;
2974             any_explicit_recipient = 1;
2975             break;
2976
2977           case oEncryptTo:
2978           case oHiddenEncryptTo:
2979             /* Store an additional recipient.  */
2980             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2981             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
2982             if (configfp)
2983               sl->flags |= PK_LIST_CONFIG;
2984             if (pargs.r_opt == oHiddenEncryptTo)
2985               sl->flags |= PK_LIST_HIDDEN;
2986             break;
2987
2988           case oNoEncryptTo:
2989             opt.no_encrypt_to = 1;
2990             break;
2991           case oEncryptToDefaultKey:
2992             opt.encrypt_to_default_key = configfp ? 2 : 1;
2993             break;
2994
2995           case oTrySecretKey:
2996             add_to_strlist2 (&opt.secret_keys_to_try,
2997                              pargs.r.ret_str, utf8_strings);
2998             break;
2999
3000           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3001           case oTextmodeShort: opt.textmode = 2; break;
3002           case oTextmode: opt.textmode=1;  break;
3003           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3004
3005           case oExpert: opt.expert = 1; break;
3006           case oNoExpert: opt.expert = 0; break;
3007           case oDefSigExpire:
3008             if(*pargs.r.ret_str!='\0')
3009               {
3010                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3011                   log_error(_("'%s' is not a valid signature expiration\n"),
3012                             pargs.r.ret_str);
3013                 else
3014                   opt.def_sig_expire=pargs.r.ret_str;
3015               }
3016             break;
3017           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3018           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3019           case oDefCertExpire:
3020             if(*pargs.r.ret_str!='\0')
3021               {
3022                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3023                   log_error(_("'%s' is not a valid signature expiration\n"),
3024                             pargs.r.ret_str);
3025                 else
3026                   opt.def_cert_expire=pargs.r.ret_str;
3027               }
3028             break;
3029           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3030           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3031           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3032           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3033           case oAskCertLevel: opt.ask_cert_level = 1; break;
3034           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3035           case oLocalUser: /* store the local users */
3036             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3037             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3038             if (configfp)
3039               sl->flags |= PK_LIST_CONFIG;
3040             break;
3041           case oSender:
3042             {
3043               char *mbox = mailbox_from_userid (pargs.r.ret_str);
3044               if (!mbox)
3045                 log_error (_("\"%s\" is not a proper mail address\n"),
3046                            pargs.r.ret_str);
3047               else
3048                 {
3049                   add_to_strlist (&opt.sender_list, mbox);
3050                   xfree (mbox);
3051                 }
3052             }
3053             break;
3054           case oCompress:
3055             /* this is the -z command line option */
3056             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3057             break;
3058           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3059           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3060           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3061           case oPassphrase:
3062             set_passphrase_from_string(pargs.r.ret_str);
3063             break;
3064           case oPassphraseFD:
3065             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3066             break;
3067           case oPassphraseFile:
3068             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3069             break;
3070           case oPassphraseRepeat:
3071             opt.passphrase_repeat = pargs.r.ret_int;
3072             break;
3073
3074           case oPinentryMode:
3075             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3076             if (opt.pinentry_mode == -1)
3077               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3078             break;
3079
3080           case oCommandFD:
3081             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3082             if (! gnupg_fd_valid (opt.command_fd))
3083               log_fatal ("command-fd is invalid: %s\n", strerror (errno));
3084             break;
3085           case oCommandFile:
3086             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3087             break;
3088           case oCipherAlgo:
3089             def_cipher_string = xstrdup(pargs.r.ret_str);
3090             break;
3091           case oDigestAlgo:
3092             def_digest_string = xstrdup(pargs.r.ret_str);
3093             break;
3094           case oCompressAlgo:
3095             /* If it is all digits, stick a Z in front of it for
3096                later.  This is for backwards compatibility with
3097                versions that took the compress algorithm number. */
3098             {
3099               char *pt=pargs.r.ret_str;
3100               while(*pt)
3101                 {
3102                   if (!isascii (*pt) || !isdigit (*pt))
3103                     break;
3104
3105                   pt++;
3106                 }
3107
3108               if(*pt=='\0')
3109                 {
3110                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3111                   strcpy(compress_algo_string,"Z");
3112                   strcat(compress_algo_string,pargs.r.ret_str);
3113                 }
3114               else
3115                 compress_algo_string = xstrdup(pargs.r.ret_str);
3116             }
3117             break;
3118           case oCertDigestAlgo:
3119             cert_digest_string = xstrdup(pargs.r.ret_str);
3120             break;
3121
3122           case oNoSecmemWarn:
3123             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3124             break;
3125
3126           case oRequireSecmem: require_secmem=1; break;
3127           case oNoRequireSecmem: require_secmem=0; break;
3128           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3129           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3130           case oDisplayCharset:
3131             if( set_native_charset( pargs.r.ret_str ) )
3132                 log_error(_("'%s' is not a valid character set\n"),
3133                           pargs.r.ret_str);
3134             break;
3135           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3136           case oEscapeFrom: opt.escape_from = 1; break;
3137           case oNoEscapeFrom: opt.escape_from = 0; break;
3138           case oLockOnce: opt.lock_once = 1; break;
3139           case oLockNever:
3140             dotlock_disable ();
3141             break;
3142           case oLockMultiple:
3143 #ifndef __riscos__
3144             opt.lock_once = 0;
3145 #else /* __riscos__ */
3146             riscos_not_implemented("lock-multiple");
3147 #endif /* __riscos__ */
3148             break;
3149           case oKeyServer:
3150             {
3151               keyserver_spec_t keyserver;
3152               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3153               if (!keyserver)
3154                 log_error (_("could not parse keyserver URL\n"));
3155               else
3156                 {
3157                   /* We only support a single keyserver.  Later ones
3158                      override earlier ones.  (Since we parse the
3159                      config file first and then the command line
3160                      arguments, the command line takes
3161                      precedence.)  */
3162                   if (opt.keyserver)
3163                     free_keyserver_spec (opt.keyserver);
3164                   opt.keyserver = keyserver;
3165                 }
3166             }
3167             break;
3168           case oKeyServerOptions:
3169             if(!parse_keyserver_options(pargs.r.ret_str))
3170               {
3171                 if(configname)
3172                   log_error(_("%s:%d: invalid keyserver options\n"),
3173                             configname,configlineno);
3174                 else
3175                   log_error(_("invalid keyserver options\n"));
3176               }
3177             break;
3178           case oImportOptions:
3179             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3180               {
3181                 if(configname)
3182                   log_error(_("%s:%d: invalid import options\n"),
3183                             configname,configlineno);
3184                 else
3185                   log_error(_("invalid import options\n"));
3186               }
3187             break;
3188           case oImportFilter:
3189             rc = parse_and_set_import_filter (pargs.r.ret_str);
3190             if (rc)
3191               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3192             break;
3193           case oExportOptions:
3194             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3195               {
3196                 if(configname)
3197                   log_error(_("%s:%d: invalid export options\n"),
3198                             configname,configlineno);
3199                 else
3200                   log_error(_("invalid export options\n"));
3201               }
3202             break;
3203           case oExportFilter:
3204             rc = parse_and_set_export_filter (pargs.r.ret_str);
3205             if (rc)
3206               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3207             break;
3208           case oListOptions:
3209             if(!parse_list_options(pargs.r.ret_str))
3210               {
3211                 if(configname)
3212                   log_error(_("%s:%d: invalid list options\n"),
3213                             configname,configlineno);
3214                 else
3215                   log_error(_("invalid list options\n"));
3216               }
3217             break;
3218           case oVerifyOptions:
3219             {
3220               struct parse_options vopts[]=
3221                 {
3222                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3223                    N_("display photo IDs during signature verification")},
3224                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3225                    N_("show policy URLs during signature verification")},
3226                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3227                    N_("show all notations during signature verification")},
3228                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3229                    N_("show IETF standard notations during signature verification")},
3230                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3231                    NULL},
3232                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3233                    N_("show user-supplied notations during signature verification")},
3234                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3235                    N_("show preferred keyserver URLs during signature verification")},
3236                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3237                    N_("show user ID validity during signature verification")},
3238                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3239                    N_("show revoked and expired user IDs in signature verification")},
3240                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3241                    N_("show only the primary user ID in signature verification")},
3242                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3243                    N_("validate signatures with PKA data")},
3244                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3245                    N_("elevate the trust of signatures with valid PKA data")},
3246                   {NULL,0,NULL,NULL}
3247                 };
3248
3249               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3250                 {
3251                   if(configname)
3252                     log_error(_("%s:%d: invalid verify options\n"),
3253                               configname,configlineno);
3254                   else
3255                     log_error(_("invalid verify options\n"));
3256                 }
3257             }
3258             break;
3259           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3260           case oExecPath:
3261             if(set_exec_path(pargs.r.ret_str))
3262               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3263             else
3264               opt.exec_path_set=1;
3265             break;
3266           case oSetNotation:
3267             add_notation_data( pargs.r.ret_str, 0 );
3268             add_notation_data( pargs.r.ret_str, 1 );
3269             break;
3270           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3271           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3272           case oShowNotation:
3273             deprecated_warning(configname,configlineno,"--show-notation",
3274                                "--list-options ","show-notations");
3275             deprecated_warning(configname,configlineno,"--show-notation",
3276                                "--verify-options ","show-notations");
3277             opt.list_options|=LIST_SHOW_NOTATIONS;
3278             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3279             break;
3280           case oNoShowNotation:
3281             deprecated_warning(configname,configlineno,"--no-show-notation",
3282                                "--list-options ","no-show-notations");
3283             deprecated_warning(configname,configlineno,"--no-show-notation",
3284                                "--verify-options ","no-show-notations");
3285             opt.list_options&=~LIST_SHOW_NOTATIONS;
3286             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3287             break;
3288           case oUtf8Strings: utf8_strings = 1; break;
3289           case oNoUtf8Strings: utf8_strings = 0; break;
3290           case oDisableCipherAlgo:
3291             {
3292               int algo = string_to_cipher_algo (pargs.r.ret_str);
3293               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3294             }
3295             break;
3296           case oDisablePubkeyAlgo:
3297             {
3298               int algo = gcry_pk_map_name (pargs.r.ret_str);
3299               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3300             }
3301             break;
3302           case oNoSigCache: opt.no_sig_cache = 1; break;
3303           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3304           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3305           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3306           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3307           case oNoLiteral: opt.no_literal = 1; break;
3308           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3309           case oFastListMode: opt.fast_list_mode = 1; break;
3310           case oFixedListMode: /* Dummy */ break;
3311           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3312           case oPrintPKARecords: print_pka_records = 1; break;
3313           case oPrintDANERecords: print_dane_records = 1; break;
3314           case oListOnly: opt.list_only=1; break;
3315           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3316           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3317           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3318           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3319           case oNoRandomSeedFile: use_random_seed = 0; break;
3320           case oAutoKeyRetrieve:
3321           case oNoAutoKeyRetrieve:
3322                 if(pargs.r_opt==oAutoKeyRetrieve)
3323                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3324                 else
3325                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3326                 break;
3327           case oShowSessionKey: opt.show_session_key = 1; break;
3328           case oOverrideSessionKey:
3329                 opt.override_session_key = pargs.r.ret_str;
3330                 break;
3331           case oOverrideSessionKeyFD:
3332                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3333                 break;
3334           case oMergeOnly:
3335                 deprecated_warning(configname,configlineno,"--merge-only",
3336                                    "--import-options ","merge-only");
3337                 opt.import_options|=IMPORT_MERGE_ONLY;
3338             break;
3339           case oAllowSecretKeyImport: /* obsolete */ break;
3340           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3341           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3342
3343           case oEnableSpecialFilenames:
3344             enable_special_filenames ();
3345             break;
3346
3347           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3348           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3349           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3350           case oPreservePermissions: opt.preserve_permissions=1; break;
3351           case oDefaultPreferenceList:
3352             opt.def_preference_list = pargs.r.ret_str;
3353             break;
3354           case oDefaultKeyserverURL:
3355             {
3356               keyserver_spec_t keyserver;
3357               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3358               if (!keyserver)
3359                 log_error (_("could not parse keyserver URL\n"));
3360               else
3361                 free_keyserver_spec (keyserver);
3362
3363               opt.def_keyserver_url = pargs.r.ret_str;
3364             }
3365             break;
3366           case oPersonalCipherPreferences:
3367             pers_cipher_list=pargs.r.ret_str;
3368             break;
3369           case oPersonalDigestPreferences:
3370             pers_digest_list=pargs.r.ret_str;
3371             break;
3372           case oPersonalCompressPreferences:
3373             pers_compress_list=pargs.r.ret_str;
3374             break;
3375           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3376           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3377           case oWeakDigest:
3378             additional_weak_digest(pargs.r.ret_str);
3379             break;
3380           case oUnwrap:
3381             opt.unwrap_encryption = 1;
3382             break;
3383           case oOnlySignTextIDs:
3384             opt.only_sign_text_ids = 1;
3385             break;
3386
3387           case oDisplay:
3388             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3389             break;
3390           case oTTYname:
3391             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3392             break;
3393           case oTTYtype:
3394             set_opt_session_env ("TERM", pargs.r.ret_str);
3395             break;
3396           case oXauthority:
3397             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3398             break;
3399
3400           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3401           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3402
3403           case oGroup: add_group(pargs.r.ret_str); break;
3404           case oUnGroup: rm_group(pargs.r.ret_str); break;
3405           case oNoGroups:
3406             while(opt.grouplist)
3407               {
3408                 struct groupitem *iter=opt.grouplist;
3409                 free_strlist(iter->values);
3410                 opt.grouplist=opt.grouplist->next;
3411                 xfree(iter);
3412               }
3413             break;
3414
3415           case oStrict:
3416           case oNoStrict:
3417             /* Not used */
3418             break;
3419
3420           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3421           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3422           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3423           case oMultifile: multifile=1; break;
3424           case oKeyidFormat:
3425             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3426               opt.keyid_format=KF_SHORT;
3427             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3428               opt.keyid_format=KF_LONG;
3429             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3430               opt.keyid_format=KF_0xSHORT;
3431             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3432               opt.keyid_format=KF_0xLONG;
3433             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3434               opt.keyid_format = KF_NONE;
3435             else
3436               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3437             break;
3438
3439           case oExitOnStatusWriteError:
3440             opt.exit_on_status_write_error = 1;
3441             break;
3442
3443           case oLimitCardInsertTries:
3444             opt.limit_card_insert_tries = pargs.r.ret_int;
3445             break;
3446
3447           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3448           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3449
3450           case oAutoKeyLocate:
3451             if(!parse_auto_key_locate(pargs.r.ret_str))
3452               {
3453                 if(configname)
3454                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3455                             configname,configlineno);
3456                 else
3457                   log_error(_("invalid auto-key-locate list\n"));
3458               }
3459             break;
3460           case oNoAutoKeyLocate:
3461             release_akl();
3462             break;
3463
3464           case oEnableLargeRSA:
3465 #if SECMEM_BUFFER_SIZE >= 65536
3466             opt.flags.large_rsa=1;
3467 #else
3468             if (configname)
3469               log_info("%s:%d: WARNING: gpg not built with large secure "
3470                          "memory buffer.  Ignoring enable-large-rsa\n",
3471                         configname,configlineno);
3472             else
3473               log_info("WARNING: gpg not built with large secure "
3474                          "memory buffer.  Ignoring --enable-large-rsa\n");
3475 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3476             break;
3477           case oDisableLargeRSA: opt.flags.large_rsa=0;
3478             break;
3479
3480           case oEnableDSA2: opt.flags.dsa2=1; break;
3481           case oDisableDSA2: opt.flags.dsa2=0; break;
3482
3483           case oAllowMultisigVerification:
3484           case oAllowMultipleMessages:
3485             opt.flags.allow_multiple_messages=1;
3486             break;
3487
3488           case oNoAllowMultipleMessages:
3489             opt.flags.allow_multiple_messages=0;
3490             break;
3491
3492           case oAllowWeakDigestAlgos:
3493             opt.flags.allow_weak_digest_algos = 1;
3494             break;
3495
3496           case oFakedSystemTime:
3497             {
3498               size_t len = strlen (pargs.r.ret_str);
3499               int freeze = 0;
3500               time_t faked_time;
3501
3502               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3503                 {
3504                   freeze = 1;
3505                   pargs.r.ret_str[len-1] = '\0';
3506                 }
3507
3508               faked_time = isotime2epoch (pargs.r.ret_str);
3509               if (faked_time == (time_t)(-1))
3510                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3511               gnupg_set_time (faked_time, freeze);
3512             }
3513             break;
3514
3515           case oNoAutostart: opt.autostart = 0; break;
3516
3517           case oDefaultNewKeyAlgo:
3518             opt.def_new_key_algo = pargs.r.ret_str;
3519             break;
3520
3521           case oNoop: break;
3522
3523           default:
3524             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3525             break;
3526           }
3527       }
3528
3529     if (configfp)
3530       {
3531         fclose( configfp );
3532         configfp = NULL;
3533         /* Remember the first config file name. */
3534         if (!save_configname)
3535           save_configname = configname;
3536         else
3537           xfree(configname);
3538         configname = NULL;
3539         goto next_pass;
3540       }
3541     xfree(configname); configname = NULL;
3542     if (log_get_errorcount (0))
3543       g10_exit(2);
3544
3545     /* The command --gpgconf-list is pretty simple and may be called
3546        directly after the option parsing. */
3547     if (cmd == aGPGConfList)
3548       {
3549         gpgconf_list (save_configname ? save_configname : default_configname);
3550         g10_exit (0);
3551       }
3552     xfree (save_configname);
3553     xfree (default_configname);
3554
3555     if (print_dane_records)
3556       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3557                  "--print-dane-records",
3558                  "--export-options export-dane");
3559     if (print_pka_records)
3560       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3561                  "--print-pks-records",
3562                  "--export-options export-pka");
3563     if (log_get_errorcount (0))
3564       g10_exit(2);
3565
3566
3567     if( nogreeting )
3568         greeting = 0;
3569
3570     if( greeting )
3571       {
3572         es_fprintf (es_stderr, "%s %s; %s\n",
3573                     strusage(11), strusage(13), strusage(14) );
3574         es_fprintf (es_stderr, "%s\n", strusage(15) );
3575       }
3576 #ifdef IS_DEVELOPMENT_VERSION
3577     if (!opt.batch)
3578       {
3579         const char *s;
3580
3581         if((s=strusage(25)))
3582           log_info("%s\n",s);
3583         if((s=strusage(26)))
3584           log_info("%s\n",s);
3585         if((s=strusage(27)))
3586           log_info("%s\n",s);
3587       }
3588 #endif
3589
3590     /* FIXME: We should use logging to a file only in server mode;
3591        however we have not yet implemetyed that.  Thus we try to get
3592        away with --batch as indication for logging to file
3593        required. */
3594     if (logfile && opt.batch)
3595       {
3596         log_set_file (logfile);
3597         log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
3598       }
3599
3600     if (opt.verbose > 2)
3601         log_info ("using character set '%s'\n", get_native_charset ());
3602
3603     if( may_coredump && !opt.quiet )
3604         log_info(_("WARNING: program may create a core file!\n"));
3605
3606     if (opt.flags.rfc4880bis)
3607         log_info ("WARNING: using experimental features from RFC4880bis!\n");
3608     else
3609       {
3610         opt.mimemode = 0; /* This will use text mode instead.  */
3611       }
3612
3613     if (eyes_only) {
3614       if (opt.set_filename)
3615           log_info(_("WARNING: %s overrides %s\n"),
3616                    "--for-your-eyes-only","--set-filename");
3617
3618       opt.set_filename="_CONSOLE";
3619     }
3620
3621     if (opt.no_literal) {
3622         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3623         if (opt.textmode)
3624             log_error(_("%s not allowed with %s!\n"),
3625                        "--textmode", "--no-literal" );
3626         if (opt.set_filename)
3627             log_error(_("%s makes no sense with %s!\n"),
3628                         eyes_only?"--for-your-eyes-only":"--set-filename",
3629                         "--no-literal" );
3630     }
3631
3632
3633     if (opt.set_filesize)
3634         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3635     if( opt.batch )
3636         tty_batchmode( 1 );
3637
3638     if (gnupg_faked_time_p ())
3639       {
3640         gnupg_isotime_t tbuf;
3641
3642         log_info (_("WARNING: running with faked system time: "));
3643         gnupg_get_isotime (tbuf);
3644         dump_isotime (tbuf);
3645         log_printf ("\n");
3646       }
3647
3648     /* Print a warning if an argument looks like an option.  */
3649     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3650       {
3651         int i;
3652
3653         for (i=0; i < argc; i++)
3654           if (argv[i][0] == '-' && argv[i][1] == '-')
3655             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3656       }
3657
3658
3659     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3660
3661     if(require_secmem && !got_secmem)
3662       {
3663         log_info(_("will not run with insecure memory due to %s\n"),
3664                  "--require-secmem");
3665         g10_exit(2);
3666       }
3667
3668     set_debug (debug_level);
3669     if (DBG_CLOCK)
3670       log_clock ("start");
3671
3672     /* Do these after the switch(), so they can override settings. */
3673     if(PGP6)
3674       {
3675         /* That does not anymore work because we have no more support
3676            for v3 signatures.  */
3677         opt.disable_mdc=1;
3678         opt.escape_from=1;
3679         opt.ask_sig_expire=0;
3680       }
3681     else if(PGP7)
3682       {
3683         /* That does not anymore work because we have no more support
3684            for v3 signatures.  */
3685         opt.escape_from=1;
3686         opt.ask_sig_expire=0;
3687       }
3688     else if(PGP8)
3689       {
3690         opt.escape_from=1;
3691       }
3692
3693
3694     if( def_cipher_string ) {
3695         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3696         xfree(def_cipher_string); def_cipher_string = NULL;
3697         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3698             log_error(_("selected cipher algorithm is invalid\n"));
3699     }
3700     if( def_digest_string ) {
3701         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3702         xfree(def_digest_string); def_digest_string = NULL;
3703         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3704             log_error(_("selected digest algorithm is invalid\n"));
3705     }
3706     if( compress_algo_string ) {
3707         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3708         xfree(compress_algo_string); compress_algo_string = NULL;
3709         if( check_compress_algo(opt.compress_algo) )
3710           log_error(_("selected compression algorithm is invalid\n"));
3711     }
3712     if( cert_digest_string ) {
3713         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3714         xfree(cert_digest_string); cert_digest_string = NULL;
3715         if (openpgp_md_test_algo(opt.cert_digest_algo))
3716           log_error(_("selected certification digest algorithm is invalid\n"));
3717     }
3718     if( s2k_cipher_string ) {
3719         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3720         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3721         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3722           log_error(_("selected cipher algorithm is invalid\n"));
3723     }
3724     if( s2k_digest_string ) {
3725         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3726         xfree(s2k_digest_string); s2k_digest_string = NULL;
3727         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3728           log_error(_("selected digest algorithm is invalid\n"));
3729     }
3730     if( opt.completes_needed < 1 )
3731       log_error(_("completes-needed must be greater than 0\n"));
3732     if( opt.marginals_needed < 2 )
3733       log_error(_("marginals-needed must be greater than 1\n"));
3734     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3735       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3736     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3737       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3738     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3739       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3740     switch( opt.s2k_mode ) {
3741       case 0:
3742         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3743         break;
3744       case 1: case 3: break;
3745       default:
3746         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3747     }
3748
3749     /* This isn't actually needed, but does serve to error out if the
3750        string is invalid. */
3751     if(opt.def_preference_list &&
3752         keygen_set_std_prefs(opt.def_preference_list,0))
3753       log_error(_("invalid default preferences\n"));
3754
3755     if(pers_cipher_list &&
3756        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3757       log_error(_("invalid personal cipher preferences\n"));
3758
3759     if(pers_digest_list &&
3760        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3761       log_error(_("invalid personal digest preferences\n"));
3762
3763     if(pers_compress_list &&
3764        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3765       log_error(_("invalid personal compress preferences\n"));
3766
3767     /* We don't support all possible commands with multifile yet */
3768     if(multifile)
3769       {
3770         char *cmdname;
3771
3772         switch(cmd)
3773           {
3774           case aSign:
3775             cmdname="--sign";
3776             break;
3777           case aSignEncr:
3778             cmdname="--sign --encrypt";
3779             break;
3780           case aClearsign:
3781             cmdname="--clear-sign";
3782             break;
3783           case aDetachedSign:
3784             cmdname="--detach-sign";
3785             break;
3786           case aSym:
3787             cmdname="--symmetric";
3788             break;
3789           case aEncrSym:
3790             cmdname="--symmetric --encrypt";
3791             break;
3792           case aStore:
3793             cmdname="--store";
3794             break;
3795           default:
3796             cmdname=NULL;
3797             break;
3798           }
3799
3800         if(cmdname)
3801           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3802       }
3803
3804     if( log_get_errorcount(0) )
3805         g10_exit(2);
3806
3807     if(opt.compress_level==0)
3808       opt.compress_algo=COMPRESS_ALGO_NONE;
3809
3810     /* Check our chosen algorithms against the list of legal
3811        algorithms. */
3812
3813     if(!GNUPG)
3814       {
3815         const char *badalg=NULL;
3816         preftype_t badtype=PREFTYPE_NONE;
3817
3818         if(opt.def_cipher_algo
3819            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3820           {
3821             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3822             badtype = PREFTYPE_SYM;
3823           }
3824         else if(opt.def_digest_algo
3825                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3826           {
3827             badalg = gcry_md_algo_name (opt.def_digest_algo);
3828             badtype = PREFTYPE_HASH;
3829           }
3830         else if(opt.cert_digest_algo
3831                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3832           {
3833             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3834             badtype = PREFTYPE_HASH;
3835           }
3836         else if(opt.compress_algo!=-1
3837                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3838           {
3839             badalg = compress_algo_to_string(opt.compress_algo);
3840             badtype = PREFTYPE_ZIP;
3841           }
3842
3843         if(badalg)
3844           {
3845             switch(badtype)
3846               {
3847               case PREFTYPE_SYM:
3848                 log_info(_("you may not use cipher algorithm '%s'"
3849                            " while in %s mode\n"),
3850                          badalg,compliance_option_string());
3851                 break;
3852               case PREFTYPE_HASH:
3853                 log_info(_("you may not use digest algorithm '%s'"
3854                            " while in %s mode\n"),
3855                          badalg,compliance_option_string());
3856                 break;
3857               case PREFTYPE_ZIP:
3858                 log_info(_("you may not use compression algorithm '%s'"
3859                            " while in %s mode\n"),
3860                          badalg,compliance_option_string());
3861                 break;
3862               default:
3863                 BUG();
3864               }
3865
3866             compliance_failure();
3867           }
3868       }
3869
3870     /* Set the random seed file. */
3871     if( use_random_seed ) {
3872       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
3873         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3874         if (!access (p, F_OK))
3875           register_secured_file (p);
3876         xfree(p);
3877     }
3878
3879     /* If there is no command but the --fingerprint is given, default
3880        to the --list-keys command.  */
3881     if (!cmd && fpr_maybe_cmd)
3882       {
3883         set_cmd (&cmd, aListKeys);
3884       }
3885
3886
3887     if( opt.verbose > 1 )
3888         set_packet_list_mode(1);
3889
3890     /* Add the keyrings, but not for some special commands.  We always
3891      * need to add the keyrings if we are running under SELinux, this
3892      * is so that the rings are added to the list of secured files.
3893      * We do not add any keyring if --no-keyring has been used.  */
3894     if (default_keyring >= 0
3895         && (ALWAYS_ADD_KEYRINGS
3896             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
3897       {
3898         if (!nrings || default_keyring > 0)  /* Add default ring. */
3899             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3900                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3901         for (sl = nrings; sl; sl = sl->next )
3902           keydb_add_resource (sl->d, sl->flags);
3903       }
3904     FREE_STRLIST(nrings);
3905
3906     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3907       /* In loopback mode, never ask for the password multiple
3908          times.  */
3909       {
3910         opt.passphrase_repeat = 0;
3911       }
3912
3913     if (cmd == aGPGConfTest)
3914       g10_exit(0);
3915
3916
3917     if (pwfd != -1)  /* Read the passphrase now. */
3918       read_passphrase_from_fd (pwfd);
3919
3920     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
3921       read_sessionkey_from_fd (ovrseskeyfd);
3922
3923     fname = argc? *argv : NULL;
3924
3925     if(fname && utf8_strings)
3926       opt.flags.utf8_filename=1;
3927
3928     ctrl = xcalloc (1, sizeof *ctrl);
3929     gpg_init_default_ctrl (ctrl);
3930
3931 #ifndef NO_TRUST_MODELS
3932     switch (cmd)
3933       {
3934       case aPrimegen:
3935       case aPrintMD:
3936       case aPrintMDs:
3937       case aGenRandom:
3938       case aDeArmor:
3939       case aEnArmor:
3940       case aListConfig:
3941       case aListGcryptConfig:
3942         break;
3943       case aFixTrustDB:
3944       case aExportOwnerTrust:
3945         rc = setup_trustdb (0, trustdb_name);
3946         break;
3947       case aListTrustDB:
3948         rc = setup_trustdb (argc? 1:0, trustdb_name);
3949         break;
3950       default:
3951         /* If we are using TM_ALWAYS, we do not need to create the
3952            trustdb.  */
3953         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3954         break;
3955       }
3956     if (rc)
3957       log_error (_("failed to initialize the TrustDB: %s\n"),
3958                  gpg_strerror (rc));
3959 #endif /*!NO_TRUST_MODELS*/
3960
3961     switch (cmd)
3962       {
3963       case aStore:
3964       case aSym:
3965       case aSign:
3966       case aSignSym:
3967       case aClearsign:
3968         if (!opt.quiet && any_explicit_recipient)
3969           log_info (_("WARNING: recipients (-r) given "
3970                       "without using public key encryption\n"));
3971         break;
3972       default:
3973         break;
3974       }
3975
3976
3977     /* Check for certain command whether we need to migrate a
3978        secring.gpg to the gpg-agent. */
3979     switch (cmd)
3980       {
3981       case aListSecretKeys:
3982       case aSign:
3983       case aSignEncr:
3984       case aSignEncrSym:
3985       case aSignSym:
3986       case aClearsign:
3987       case aDecrypt:
3988       case aSignKey:
3989       case aLSignKey:
3990       case aEditKey:
3991       case aPasswd:
3992       case aDeleteSecretKeys:
3993       case aDeleteSecretAndPublicKeys:
3994       case aQuickKeygen:
3995       case aQuickAddUid:
3996       case aQuickAddKey:
3997       case aQuickRevUid:
3998       case aFullKeygen:
3999       case aKeygen:
4000       case aImport:
4001       case aExportSecret:
4002       case aExportSecretSub:
4003       case aGenRevoke:
4004       case aDesigRevoke:
4005       case aCardEdit:
4006       case aChangePIN:
4007         migrate_secring (ctrl);
4008         break;
4009       case aListKeys:
4010         if (opt.with_secret)
4011           migrate_secring (ctrl);
4012         break;
4013       default:
4014         break;
4015       }
4016
4017     /* The command dispatcher.  */
4018     switch( cmd )
4019       {
4020       case aServer:
4021         gpg_server (ctrl);
4022         break;
4023
4024       case aStore: /* only store the file */
4025         if( argc > 1 )
4026             wrong_args("--store [filename]");
4027         if( (rc = encrypt_store(fname)) )
4028           {
4029             write_status_failure ("store", rc);
4030             log_error ("storing '%s' failed: %s\n",
4031                        print_fname_stdin(fname),gpg_strerror (rc) );
4032           }
4033         break;
4034       case aSym: /* encrypt the given file only with the symmetric cipher */
4035         if( argc > 1 )
4036             wrong_args("--symmetric [filename]");
4037         if( (rc = encrypt_symmetric(fname)) )
4038           {
4039             write_status_failure ("symencrypt", rc);
4040             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4041                         print_fname_stdin(fname),gpg_strerror (rc) );
4042           }
4043         break;
4044
4045       case aEncr: /* encrypt the given file */
4046         if(multifile)
4047           encrypt_crypt_files (ctrl, argc, argv, remusr);
4048         else
4049           {
4050             if( argc > 1 )
4051               wrong_args("--encrypt [filename]");
4052             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4053               {
4054                 write_status_failure ("encrypt", rc);
4055                 log_error("%s: encryption failed: %s\n",
4056                           print_fname_stdin(fname), gpg_strerror (rc) );
4057               }
4058           }
4059         break;
4060
4061       case aEncrSym:
4062         /* This works with PGP 8 in the sense that it acts just like a
4063            symmetric message.  It doesn't work at all with 2 or 6.  It
4064            might work with 7, but alas, I don't have a copy to test
4065            with right now. */
4066         if( argc > 1 )
4067           wrong_args("--symmetric --encrypt [filename]");
4068         else if(opt.s2k_mode==0)
4069           log_error(_("you cannot use --symmetric --encrypt"
4070                       " with --s2k-mode 0\n"));
4071         else if(PGP6 || PGP7)
4072           log_error(_("you cannot use --symmetric --encrypt"
4073                       " while in %s mode\n"),compliance_option_string());
4074         else
4075           {
4076             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4077               {
4078                 write_status_failure ("encrypt", rc);
4079                 log_error ("%s: encryption failed: %s\n",
4080                            print_fname_stdin(fname), gpg_strerror (rc) );
4081               }
4082           }
4083         break;
4084
4085       case aSign: /* sign the given file */
4086         sl = NULL;
4087         if( detached_sig ) { /* sign all files */
4088             for( ; argc; argc--, argv++ )
4089                 add_to_strlist( &sl, *argv );
4090         }
4091         else {
4092             if( argc > 1 )
4093                 wrong_args("--sign [filename]");
4094             if( argc ) {
4095                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4096                 strcpy(sl->d, fname);
4097             }
4098         }
4099         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
4100           {
4101             write_status_failure ("sign", rc);
4102             log_error ("signing failed: %s\n", gpg_strerror (rc) );
4103           }
4104         free_strlist(sl);
4105         break;
4106
4107       case aSignEncr: /* sign and encrypt the given file */
4108         if( argc > 1 )
4109             wrong_args("--sign --encrypt [filename]");
4110         if( argc ) {
4111             sl = xmalloc_clear( sizeof *sl + strlen(fname));
4112             strcpy(sl->d, fname);
4113         }
4114         else
4115             sl = NULL;
4116         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
4117           {
4118             write_status_failure ("sign-encrypt", rc);
4119             log_error("%s: sign+encrypt failed: %s\n",
4120                       print_fname_stdin(fname), gpg_strerror (rc) );
4121           }
4122         free_strlist(sl);
4123         break;
4124
4125       case aSignEncrSym: /* sign and encrypt the given file */
4126         if( argc > 1 )
4127             wrong_args("--symmetric --sign --encrypt [filename]");
4128         else if(opt.s2k_mode==0)
4129           log_error(_("you cannot use --symmetric --sign --encrypt"
4130                       " with --s2k-mode 0\n"));
4131         else if(PGP6 || PGP7)
4132           log_error(_("you cannot use --symmetric --sign --encrypt"
4133                       " while in %s mode\n"),compliance_option_string());
4134         else
4135           {
4136             if( argc )
4137               {
4138                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4139                 strcpy(sl->d, fname);
4140               }
4141             else
4142               sl = NULL;
4143             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
4144                                  2, remusr, NULL)))
4145               {
4146                 write_status_failure ("sign-encrypt", rc);
4147                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
4148                           print_fname_stdin(fname), gpg_strerror (rc) );
4149               }
4150             free_strlist(sl);
4151           }
4152         break;
4153
4154       case aSignSym: /* sign and conventionally encrypt the given file */
4155         if (argc > 1)
4156             wrong_args("--sign --symmetric [filename]");
4157         rc = sign_symencrypt_file (ctrl, fname, locusr);
4158         if (rc)
4159           {
4160             write_status_failure ("sign-symencrypt", rc);
4161             log_error("%s: sign+symmetric failed: %s\n",
4162                       print_fname_stdin(fname), gpg_strerror (rc) );
4163           }
4164         break;
4165
4166       case aClearsign: /* make a clearsig */
4167         if( argc > 1 )
4168             wrong_args("--clear-sign [filename]");
4169         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
4170           {
4171             write_status_failure ("sign", rc);
4172             log_error("%s: clear-sign failed: %s\n",
4173                       print_fname_stdin(fname), gpg_strerror (rc) );
4174           }
4175         break;
4176
4177       case aVerify:
4178         if (multifile)
4179           {
4180             if ((rc = verify_files (ctrl, argc, argv)))
4181               log_error("verify files failed: %s\n", gpg_strerror (rc) );
4182           }
4183         else
4184           {
4185             if ((rc = verify_signatures (ctrl, argc, argv)))
4186               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
4187           }
4188         if (rc)
4189           write_status_failure ("verify", rc);
4190         break;
4191
4192       case aDecrypt:
4193         if (multifile)
4194           decrypt_messages (ctrl, argc, argv);
4195         else
4196           {
4197             if( argc > 1 )
4198               wrong_args("--decrypt [filename]");
4199             if( (rc = decrypt_message (ctrl, fname) ))
4200               {
4201                 write_status_failure ("decrypt", rc);
4202                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
4203               }
4204           }
4205         break;
4206
4207       case aQuickSignKey:
4208       case aQuickLSignKey:
4209         {
4210           const char *fpr;
4211
4212           if (argc < 1)
4213             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
4214           fpr = *argv++; argc--;
4215           sl = NULL;
4216           for( ; argc; argc--, argv++)
4217             append_to_strlist2 (&sl, *argv, utf8_strings);
4218           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
4219           free_strlist (sl);
4220         }
4221         break;
4222
4223       case aSignKey:
4224         if( argc != 1 )
4225           wrong_args("--sign-key user-id");
4226         /* fall through */
4227       case aLSignKey:
4228         if( argc != 1 )
4229           wrong_args("--lsign-key user-id");
4230         /* fall through */
4231
4232         sl=NULL;
4233
4234         if(cmd==aSignKey)
4235           append_to_strlist(&sl,"sign");
4236         else if(cmd==aLSignKey)
4237           append_to_strlist(&sl,"lsign");
4238         else
4239           BUG();
4240
4241         append_to_strlist( &sl, "save" );
4242         username = make_username( fname );
4243         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4244         xfree(username);
4245         free_strlist(sl);
4246         break;
4247
4248       case aEditKey: /* Edit a key signature */
4249         if( !argc )
4250             wrong_args("--edit-key user-id [commands]");
4251         username = make_username( fname );
4252         if( argc > 1 ) {
4253             sl = NULL;
4254             for( argc--, argv++ ; argc; argc--, argv++ )
4255                 append_to_strlist( &sl, *argv );
4256             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4257             free_strlist(sl);
4258         }
4259         else
4260             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4261         xfree(username);
4262         break;
4263
4264       case aPasswd:
4265         if (argc != 1)
4266           wrong_args("--change-passphrase <user-id>");
4267         else
4268           {
4269             username = make_username (fname);
4270             keyedit_passwd (ctrl, username);
4271             xfree (username);
4272           }
4273         break;
4274
4275       case aDeleteKeys:
4276       case aDeleteSecretKeys:
4277       case aDeleteSecretAndPublicKeys:
4278         sl = NULL;
4279         /* I'm adding these in reverse order as add_to_strlist2
4280            reverses them again, and it's easier to understand in the
4281            proper order :) */
4282         for( ; argc; argc-- )
4283           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
4284         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
4285         free_strlist(sl);
4286         break;
4287
4288       case aCheckKeys:
4289         opt.check_sigs = 1;
4290       case aListSigs:
4291         opt.list_sigs = 1;
4292       case aListKeys:
4293         sl = NULL;
4294         for( ; argc; argc--, argv++ )
4295             add_to_strlist2( &sl, *argv, utf8_strings );
4296         public_key_list (ctrl, sl, 0);
4297         free_strlist(sl);
4298         break;
4299       case aListSecretKeys:
4300         sl = NULL;
4301         for( ; argc; argc--, argv++ )
4302             add_to_strlist2( &sl, *argv, utf8_strings );
4303         secret_key_list (ctrl, sl);
4304         free_strlist(sl);
4305         break;
4306       case aLocateKeys:
4307         sl = NULL;
4308         for (; argc; argc--, argv++)
4309           add_to_strlist2( &sl, *argv, utf8_strings );
4310         public_key_list (ctrl, sl, 1);
4311         free_strlist (sl);
4312         break;
4313
4314       case aQuickKeygen:
4315         {
4316           const char *x_algo, *x_usage, *x_expire;
4317
4318           if (argc < 1 || argc > 4)
4319             wrong_args("--quick-generate-key USER-ID [ALGO [USAGE [EXPIRE]]]");
4320           username = make_username (fname);
4321           argv++, argc--;
4322           x_algo = "";
4323           x_usage = "";
4324           x_expire = "";
4325           if (argc)
4326             {
4327               x_algo = *argv++; argc--;
4328               if (argc)
4329                 {
4330                   x_usage = *argv++; argc--;
4331                   if (argc)
4332                     {
4333                       x_expire = *argv++; argc--;
4334                     }
4335                 }
4336             }
4337           quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
4338           xfree (username);
4339         }
4340         break;
4341
4342       case aKeygen: /* generate a key */
4343         if( opt.batch ) {
4344             if( argc > 1 )
4345                 wrong_args("--generate-key [parameterfile]");
4346             generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4347         }
4348         else {
4349             if (opt.command_fd != -1 && argc)
4350               {
4351                 if( argc > 1 )
4352                   wrong_args("--generate-key [parameterfile]");
4353
4354                 opt.batch = 1;
4355                 generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4356               }
4357             else if (argc)
4358               wrong_args ("--generate-key");
4359             else
4360               generate_keypair (ctrl, 0, NULL, NULL, 0);
4361         }
4362         break;
4363
4364       case aFullKeygen: /* Generate a key with all options. */
4365         if (opt.batch)
4366           {
4367             if (argc > 1)
4368               wrong_args ("--full-generate-key [parameterfile]");
4369             generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
4370           }
4371         else
4372           {
4373             if (argc)
4374               wrong_args("--full-generate-key");
4375             generate_keypair (ctrl, 1, NULL, NULL, 0);
4376         }
4377         break;
4378
4379       case aQuickAddUid:
4380         {
4381           const char *uid, *newuid;
4382
4383           if (argc != 2)
4384             wrong_args ("--quick-add-uid USER-ID NEW-USER-ID");
4385           uid = *argv++; argc--;
4386           newuid = *argv++; argc--;
4387           keyedit_quick_adduid (ctrl, uid, newuid);
4388         }
4389         break;
4390
4391       case aQuickAddKey:
4392         {
4393           const char *x_fpr, *x_algo, *x_usage, *x_expire;
4394
4395           if (argc < 1 || argc > 4)
4396             wrong_args ("--quick-add-key FINGERPRINT [ALGO [USAGE [EXPIRE]]]");
4397           x_fpr = *argv++; argc--;
4398           x_algo = "";
4399           x_usage = "";
4400           x_expire = "";
4401           if (argc)
4402             {
4403               x_algo = *argv++; argc--;
4404               if (argc)
4405                 {
4406                   x_usage = *argv++; argc--;
4407                   if (argc)
4408                    {
4409                      x_expire = *argv++; argc--;
4410                    }
4411                 }
4412             }
4413           keyedit_quick_addkey (ctrl, x_fpr, x_algo, x_usage, x_expire);
4414         }
4415         break;
4416
4417       case aQuickRevUid:
4418         {
4419           const char *uid, *uidtorev;
4420
4421           if (argc != 2)
4422             wrong_args ("--quick-revoke-uid USER-ID USER-ID-TO-REVOKE");
4423           uid = *argv++; argc--;
4424           uidtorev = *argv++; argc--;
4425           keyedit_quick_revuid (ctrl, uid, uidtorev);
4426         }
4427         break;
4428
4429       case aQuickSetExpire:
4430         {
4431           const char *x_fpr, *x_expire;
4432
4433           if (argc != 2)
4434             wrong_args ("--quick-set-exipre FINGERPRINT EXPIRE");
4435           x_fpr = *argv++; argc--;
4436           x_expire = *argv++; argc--;
4437           keyedit_quick_set_expire (ctrl, x_fpr, x_expire);
4438         }
4439         break;
4440
4441       case aFastImport:
4442         opt.import_options |= IMPORT_FAST;
4443       case aImport:
4444         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
4445         break;
4446
4447         /* TODO: There are a number of command that use this same
4448            "make strlist, call function, report error, free strlist"
4449            pattern.  Join them together here and avoid all that
4450            duplicated code. */
4451
4452       case aExport:
4453       case aSendKeys:
4454       case aRecvKeys:
4455         sl = NULL;
4456         for( ; argc; argc--, argv++ )
4457             append_to_strlist2( &sl, *argv, utf8_strings );
4458         if( cmd == aSendKeys )
4459             rc = keyserver_export (ctrl, sl );
4460         else if( cmd == aRecvKeys )
4461             rc = keyserver_import (ctrl, sl );
4462         else
4463           {
4464             export_stats_t stats = export_new_stats ();
4465             rc = export_pubkeys (ctrl, sl, opt.export_options, stats);
4466             export_print_stats (stats);
4467             export_release_stats (stats);
4468           }
4469         if(rc)
4470           {
4471             if(cmd==aSendKeys)
4472               {
4473                 write_status_failure ("send-keys", rc);
4474                 log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
4475               }
4476             else if(cmd==aRecvKeys)
4477               {
4478                 write_status_failure ("recv-keys", rc);
4479                 log_error (_("keyserver receive failed: %s\n"),
4480                            gpg_strerror (rc));
4481               }
4482             else
4483               {
4484                 write_status_failure ("export", rc);
4485                 log_error (_("key export failed: %s\n"), gpg_strerror (rc));
4486               }
4487           }
4488         free_strlist(sl);
4489         break;
4490
4491       case aExportSshKey:
4492         if (argc != 1)
4493           wrong_args ("--export-ssh-key <user-id>");
4494         rc = export_ssh_key (ctrl, argv[0]);
4495         if (rc)
4496           {
4497             write_status_failure ("export-ssh-key", rc);
4498             log_error (_("export as ssh key failed: %s\n"), gpg_strerror (rc));
4499           }
4500         break;
4501
4502      case aSearchKeys:
4503         sl = NULL;
4504         for (; argc; argc--, argv++)
4505           append_to_strlist2 (&sl, *argv, utf8_strings);
4506         rc = keyserver_search (ctrl, sl);
4507         if (rc)
4508           {
4509             write_status_failure ("search-keys", rc);
4510             log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
4511           }
4512         free_strlist (sl);
4513         break;
4514
4515       case aRefreshKeys:
4516         sl = NULL;
4517         for( ; argc; argc--, argv++ )
4518             append_to_strlist2( &sl, *argv, utf8_strings );
4519         rc = keyserver_refresh (ctrl, sl);
4520         if(rc)
4521           {
4522             write_status_failure ("refresh-keys", rc);
4523             log_error (_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
4524           }
4525         free_strlist(sl);
4526         break;
4527
4528       case aFetchKeys:
4529         sl = NULL;
4530         for( ; argc; argc--, argv++ )
4531             append_to_strlist2( &sl, *argv, utf8_strings );
4532         rc = keyserver_fetch (ctrl, sl);
4533         if(rc)
4534           {
4535             write_status_failure ("fetch-keys", rc);
4536             log_error ("key fetch failed: %s\n",gpg_strerror (rc));
4537           }
4538         free_strlist(sl);
4539         break;
4540
4541       case aExportSecret:
4542         sl = NULL;
4543         for( ; argc; argc--, argv++ )
4544             add_to_strlist2( &sl, *argv, utf8_strings );
4545         {
4546           export_stats_t stats = export_new_stats ();
4547           export_seckeys (ctrl, sl, stats);
4548           export_print_stats (stats);
4549           export_release_stats (stats);
4550         }
4551         free_strlist(sl);
4552         break;
4553
4554       case aExportSecretSub:
4555         sl = NULL;
4556         for( ; argc; argc--, argv++ )
4557             add_to_strlist2( &sl, *argv, utf8_strings );
4558         {
4559           export_stats_t stats = export_new_stats ();
4560           export_secsubkeys (ctrl, sl, stats);
4561           export_print_stats (stats);
4562           export_release_stats (stats);
4563         }
4564         free_strlist(sl);
4565         break;
4566
4567       case aGenRevoke:
4568         if( argc != 1 )
4569             wrong_args("--generate-revocation user-id");
4570         username =  make_username(*argv);
4571         gen_revoke( username );
4572         xfree( username );
4573         break;
4574
4575       case aDesigRevoke:
4576         if (argc != 1)
4577             wrong_args ("--generate-designated-revocation user-id");
4578         username = make_username (*argv);
4579         gen_desig_revoke (ctrl, username, locusr);
4580         xfree (username);
4581         break;
4582
4583       case aDeArmor:
4584         if( argc > 1 )
4585             wrong_args("--dearmor [file]");
4586         rc = dearmor_file( argc? *argv: NULL );
4587         if( rc )
4588           {
4589             write_status_failure ("dearmor", rc);
4590             log_error (_("dearmoring failed: %s\n"), gpg_strerror (rc));
4591           }
4592         break;
4593
4594       case aEnArmor:
4595         if( argc > 1 )
4596             wrong_args("--enarmor [file]");
4597         rc = enarmor_file( argc? *argv: NULL );
4598         if( rc )
4599           {
4600             write_status_failure ("enarmor", rc);
4601             log_error (_("enarmoring failed: %s\n"), gpg_strerror (rc));
4602           }
4603         break;
4604
4605
4606       case aPrimegen:
4607 #if 0 /*FIXME*/
4608         {   int mode = argc < 2 ? 0 : atoi(*argv);
4609
4610             if( mode == 1 && argc == 2 ) {
4611                 mpi_print (es_stdout,
4612                            generate_public_prime( atoi(argv[1]) ), 1);
4613             }
4614             else if( mode == 2 && argc == 3 ) {
4615                 mpi_print (es_stdout, generate_elg_prime(
4616                                              0, atoi(argv[1]),
4617                                              atoi(argv[2]), NULL,NULL ), 1);
4618             }
4619             else if( mode == 3 && argc == 3 ) {
4620                 MPI *factors;
4621                 mpi_print (es_stdout, generate_elg_prime(
4622                                              1, atoi(argv[1]),
4623                                              atoi(argv[2]), NULL,&factors ), 1);
4624                 es_putc ('\n', es_stdout);
4625                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
4626             }
4627             else if( mode == 4 && argc == 3 ) {
4628                 MPI g = mpi_alloc(1);
4629                 mpi_print (es_stdout, generate_elg_prime(
4630                                                  0, atoi(argv[1]),
4631                                                  atoi(argv[2]), g, NULL ), 1);
4632                 es_putc ('\n', es_stdout);
4633                 mpi_print (es_stdout, g, 1 );
4634                 mpi_free (g);
4635             }
4636             else
4637                 wrong_args("--gen-prime mode bits [qbits] ");
4638             es_putc ('\n', es_stdout);
4639         }
4640 #endif
4641         wrong_args("--gen-prime not yet supported ");
4642         break;
4643
4644       case aGenRandom:
4645         {
4646             int level = argc ? atoi(*argv):0;
4647             int count = argc > 1 ? atoi(argv[1]): 0;
4648             int endless = !count;
4649
4650             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
4651                 wrong_args("--gen-random 0|1|2 [count]");
4652
4653             while( endless || count ) {
4654                 byte *p;
4655                 /* Wee need a multiple of 3, so that in case of
4656                    armored output we get a correct string.  No
4657                    linefolding is done, as it is best to levae this to
4658                    other tools */
4659                 size_t n = !endless && count < 99? count : 99;
4660
4661                 p = gcry_random_bytes (n, level);
4662 #ifdef HAVE_DOSISH_SYSTEM
4663                 setmode ( fileno(stdout), O_BINARY );
4664 #endif
4665                 if (opt.armor) {
4666                     char *tmp = make_radix64_string (p, n);
4667                     es_fputs (tmp, es_stdout);
4668                     xfree (tmp);
4669                     if (n%3 == 1)
4670                       es_putc ('=', es_stdout);
4671                     if (n%3)
4672                       es_putc ('=', es_stdout);
4673                 } else {
4674                     es_fwrite( p, n, 1, es_stdout );
4675                 }
4676                 xfree(p);
4677                 if( !endless )
4678                     count -= n;
4679             }
4680             if (opt.armor)
4681               es_putc ('\n', es_stdout);
4682         }
4683         break;
4684
4685       case aPrintMD:
4686         if( argc < 1)
4687             wrong_args("--print-md algo [files]");
4688         {
4689             int all_algos = (**argv=='*' && !(*argv)[1]);
4690             int algo = all_algos? 0 : gcry_md_map_name (*argv);
4691
4692             if( !algo && !all_algos )
4693                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
4694             else {
4695                 argc--; argv++;
4696                 if( !argc )
4697                     print_mds(NULL, algo);
4698                 else {
4699                     for(; argc; argc--, argv++ )
4700                         print_mds(*argv, algo);
4701                 }
4702             }
4703         }
4704         break;
4705
4706       case aPrintMDs: /* old option */
4707         if( !argc )
4708             print_mds(NULL,0);
4709         else {
4710             for(; argc; argc--, argv++ )
4711                 print_mds(*argv,0);
4712         }
4713         break;
4714
4715 #ifndef NO_TRUST_MODELS
4716       case aListTrustDB:
4717         if( !argc )
4718           list_trustdb (es_stdout, NULL);
4719         else {
4720             for( ; argc; argc--, argv++ )
4721               list_trustdb (es_stdout, *argv );
4722         }
4723         break;
4724
4725       case aUpdateTrustDB:
4726         if( argc )
4727             wrong_args("--update-trustdb");
4728         update_trustdb (ctrl);
4729         break;
4730
4731       case aCheckTrustDB:
4732         /* Old versions allowed for arguments - ignore them */
4733         check_trustdb (ctrl);
4734         break;
4735
4736       case aFixTrustDB:
4737         how_to_fix_the_trustdb ();
4738         break;
4739
4740       case aListTrustPath:
4741         if( !argc )
4742             wrong_args("--list-trust-path <user-ids>");
4743         for( ; argc; argc--, argv++ ) {
4744             username = make_username( *argv );
4745             list_trust_path( username );
4746             xfree(username);
4747         }
4748         break;
4749
4750       case aExportOwnerTrust:
4751         if( argc )
4752             wrong_args("--export-ownertrust");
4753         export_ownertrust();
4754         break;
4755
4756       case aImportOwnerTrust:
4757         if( argc > 1 )
4758             wrong_args("--import-ownertrust [file]");
4759         import_ownertrust( argc? *argv:NULL );
4760         break;
4761 #endif /*!NO_TRUST_MODELS*/
4762
4763       case aRebuildKeydbCaches:
4764         if (argc)
4765             wrong_args ("--rebuild-keydb-caches");
4766         keydb_rebuild_caches (1);
4767         break;
4768
4769 #ifdef ENABLE_CARD_SUPPORT
4770       case aCardStatus:
4771         if (argc)
4772             wrong_args ("--card-status");
4773         card_status (es_stdout, NULL, 0);
4774         break;
4775
4776       case aCardEdit:
4777         if (argc) {
4778             sl = NULL;
4779             for (argc--, argv++ ; argc; argc--, argv++)
4780                 append_to_strlist (&sl, *argv);
4781             card_edit (ctrl, sl);
4782             free_strlist (sl);
4783         }
4784         else
4785           card_edit (ctrl, NULL);
4786         break;
4787
4788       case aChangePIN:
4789         if (!argc)
4790             change_pin (0,1);
4791         else if (argc == 1)
4792             change_pin (atoi (*argv),1);
4793         else
4794             wrong_args ("--change-pin [no]");
4795         break;
4796 #endif /* ENABLE_CARD_SUPPORT*/
4797
4798       case aListConfig:
4799         {
4800           char *str=collapse_args(argc,argv);
4801           list_config(str);
4802           xfree(str);
4803         }
4804         break;
4805
4806       case aListGcryptConfig:
4807         /* Fixme: It would be nice to integrate that with
4808            --list-config but unfortunately there is no way yet to have
4809            libgcrypt print it to an estream for further parsing.  */
4810         gcry_control (GCRYCTL_PRINT_CONFIG, stdout);
4811         break;
4812
4813       case aTOFUPolicy:
4814 #ifdef USE_TOFU
4815         {
4816           int policy;
4817           int i;
4818           KEYDB_HANDLE hd;
4819
4820           if (argc < 2)
4821             wrong_args ("--tofu-policy POLICY KEYID [KEYID...]");
4822
4823           policy = parse_tofu_policy (argv[0]);
4824
4825           hd = keydb_new ();
4826           if (! hd)
4827             g10_exit (1);
4828
4829           tofu_begin_batch_update (ctrl);
4830
4831           for (i = 1; i < argc; i ++)
4832             {
4833               KEYDB_SEARCH_DESC desc;
4834               kbnode_t kb;
4835
4836               rc = classify_user_id (argv[i], &desc, 0);
4837               if (rc)
4838                 {
4839                   log_error (_("error parsing key specification '%s': %s\n"),
4840                              argv[i], gpg_strerror (rc));
4841                   g10_exit (1);
4842                 }
4843
4844               if (! (desc.mode == KEYDB_SEARCH_MODE_SHORT_KID
4845                      || desc.mode == KEYDB_SEARCH_MODE_LONG_KID
4846                      || desc.mode == KEYDB_SEARCH_MODE_FPR16
4847                      || desc.mode == KEYDB_SEARCH_MODE_FPR20
4848                      || desc.mode == KEYDB_SEARCH_MODE_FPR
4849                      || desc.mode == KEYDB_SEARCH_MODE_KEYGRIP))
4850                 {
4851                   log_error (_("'%s' does not appear to be a valid"
4852                                " key ID, fingerprint or keygrip\n"),
4853                              argv[i]);
4854                   g10_exit (1);
4855                 }
4856
4857               rc = keydb_search_reset (hd);
4858               if (rc)
4859                 {
4860                   /* This should not happen, thus no need to tranalate
4861                      the string.  */
4862                   log_error ("keydb_search_reset failed: %s\n",
4863                              gpg_strerror (rc));
4864                   g10_exit (1);
4865                 }
4866
4867               rc = keydb_search (hd, &desc, 1, NULL);
4868               if (rc)
4869                 {
4870                   log_error (_("key \"%s\" not found: %s\n"), argv[i],
4871                              gpg_strerror (rc));
4872                   g10_exit (1);
4873                 }
4874
4875               rc = keydb_get_keyblock (hd, &kb);
4876               if (rc)
4877                 {
4878                   log_error (_("error reading keyblock: %s\n"),
4879                              gpg_strerror (rc));
4880                   g10_exit (1);
4881                 }
4882
4883               merge_keys_and_selfsig (kb);
4884               if (tofu_set_policy (ctrl, kb, policy))
4885                 g10_exit (1);
4886
4887               release_kbnode (kb);
4888             }
4889
4890           tofu_end_batch_update (ctrl);
4891
4892           keydb_release (hd);
4893         }
4894 #endif /*USE_TOFU*/
4895         break;
4896
4897       default:
4898         if (!opt.quiet)
4899           log_info (_("WARNING: no command supplied."
4900                       "  Trying to guess what you mean ...\n"));
4901         /*FALLTHU*/
4902       case aListPackets:
4903         if( argc > 1 )
4904             wrong_args("[filename]");
4905         /* Issue some output for the unix newbie */
4906         if (!fname && !opt.outfile
4907             && gnupg_isatty (fileno (stdin))
4908             && gnupg_isatty (fileno (stdout))
4909             && gnupg_isatty (fileno (stderr)))
4910             log_info(_("Go ahead and type your message ...\n"));
4911
4912         a = iobuf_open(fname);
4913         if (a && is_secured_file (iobuf_get_fd (a)))
4914           {
4915             iobuf_close (a);
4916             a = NULL;
4917             gpg_err_set_errno (EPERM);
4918           }
4919         if( !a )
4920             log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
4921         else {
4922
4923             if( !opt.no_armor ) {
4924                 if( use_armor_filter( a ) ) {
4925                     afx = new_armor_context ();
4926                     push_armor_filter (afx, a);
4927                 }
4928             }
4929             if( cmd == aListPackets ) {
4930                 opt.list_packets=1;
4931                 set_packet_list_mode(1);
4932             }
4933             rc = proc_packets (ctrl, NULL, a );
4934             if( rc )
4935               {
4936                 write_status_failure ("-", rc);
4937                 log_error ("processing message failed: %s\n",
4938                            gpg_strerror (rc));
4939               }
4940             iobuf_close(a);
4941         }
4942         break;
4943       }
4944
4945     /* cleanup */
4946     gpg_deinit_default_ctrl (ctrl);
4947     xfree (ctrl);
4948     release_armor_context (afx);
4949     FREE_STRLIST(remusr);
4950     FREE_STRLIST(locusr);
4951     g10_exit(0);
4952     return 8; /*NEVER REACHED*/
4953 }
4954
4955
4956 /* Note: This function is used by signal handlers!. */
4957 static void
4958 emergency_cleanup (void)
4959 {
4960   gcry_control (GCRYCTL_TERM_SECMEM );
4961 }
4962
4963
4964 void
4965 g10_exit( int rc )
4966 {
4967   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
4968   if (DBG_CLOCK)
4969     log_clock ("stop");
4970
4971   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
4972     {
4973       keydb_dump_stats ();
4974       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
4975       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
4976     }
4977   if (opt.debug)
4978     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
4979
4980   emergency_cleanup ();
4981
4982   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
4983   exit (rc);
4984 }
4985
4986
4987 /* Pretty-print hex hashes.  This assumes at least an 80-character
4988    display, but there are a few other similar assumptions in the
4989    display code. */
4990 static void
4991 print_hex (gcry_md_hd_t md, int algo, const char *fname)
4992 {
4993   int i,n,count,indent=0;
4994   const byte *p;
4995
4996   if (fname)
4997     indent = es_printf("%s: ",fname);
4998
4999   if (indent>40)
5000     {
5001       es_printf ("\n");
5002       indent=0;
5003     }
5004
5005   if (algo==DIGEST_ALGO_RMD160)
5006     indent += es_printf("RMD160 = ");
5007   else if (algo>0)
5008     indent += es_printf("%6s = ", gcry_md_algo_name (algo));
5009   else
5010     algo = abs(algo);
5011
5012   count = indent;
5013
5014   p = gcry_md_read (md, algo);
5015   n = gcry_md_get_algo_dlen (algo);
5016
5017   count += es_printf ("%02X",*p++);
5018
5019   for(i=1;i<n;i++,p++)
5020     {
5021       if(n==16)
5022         {
5023           if(count+2>79)
5024             {
5025               es_printf ("\n%*s",indent," ");
5026               count = indent;
5027             }
5028           else
5029             count += es_printf(" ");
5030
5031           if (!(i%8))
5032             count += es_printf(" ");
5033         }
5034       else if (n==20)
5035         {
5036           if(!(i%2))
5037             {
5038               if(count+4>79)
5039                 {
5040                   es_printf ("\n%*s",indent," ");
5041                   count=indent;
5042                 }
5043               else
5044                 count += es_printf(" ");
5045             }
5046
5047           if (!(i%10))
5048             count += es_printf(" ");
5049         }
5050       else
5051         {
5052           if(!(i%4))
5053             {
5054               if (count+8>79)
5055                 {
5056                   es_printf ("\n%*s",indent," ");
5057                   count=indent;
5058                 }
5059               else
5060                 count += es_printf(" ");
5061             }
5062         }
5063
5064       count += es_printf("%02X",*p);
5065     }
5066
5067   es_printf ("\n");
5068 }
5069
5070 static void
5071 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
5072 {
5073   int i, n;
5074   const byte *p;
5075
5076   if ( fname )
5077     {
5078       for (p = fname; *p; p++ )
5079         {
5080           if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
5081             es_printf ("%%%02X", *p );
5082           else
5083             es_putc (*p, es_stdout);
5084         }
5085     }
5086   es_putc (':', es_stdout);
5087   es_printf ("%d:", algo);
5088   p = gcry_md_read (md, algo);
5089   n = gcry_md_get_algo_dlen (algo);
5090   for(i=0; i < n ; i++, p++ )
5091     es_printf ("%02X", *p);
5092   es_fputs (":\n", es_stdout);
5093 }
5094
5095
5096 static void
5097 print_mds( const char *fname, int algo )
5098 {
5099   estream_t fp;
5100   char buf[1024];
5101   size_t n;
5102   gcry_md_hd_t md;
5103
5104   if (!fname)
5105     {
5106       fp = es_stdin;
5107       es_set_binary (fp);
5108     }
5109   else
5110     {
5111       fp = es_fopen (fname, "rb" );
5112       if (fp && is_secured_file (es_fileno (fp)))
5113         {
5114           es_fclose (fp);
5115           fp = NULL;
5116           gpg_err_set_errno (EPERM);
5117         }
5118     }
5119   if (!fp)
5120     {
5121       log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
5122       return;
5123     }
5124
5125   gcry_md_open (&md, 0, 0);
5126   if (algo)
5127     gcry_md_enable (md, algo);
5128   else
5129     {
5130       if (!gcry_md_test_algo (GCRY_MD_MD5))
5131         gcry_md_enable (md, GCRY_MD_MD5);
5132       gcry_md_enable (md, GCRY_MD_SHA1);
5133       if (!gcry_md_test_algo (GCRY_MD_RMD160))
5134         gcry_md_enable (md, GCRY_MD_RMD160);
5135       if (!gcry_md_test_algo (GCRY_MD_SHA224))
5136         gcry_md_enable (md, GCRY_MD_SHA224);
5137       if (!gcry_md_test_algo (GCRY_MD_SHA256))
5138         gcry_md_enable (md, GCRY_MD_SHA256);
5139       if (!gcry_md_test_algo (GCRY_MD_SHA384))
5140         gcry_md_enable (md, GCRY_MD_SHA384);
5141       if (!gcry_md_test_algo (GCRY_MD_SHA512))
5142         gcry_md_enable (md, GCRY_MD_SHA512);
5143     }
5144
5145   while ((n=es_fread (buf, 1, DIM(buf), fp)))
5146     gcry_md_write (md, buf, n);
5147
5148   if (es_ferror(fp))
5149     log_error ("%s: %s\n", fname?fname:"[stdin]", strerror(errno));
5150   else
5151     {
5152       gcry_md_final (md);
5153       if (opt.with_colons)
5154         {
5155           if ( algo )
5156             print_hashline (md, algo, fname);
5157           else
5158             {
5159               if (!gcry_md_test_algo (GCRY_MD_MD5))
5160                 print_hashline( md, GCRY_MD_MD5, fname );
5161               print_hashline( md, GCRY_MD_SHA1, fname );
5162               if (!gcry_md_test_algo (GCRY_MD_RMD160))
5163                 print_hashline( md, GCRY_MD_RMD160, fname );
5164               if (!gcry_md_test_algo (GCRY_MD_SHA224))
5165                 print_hashline (md, GCRY_MD_SHA224, fname);
5166               if (!gcry_md_test_algo (GCRY_MD_SHA256))
5167                 print_hashline( md, GCRY_MD_SHA256, fname );
5168               if (!gcry_md_test_algo (GCRY_MD_SHA384))
5169                 print_hashline ( md, GCRY_MD_SHA384, fname );
5170               if (!gcry_md_test_algo (GCRY_MD_SHA512))
5171                 print_hashline ( md, GCRY_MD_SHA512, fname );
5172             }
5173         }
5174       else
5175         {
5176           if (algo)
5177             print_hex (md, -algo, fname);
5178           else
5179             {
5180               if (!gcry_md_test_algo (GCRY_MD_MD5))
5181                 print_hex (md, GCRY_MD_MD5, fname);
5182               print_hex (md, GCRY_MD_SHA1, fname );
5183               if (!gcry_md_test_algo (GCRY_MD_RMD160))
5184                 print_hex (md, GCRY_MD_RMD160, fname );
5185               if (!gcry_md_test_algo (GCRY_MD_SHA224))
5186                 print_hex (md, GCRY_MD_SHA224, fname);
5187               if (!gcry_md_test_algo (GCRY_MD_SHA256))
5188                 print_hex (md, GCRY_MD_SHA256, fname );
5189               if (!gcry_md_test_algo (GCRY_MD_SHA384))
5190                 print_hex (md, GCRY_MD_SHA384, fname );
5191               if (!gcry_md_test_algo (GCRY_MD_SHA512))
5192                 print_hex (md, GCRY_MD_SHA512, fname );
5193             }
5194         }
5195     }
5196   gcry_md_close (md);
5197
5198   if (fp != es_stdin)
5199     es_fclose (fp);
5200 }
5201
5202
5203 /****************
5204  * Check the supplied name,value string and add it to the notation
5205  * data to be used for signatures.  which==0 for sig notations, and 1
5206  * for cert notations.
5207 */
5208 static void
5209 add_notation_data( const char *string, int which )
5210 {
5211   struct notation *notation;
5212
5213   notation=string_to_notation(string,utf8_strings);
5214   if(notation)
5215     {
5216       if(which)
5217         {
5218           notation->next=opt.cert_notations;
5219           opt.cert_notations=notation;
5220         }
5221       else
5222         {
5223           notation->next=opt.sig_notations;
5224           opt.sig_notations=notation;
5225         }
5226     }
5227 }
5228
5229 static void
5230 add_policy_url( const char *string, int which )
5231 {
5232   unsigned int i,critical=0;
5233   strlist_t sl;
5234
5235   if(*string=='!')
5236     {
5237       string++;
5238       critical=1;
5239     }
5240
5241   for(i=0;i<strlen(string);i++)
5242     if( !isascii (string[i]) || iscntrl(string[i]))
5243       break;
5244
5245   if(i==0 || i<strlen(string))
5246     {
5247       if(which)
5248         log_error(_("the given certification policy URL is invalid\n"));
5249       else
5250         log_error(_("the given signature policy URL is invalid\n"));
5251     }
5252
5253   if(which)
5254     sl=add_to_strlist( &opt.cert_policy_url, string );
5255   else
5256     sl=add_to_strlist( &opt.sig_policy_url, string );
5257
5258   if(critical)
5259     sl->flags |= 1;
5260 }
5261
5262 static void
5263 add_keyserver_url( const char *string, int which )
5264 {
5265   unsigned int i,critical=0;
5266   strlist_t sl;
5267
5268   if(*string=='!')
5269     {
5270       string++;
5271       critical=1;
5272     }
5273
5274   for(i=0;i<strlen(string);i++)
5275     if( !isascii (string[i]) || iscntrl(string[i]))
5276       break;
5277
5278   if(i==0 || i<strlen(string))
5279     {
5280       if(which)
5281         BUG();
5282       else
5283         log_error(_("the given preferred keyserver URL is invalid\n"));
5284     }
5285
5286   if(which)
5287     BUG();
5288   else
5289     sl=add_to_strlist( &opt.sig_keyserver_url, string );
5290
5291   if(critical)
5292     sl->flags |= 1;
5293 }
5294
5295
5296 static void
5297 read_sessionkey_from_fd (int fd)
5298 {
5299   int i, len;
5300   char *line;
5301
5302   if (! gnupg_fd_valid (fd))
5303     log_fatal ("override-session-key-fd is invalid: %s\n", strerror (errno));
5304
5305   for (line = NULL, i = len = 100; ; i++ )
5306     {
5307       if (i >= len-1 )
5308         {
5309           char *tmp = line;
5310           len += 100;
5311           line = xmalloc_secure (len);
5312           if (tmp)
5313             {
5314               memcpy (line, tmp, i);
5315               xfree (tmp);
5316             }
5317           else
5318             i=0;
5319         }
5320       if (read (fd, line + i, 1) != 1 || line[i] == '\n')
5321         break;
5322     }
5323   line[i] = 0;
5324   log_debug ("seskey: %s\n", line);
5325   gpgrt_annotate_leaked_object (line);
5326   opt.override_session_key = line;
5327 }