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   es_printf ("trust-model:%lu:\n", GC_OPT_FLAG_NONE);
1849
1850   /* The next one is an info only item and should match the macros at
1851      the top of keygen.c  */
1852   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1853              get_default_pubkey_algo ());
1854
1855   xfree (configfile_esc);
1856 }
1857
1858
1859 static int
1860 parse_subpacket_list(char *list)
1861 {
1862   char *tok;
1863   byte subpackets[128],i;
1864   int count=0;
1865
1866   if(!list)
1867     {
1868       /* No arguments means all subpackets */
1869       memset(subpackets+1,1,sizeof(subpackets)-1);
1870       count=127;
1871     }
1872   else
1873     {
1874       memset(subpackets,0,sizeof(subpackets));
1875
1876       /* Merge with earlier copy */
1877       if(opt.show_subpackets)
1878         {
1879           byte *in;
1880
1881           for(in=opt.show_subpackets;*in;in++)
1882             {
1883               if(*in>127 || *in<1)
1884                 BUG();
1885
1886               if(!subpackets[*in])
1887                 count++;
1888               subpackets[*in]=1;
1889             }
1890         }
1891
1892       while((tok=strsep(&list," ,")))
1893         {
1894           if(!*tok)
1895             continue;
1896
1897           i=atoi(tok);
1898           if(i>127 || i<1)
1899             return 0;
1900
1901           if(!subpackets[i])
1902             count++;
1903           subpackets[i]=1;
1904         }
1905     }
1906
1907   xfree(opt.show_subpackets);
1908   opt.show_subpackets=xmalloc(count+1);
1909   opt.show_subpackets[count--]=0;
1910
1911   for(i=1;i<128 && count>=0;i++)
1912     if(subpackets[i])
1913       opt.show_subpackets[count--]=i;
1914
1915   return 1;
1916 }
1917
1918
1919 static int
1920 parse_list_options(char *str)
1921 {
1922   char *subpackets=""; /* something that isn't NULL */
1923   struct parse_options lopts[]=
1924     {
1925       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1926        N_("display photo IDs during key listings")},
1927       {"show-usage",LIST_SHOW_USAGE,NULL,
1928        N_("show key usage information during key listings")},
1929       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1930        N_("show policy URLs during signature listings")},
1931       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1932        N_("show all notations during signature listings")},
1933       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1934        N_("show IETF standard notations during signature listings")},
1935       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1936        NULL},
1937       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1938        N_("show user-supplied notations during signature listings")},
1939       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1940        N_("show preferred keyserver URLs during signature listings")},
1941       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1942        N_("show user ID validity during key listings")},
1943       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1944        N_("show revoked and expired user IDs in key listings")},
1945       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1946        N_("show revoked and expired subkeys in key listings")},
1947       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1948        N_("show the keyring name in key listings")},
1949       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1950        N_("show expiration dates during signature listings")},
1951       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1952        NULL},
1953       {NULL,0,NULL,NULL}
1954     };
1955
1956   /* C99 allows for non-constant initializers, but we'd like to
1957      compile everywhere, so fill in the show-sig-subpackets argument
1958      here.  Note that if the parse_options array changes, we'll have
1959      to change the subscript here. */
1960   lopts[13].value=&subpackets;
1961
1962   if(parse_options(str,&opt.list_options,lopts,1))
1963     {
1964       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1965         {
1966           /* Unset so users can pass multiple lists in. */
1967           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1968           if(!parse_subpacket_list(subpackets))
1969             return 0;
1970         }
1971       else if(subpackets==NULL && opt.show_subpackets)
1972         {
1973           /* User did 'no-show-subpackets' */
1974           xfree(opt.show_subpackets);
1975           opt.show_subpackets=NULL;
1976         }
1977
1978       return 1;
1979     }
1980   else
1981     return 0;
1982 }
1983
1984
1985 /* Collapses argc/argv into a single string that must be freed */
1986 static char *
1987 collapse_args(int argc,char *argv[])
1988 {
1989   char *str=NULL;
1990   int i,first=1,len=0;
1991
1992   for(i=0;i<argc;i++)
1993     {
1994       len+=strlen(argv[i])+2;
1995       str=xrealloc(str,len);
1996       if(first)
1997         {
1998           str[0]='\0';
1999           first=0;
2000         }
2001       else
2002         strcat(str," ");
2003
2004       strcat(str,argv[i]);
2005     }
2006
2007   return str;
2008 }
2009
2010
2011 #ifndef NO_TRUST_MODELS
2012 static void
2013 parse_trust_model(const char *model)
2014 {
2015   if(ascii_strcasecmp(model,"pgp")==0)
2016     opt.trust_model=TM_PGP;
2017   else if(ascii_strcasecmp(model,"classic")==0)
2018     opt.trust_model=TM_CLASSIC;
2019   else if(ascii_strcasecmp(model,"always")==0)
2020     opt.trust_model=TM_ALWAYS;
2021   else if(ascii_strcasecmp(model,"direct")==0)
2022     opt.trust_model=TM_DIRECT;
2023 #ifdef USE_TOFU
2024   else if(ascii_strcasecmp(model,"tofu")==0)
2025     opt.trust_model=TM_TOFU;
2026   else if(ascii_strcasecmp(model,"tofu+pgp")==0)
2027     opt.trust_model=TM_TOFU_PGP;
2028 #endif /*USE_TOFU*/
2029   else if(ascii_strcasecmp(model,"auto")==0)
2030     opt.trust_model=TM_AUTO;
2031   else
2032     log_error("unknown trust model '%s'\n",model);
2033 }
2034 #endif /*NO_TRUST_MODELS*/
2035
2036
2037 static int
2038 parse_tofu_policy (const char *policystr)
2039 {
2040 #ifdef USE_TOFU
2041   struct { const char *keyword; int policy; } list[] = {
2042     { "auto",    TOFU_POLICY_AUTO },
2043     { "good",    TOFU_POLICY_GOOD },
2044     { "unknown", TOFU_POLICY_UNKNOWN },
2045     { "bad",     TOFU_POLICY_BAD },
2046     { "ask",     TOFU_POLICY_ASK }
2047   };
2048   int i;
2049
2050   if (!ascii_strcasecmp (policystr, "help"))
2051     {
2052       log_info (_("valid values for option '%s':\n"), "--tofu-policy");
2053       for (i=0; i < DIM (list); i++)
2054         log_info ("  %s\n", list[i].keyword);
2055       g10_exit (1);
2056     }
2057
2058   for (i=0; i < DIM (list); i++)
2059     if (!ascii_strcasecmp (policystr, list[i].keyword))
2060       return list[i].policy;
2061 #endif /*USE_TOFU*/
2062
2063   log_error (_("unknown TOFU policy '%s'\n"), policystr);
2064   if (!opt.quiet)
2065     log_info (_("(use \"help\" to list choices)\n"));
2066   g10_exit (1);
2067 }
2068
2069
2070 /* Parse the value of --compliance.  */
2071 static int
2072 parse_compliance_option (const char *string)
2073 {
2074   struct { const char *keyword; enum cmd_and_opt_values option; } list[] = {
2075     { "gnupg",      oGnuPG },
2076     { "openpgp",    oOpenPGP },
2077     { "rfc4880bis", oRFC4880bis },
2078     { "rfc4880",    oRFC4880 },
2079     { "rfc2440",    oRFC2440 },
2080     { "pgp6",       oPGP6 },
2081     { "pgp7",       oPGP7 },
2082     { "pgp8",       oPGP8 },
2083     { "de-vs",      oDE_VS }
2084   };
2085   int i;
2086
2087   if (!ascii_strcasecmp (string, "help"))
2088     {
2089       log_info (_("valid values for option '%s':\n"), "--compliance");
2090       for (i=0; i < DIM (list); i++)
2091         log_info ("  %s\n", list[i].keyword);
2092       g10_exit (1);
2093     }
2094
2095   for (i=0; i < DIM (list); i++)
2096     if (!ascii_strcasecmp (string, list[i].keyword))
2097       return list[i].option;
2098
2099   log_error (_("invalid value for option '%s'\n"), "--compliance");
2100   if (!opt.quiet)
2101     log_info (_("(use \"help\" to list choices)\n"));
2102   g10_exit (1);
2103 }
2104
2105
2106
2107 /* Helper to set compliance related options.  This is a separte
2108  * function so that it can also be used by the --compliance option
2109  * parser.  */
2110 static void
2111 set_compliance_option (enum cmd_and_opt_values option)
2112 {
2113   switch (option)
2114     {
2115     case oRFC4880bis:
2116       opt.flags.rfc4880bis = 1;
2117       /* fall through.  */
2118     case oOpenPGP:
2119     case oRFC4880:
2120       /* This is effectively the same as RFC2440, but with
2121          "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2122          --require-cross-certification". */
2123       opt.compliance = CO_RFC4880;
2124       opt.flags.dsa2 = 1;
2125       opt.flags.require_cross_cert = 1;
2126       opt.rfc2440_text = 0;
2127       opt.allow_non_selfsigned_uid = 1;
2128       opt.allow_freeform_uid = 1;
2129       opt.escape_from = 1;
2130       opt.not_dash_escaped = 0;
2131       opt.def_cipher_algo = 0;
2132       opt.def_digest_algo = 0;
2133       opt.cert_digest_algo = 0;
2134       opt.compress_algo = -1;
2135       opt.s2k_mode = 3; /* iterated+salted */
2136       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2137       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2138       break;
2139     case oRFC2440:
2140       opt.compliance = CO_RFC2440;
2141       opt.flags.dsa2 = 0;
2142       opt.rfc2440_text = 1;
2143       opt.allow_non_selfsigned_uid = 1;
2144       opt.allow_freeform_uid = 1;
2145       opt.escape_from = 0;
2146       opt.not_dash_escaped = 0;
2147       opt.def_cipher_algo = 0;
2148       opt.def_digest_algo = 0;
2149       opt.cert_digest_algo = 0;
2150       opt.compress_algo = -1;
2151       opt.s2k_mode = 3; /* iterated+salted */
2152       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2153       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2154       break;
2155     case oPGP6:  opt.compliance = CO_PGP6;  break;
2156     case oPGP7:  opt.compliance = CO_PGP7;  break;
2157     case oPGP8:  opt.compliance = CO_PGP8;  break;
2158     case oGnuPG: opt.compliance = CO_GNUPG; break;
2159
2160     case oDE_VS:
2161       set_compliance_option (oOpenPGP);
2162       opt.compliance = CO_DE_VS;
2163       /* Fixme: Change other options.  */
2164       break;
2165
2166     default:
2167       BUG ();
2168     }
2169 }
2170
2171
2172
2173
2174
2175
2176 /* This function called to initialized a new control object.  It is
2177    assumed that this object has been zeroed out before calling this
2178    function. */
2179 static void
2180 gpg_init_default_ctrl (ctrl_t ctrl)
2181 {
2182   (void)ctrl;
2183 }
2184
2185
2186 /* This function is called to deinitialize a control object.  It is
2187    not deallocated. */
2188 static void
2189 gpg_deinit_default_ctrl (ctrl_t ctrl)
2190 {
2191 #ifdef USE_TOFU
2192   tofu_closedbs (ctrl);
2193 #endif
2194   gpg_dirmngr_deinit_session_data (ctrl);
2195 }
2196
2197
2198 char *
2199 get_default_configname (void)
2200 {
2201   char *configname = NULL;
2202   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2203   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2204
2205   do
2206     {
2207       if (configname)
2208         {
2209           char *tok;
2210
2211           xfree (configname);
2212           configname = NULL;
2213
2214           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2215             *tok='\0';
2216           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2217             *tok='\0';
2218           else
2219             break;
2220         }
2221
2222       configname = make_filename (gnupg_homedir (), name, NULL);
2223     }
2224   while (access (configname, R_OK));
2225
2226   xfree(name);
2227
2228   if (! configname)
2229     configname = make_filename (gnupg_homedir (),
2230                                 GPG_NAME EXTSEP_S "conf", NULL);
2231   if (! access (configname, R_OK))
2232     {
2233       /* Print a warning when both config files are present.  */
2234       char *p = make_filename (gnupg_homedir (), "options", NULL);
2235       if (! access (p, R_OK))
2236         log_info (_("Note: old default options file '%s' ignored\n"), p);
2237       xfree (p);
2238     }
2239   else
2240     {
2241       /* Use the old default only if it exists.  */
2242       char *p = make_filename (gnupg_homedir (), "options", NULL);
2243       if (!access (p, R_OK))
2244         {
2245           xfree (configname);
2246           configname = p;
2247         }
2248       else
2249         xfree (p);
2250     }
2251
2252   return configname;
2253 }
2254
2255 int
2256 main (int argc, char **argv)
2257 {
2258     ARGPARSE_ARGS pargs;
2259     IOBUF a;
2260     int rc=0;
2261     int orig_argc;
2262     char **orig_argv;
2263     const char *fname;
2264     char *username;
2265     int may_coredump;
2266     strlist_t sl;
2267     strlist_t remusr = NULL;
2268     strlist_t locusr = NULL;
2269     strlist_t nrings = NULL;
2270     armor_filter_context_t *afx = NULL;
2271     int detached_sig = 0;
2272     FILE *configfp = NULL;
2273     char *configname = NULL;
2274     char *save_configname = NULL;
2275     char *default_configname = NULL;
2276     unsigned configlineno;
2277     int parse_debug = 0;
2278     int default_config = 1;
2279     int default_keyring = 1;
2280     int greeting = 0;
2281     int nogreeting = 0;
2282     char *logfile = NULL;
2283     int use_random_seed = 1;
2284     enum cmd_and_opt_values cmd = 0;
2285     const char *debug_level = NULL;
2286 #ifndef NO_TRUST_MODELS
2287     const char *trustdb_name = NULL;
2288 #endif /*!NO_TRUST_MODELS*/
2289     char *def_cipher_string = NULL;
2290     char *def_digest_string = NULL;
2291     char *compress_algo_string = NULL;
2292     char *cert_digest_string = NULL;
2293     char *s2k_cipher_string = NULL;
2294     char *s2k_digest_string = NULL;
2295     char *pers_cipher_list = NULL;
2296     char *pers_digest_list = NULL;
2297     char *pers_compress_list = NULL;
2298     int eyes_only=0;
2299     int multifile=0;
2300     int pwfd = -1;
2301     int ovrseskeyfd = -1;
2302     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2303     int any_explicit_recipient = 0;
2304     int require_secmem = 0;
2305     int got_secmem = 0;
2306     struct assuan_malloc_hooks malloc_hooks;
2307     ctrl_t ctrl;
2308
2309     static int print_dane_records;
2310     static int print_pka_records;
2311
2312
2313 #ifdef __riscos__
2314     opt.lock_once = 1;
2315 #endif /* __riscos__ */
2316
2317     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2318        when adding any stuff between here and the call to
2319        secmem_init() somewhere after the option parsing. */
2320     early_system_init ();
2321     gnupg_reopen_std (GPG_NAME);
2322     trap_unaligned ();
2323     gnupg_rl_initialize ();
2324     set_strusage (my_strusage);
2325     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2326     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
2327
2328     /* Make sure that our subsystems are ready.  */
2329     i18n_init();
2330     init_common_subsystems (&argc, &argv);
2331
2332     /* Use our own logging handler for Libcgrypt.  */
2333     setup_libgcrypt_logging ();
2334
2335     /* Put random number into secure memory */
2336     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2337
2338     may_coredump = disable_core_dumps();
2339
2340     gnupg_init_signals (0, emergency_cleanup);
2341
2342     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2343
2344     opt.autostart = 1;
2345     opt.session_env = session_env_new ();
2346     if (!opt.session_env)
2347       log_fatal ("error allocating session environment block: %s\n",
2348                  strerror (errno));
2349
2350     opt.command_fd = -1; /* no command fd */
2351     opt.compress_level = -1; /* defaults to standard compress level */
2352     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2353     /* note: if you change these lines, look at oOpenPGP */
2354     opt.def_cipher_algo = 0;
2355     opt.def_digest_algo = 0;
2356     opt.cert_digest_algo = 0;
2357     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2358     opt.s2k_mode = 3; /* iterated+salted */
2359     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2360     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2361     opt.completes_needed = 1;
2362     opt.marginals_needed = 3;
2363     opt.max_cert_depth = 5;
2364     opt.escape_from = 1;
2365     opt.flags.require_cross_cert = 1;
2366     opt.import_options = 0;
2367     opt.export_options = EXPORT_ATTRIBUTES;
2368     opt.keyserver_options.import_options = IMPORT_REPAIR_PKS_SUBKEY_BUG;
2369     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2370     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2371     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2372                           | VERIFY_SHOW_POLICY_URLS
2373                           | VERIFY_SHOW_STD_NOTATIONS
2374                           | VERIFY_SHOW_KEYSERVER_URLS);
2375     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2376                           | LIST_SHOW_USAGE);
2377 #ifdef NO_TRUST_MODELS
2378     opt.trust_model = TM_ALWAYS;
2379 #else
2380     opt.trust_model = TM_AUTO;
2381 #endif
2382     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2383     opt.mangle_dos_filenames = 0;
2384     opt.min_cert_level = 2;
2385     set_screen_dimensions ();
2386     opt.keyid_format = KF_NONE;
2387     opt.def_sig_expire = "0";
2388     opt.def_cert_expire = "0";
2389     gnupg_set_homedir (NULL);
2390     opt.passphrase_repeat = 1;
2391     opt.emit_version = 0;
2392     opt.weak_digests = NULL;
2393     additional_weak_digest("MD5");
2394
2395     /* Check whether we have a config file on the command line.  */
2396     orig_argc = argc;
2397     orig_argv = argv;
2398     pargs.argc = &argc;
2399     pargs.argv = &argv;
2400     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2401     while( arg_parse( &pargs, opts) ) {
2402         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2403             parse_debug++;
2404         else if (pargs.r_opt == oDebugIOLBF)
2405             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2406         else if( pargs.r_opt == oOptions ) {
2407             /* yes there is one, so we do not try the default one, but
2408              * read the option file when it is encountered at the commandline
2409              */
2410             default_config = 0;
2411         }
2412         else if( pargs.r_opt == oNoOptions )
2413           {
2414             default_config = 0; /* --no-options */
2415             opt.no_homedir_creation = 1;
2416           }
2417         else if( pargs.r_opt == oHomedir )
2418             gnupg_set_homedir (pargs.r.ret_str);
2419         else if( pargs.r_opt == oNoPermissionWarn )
2420             opt.no_perm_warn=1;
2421         else if (pargs.r_opt == oStrict )
2422           {
2423             /* Not used */
2424           }
2425         else if (pargs.r_opt == oNoStrict )
2426           {
2427             /* Not used */
2428           }
2429     }
2430
2431 #ifdef HAVE_DOSISH_SYSTEM
2432     if ( strchr (gnupg_homedir (), '\\') ) {
2433       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2434       const char *s;
2435       for (d=buf, s = gnupg_homedir (); *s; s++)
2436           {
2437             *d++ = *s == '\\'? '/': *s;
2438 #ifdef HAVE_W32_SYSTEM
2439             if (s[1] && IsDBCSLeadByte (*s))
2440               *d++ = *++s;
2441 #endif
2442           }
2443         *d = 0;
2444         gnupg_set_homedir (buf);
2445     }
2446 #endif
2447
2448     /* Initialize the secure memory. */
2449     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2450       got_secmem = 1;
2451 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2452     /* There should be no way to get to this spot while still carrying
2453        setuid privs.  Just in case, bomb out if we are. */
2454     if ( getuid () != geteuid () )
2455       BUG ();
2456 #endif
2457     maybe_setuid = 0;
2458
2459     /* Okay, we are now working under our real uid */
2460
2461     /* malloc hooks go here ... */
2462     malloc_hooks.malloc = gcry_malloc;
2463     malloc_hooks.realloc = gcry_realloc;
2464     malloc_hooks.free = gcry_free;
2465     assuan_set_malloc_hooks (&malloc_hooks);
2466     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2467     setup_libassuan_logging (&opt.debug, NULL);
2468
2469     /* Try for a version specific config file first */
2470     default_configname = get_default_configname ();
2471     if (default_config)
2472       configname = xstrdup (default_configname);
2473
2474     argc = orig_argc;
2475     argv = orig_argv;
2476     pargs.argc = &argc;
2477     pargs.argv = &argv;
2478     pargs.flags= ARGPARSE_FLAG_KEEP;
2479
2480     /* By this point we have a homedir, and cannot change it. */
2481     check_permissions (gnupg_homedir (), 0);
2482
2483   next_pass:
2484     if( configname ) {
2485       if(check_permissions(configname,1))
2486         {
2487           /* If any options file is unsafe, then disable any external
2488              programs for keyserver calls or photo IDs.  Since the
2489              external program to call is set in the options file, a
2490              unsafe options file can lead to an arbitrary program
2491              being run. */
2492
2493           opt.exec_disable=1;
2494         }
2495
2496         configlineno = 0;
2497         configfp = fopen( configname, "r" );
2498         if (configfp && is_secured_file (fileno (configfp)))
2499           {
2500             fclose (configfp);
2501             configfp = NULL;
2502             gpg_err_set_errno (EPERM);
2503           }
2504         if( !configfp ) {
2505             if( default_config ) {
2506                 if( parse_debug )
2507                     log_info(_("Note: no default option file '%s'\n"),
2508                                                             configname );
2509             }
2510             else {
2511                 log_error(_("option file '%s': %s\n"),
2512                                     configname, strerror(errno) );
2513                 g10_exit(2);
2514             }
2515             xfree(configname); configname = NULL;
2516         }
2517         if( parse_debug && configname )
2518             log_info(_("reading options from '%s'\n"), configname );
2519         default_config = 0;
2520     }
2521
2522     while( optfile_parse( configfp, configname, &configlineno,
2523                                                 &pargs, opts) )
2524       {
2525         switch( pargs.r_opt )
2526           {
2527           case aListConfig:
2528           case aListGcryptConfig:
2529           case aGPGConfList:
2530           case aGPGConfTest:
2531             set_cmd (&cmd, pargs.r_opt);
2532             /* Do not register a keyring for these commands.  */
2533             default_keyring = -1;
2534             break;
2535
2536           case aCheckKeys:
2537           case aListPackets:
2538           case aImport:
2539           case aFastImport:
2540           case aSendKeys:
2541           case aRecvKeys:
2542           case aSearchKeys:
2543           case aRefreshKeys:
2544           case aFetchKeys:
2545           case aExport:
2546 #ifdef ENABLE_CARD_SUPPORT
2547           case aCardStatus:
2548           case aCardEdit:
2549           case aChangePIN:
2550 #endif /* ENABLE_CARD_SUPPORT*/
2551           case aListKeys:
2552           case aLocateKeys:
2553           case aListSigs:
2554           case aExportSecret:
2555           case aExportSecretSub:
2556           case aExportSshKey:
2557           case aSym:
2558           case aClearsign:
2559           case aGenRevoke:
2560           case aDesigRevoke:
2561           case aPrimegen:
2562           case aGenRandom:
2563           case aPrintMD:
2564           case aPrintMDs:
2565           case aListTrustDB:
2566           case aCheckTrustDB:
2567           case aUpdateTrustDB:
2568           case aFixTrustDB:
2569           case aListTrustPath:
2570           case aDeArmor:
2571           case aEnArmor:
2572           case aSign:
2573           case aQuickSignKey:
2574           case aQuickLSignKey:
2575           case aSignKey:
2576           case aLSignKey:
2577           case aStore:
2578           case aQuickKeygen:
2579           case aQuickAddUid:
2580           case aQuickAddKey:
2581           case aQuickRevUid:
2582           case aQuickSetExpire:
2583           case aExportOwnerTrust:
2584           case aImportOwnerTrust:
2585           case aRebuildKeydbCaches:
2586             set_cmd (&cmd, pargs.r_opt);
2587             break;
2588
2589           case aKeygen:
2590           case aFullKeygen:
2591           case aEditKey:
2592           case aDeleteSecretKeys:
2593           case aDeleteSecretAndPublicKeys:
2594           case aDeleteKeys:
2595           case aPasswd:
2596             set_cmd (&cmd, pargs.r_opt);
2597             greeting=1;
2598             break;
2599
2600           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2601
2602           case aDecryptFiles: multifile=1; /* fall through */
2603           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2604
2605           case aEncrFiles: multifile=1; /* fall through */
2606           case aEncr: set_cmd( &cmd, aEncr); break;
2607
2608           case aVerifyFiles: multifile=1; /* fall through */
2609           case aVerify: set_cmd( &cmd, aVerify); break;
2610
2611           case aServer:
2612             set_cmd (&cmd, pargs.r_opt);
2613             opt.batch = 1;
2614             break;
2615
2616           case aTOFUPolicy:
2617             set_cmd (&cmd, pargs.r_opt);
2618             break;
2619
2620           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2621           case oOutput: opt.outfile = pargs.r.ret_str; break;
2622
2623           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2624
2625           case oInputSizeHint:
2626             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2627             break;
2628
2629           case oQuiet: opt.quiet = 1; break;
2630           case oNoTTY: tty_no_terminal(1); break;
2631           case oDryRun: opt.dry_run = 1; break;
2632           case oInteractive: opt.interactive = 1; break;
2633           case oVerbose:
2634             opt.verbose++;
2635             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2636             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2637             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2638             break;
2639
2640           case oBatch:
2641             opt.batch = 1;
2642             nogreeting = 1;
2643             break;
2644
2645           case oUseAgent: /* Dummy. */
2646             break;
2647
2648           case oNoUseAgent:
2649             obsolete_option (configname, configlineno, "no-use-agent");
2650             break;
2651           case oGpgAgentInfo:
2652             obsolete_option (configname, configlineno, "gpg-agent-info");
2653             break;
2654           case oReaderPort:
2655             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2656             break;
2657           case octapiDriver:
2658             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2659             break;
2660           case opcscDriver:
2661             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2662             break;
2663           case oDisableCCID:
2664             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2665             break;
2666           case oHonorHttpProxy:
2667             obsolete_option (configname, configlineno, "honor-http-proxy");
2668             break;
2669
2670           case oAnswerYes: opt.answer_yes = 1; break;
2671           case oAnswerNo: opt.answer_no = 1; break;
2672           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2673           case oPrimaryKeyring:
2674             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2675             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2676             break;
2677           case oShowKeyring:
2678             deprecated_warning(configname,configlineno,"--show-keyring",
2679                                "--list-options ","show-keyring");
2680             opt.list_options|=LIST_SHOW_KEYRING;
2681             break;
2682
2683           case oDebug:
2684             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2685               {
2686                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2687                 pargs.err = ARGPARSE_PRINT_ERROR;
2688               }
2689             break;
2690
2691           case oDebugAll: opt.debug = ~0; break;
2692           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2693
2694           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2695
2696           case oStatusFD:
2697             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2698             break;
2699           case oStatusFile:
2700             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2701             break;
2702           case oAttributeFD:
2703             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2704             break;
2705           case oAttributeFile:
2706             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2707             break;
2708           case oLoggerFD:
2709             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2710             break;
2711           case oLoggerFile:
2712             logfile = pargs.r.ret_str;
2713             break;
2714
2715           case oWithFingerprint:
2716             opt.with_fingerprint = 1;
2717             opt.fingerprint++;
2718             break;
2719           case oWithSubkeyFingerprint:
2720             opt.with_subkey_fingerprint = 1;
2721             break;
2722           case oWithICAOSpelling:
2723             opt.with_icao_spelling = 1;
2724             break;
2725           case oFingerprint:
2726             opt.fingerprint++;
2727             fpr_maybe_cmd = 1;
2728             break;
2729
2730           case oWithKeygrip:
2731             opt.with_keygrip = 1;
2732             break;
2733
2734           case oWithSecret:
2735             opt.with_secret = 1;
2736             break;
2737
2738           case oWithWKDHash:
2739             opt.with_wkd_hash = 1;
2740             break;
2741
2742           case oSecretKeyring:
2743             /* Ignore this old option.  */
2744             break;
2745
2746           case oOptions:
2747             /* config files may not be nested (silently ignore them) */
2748             if( !configfp ) {
2749                 xfree(configname);
2750                 configname = xstrdup(pargs.r.ret_str);
2751                 goto next_pass;
2752             }
2753             break;
2754           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2755
2756           case oNoDefKeyring:
2757             if (default_keyring > 0)
2758               default_keyring = 0;
2759             break;
2760           case oNoKeyring:
2761             default_keyring = -1;
2762             break;
2763
2764           case oNoGreeting: nogreeting = 1; break;
2765           case oNoVerbose:
2766             opt.verbose = 0;
2767             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2768             opt.list_sigs=0;
2769             break;
2770           case oQuickRandom:
2771             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2772             break;
2773           case oEmitVersion: opt.emit_version++; break;
2774           case oNoEmitVersion: opt.emit_version=0; break;
2775           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2776           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2777           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2778
2779 #ifndef NO_TRUST_MODELS
2780           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2781
2782 #endif /*!NO_TRUST_MODELS*/
2783           case oDefaultKey:
2784             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2785             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2786             if (configfp)
2787               sl->flags |= PK_LIST_CONFIG;
2788             break;
2789           case oDefRecipient:
2790             if( *pargs.r.ret_str )
2791               {
2792                 xfree (opt.def_recipient);
2793                 opt.def_recipient = make_username(pargs.r.ret_str);
2794               }
2795             break;
2796           case oDefRecipientSelf:
2797             xfree(opt.def_recipient); opt.def_recipient = NULL;
2798             opt.def_recipient_self = 1;
2799             break;
2800           case oNoDefRecipient:
2801             xfree(opt.def_recipient); opt.def_recipient = NULL;
2802             opt.def_recipient_self = 0;
2803             break;
2804           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2805           case oHomedir: break;
2806           case oNoBatch: opt.batch = 0; break;
2807
2808           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2809
2810           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2811           case oWithColons: opt.with_colons=':'; break;
2812
2813           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2814           case oWithSigList: opt.list_sigs = 1; break;
2815
2816           case oSkipVerify: opt.skip_verify=1; break;
2817
2818           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2819           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2820
2821           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2822
2823 #ifndef NO_TRUST_MODELS
2824             /* There are many programs (like mutt) that call gpg with
2825                --always-trust so keep this option around for a long
2826                time. */
2827           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2828           case oTrustModel:
2829             parse_trust_model(pargs.r.ret_str);
2830             break;
2831 #endif /*!NO_TRUST_MODELS*/
2832           case oTOFUDefaultPolicy:
2833             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2834             break;
2835           case oTOFUDBFormat:
2836             obsolete_option (configname, configlineno, "tofu-db-format");
2837             break;
2838
2839           case oForceOwnertrust:
2840             log_info(_("Note: %s is not for normal use!\n"),
2841                      "--force-ownertrust");
2842             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2843             if(opt.force_ownertrust==-1)
2844               {
2845                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2846                 opt.force_ownertrust=0;
2847               }
2848             break;
2849           case oLoadExtension:
2850             /* Dummy so that gpg 1.4 conf files can work. Should
2851                eventually be removed.  */
2852             break;
2853
2854           case oCompliance:
2855             set_compliance_option (parse_compliance_option (pargs.r.ret_str));
2856             break;
2857           case oOpenPGP:
2858           case oRFC2440:
2859           case oRFC4880:
2860           case oRFC4880bis:
2861           case oPGP6:
2862           case oPGP7:
2863           case oPGP8:
2864           case oGnuPG:
2865             set_compliance_option (pargs.r_opt);
2866             break;
2867
2868           case oRFC2440Text: opt.rfc2440_text=1; break;
2869           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2870
2871           case oSetFilename:
2872             if(utf8_strings)
2873               opt.set_filename = pargs.r.ret_str;
2874             else
2875               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2876             break;
2877           case oForYourEyesOnly: eyes_only = 1; break;
2878           case oNoForYourEyesOnly: eyes_only = 0; break;
2879           case oSetPolicyURL:
2880             add_policy_url(pargs.r.ret_str,0);
2881             add_policy_url(pargs.r.ret_str,1);
2882             break;
2883           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2884           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2885           case oShowPolicyURL:
2886             deprecated_warning(configname,configlineno,"--show-policy-url",
2887                                "--list-options ","show-policy-urls");
2888             deprecated_warning(configname,configlineno,"--show-policy-url",
2889                                "--verify-options ","show-policy-urls");
2890             opt.list_options|=LIST_SHOW_POLICY_URLS;
2891             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2892             break;
2893           case oNoShowPolicyURL:
2894             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2895                                "--list-options ","no-show-policy-urls");
2896             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2897                                "--verify-options ","no-show-policy-urls");
2898             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2899             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2900             break;
2901           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2902           case oUseEmbeddedFilename:
2903             opt.flags.use_embedded_filename=1;
2904             break;
2905           case oNoUseEmbeddedFilename:
2906             opt.flags.use_embedded_filename=0;
2907             break;
2908           case oComment:
2909             if(pargs.r.ret_str[0])
2910               append_to_strlist(&opt.comments,pargs.r.ret_str);
2911             break;
2912           case oDefaultComment:
2913             deprecated_warning(configname,configlineno,
2914                                "--default-comment","--no-comments","");
2915             /* fall through */
2916           case oNoComments:
2917             free_strlist(opt.comments);
2918             opt.comments=NULL;
2919             break;
2920           case oThrowKeyids: opt.throw_keyids = 1; break;
2921           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2922           case oShowPhotos:
2923             deprecated_warning(configname,configlineno,"--show-photos",
2924                                "--list-options ","show-photos");
2925             deprecated_warning(configname,configlineno,"--show-photos",
2926                                "--verify-options ","show-photos");
2927             opt.list_options|=LIST_SHOW_PHOTOS;
2928             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2929             break;
2930           case oNoShowPhotos:
2931             deprecated_warning(configname,configlineno,"--no-show-photos",
2932                                "--list-options ","no-show-photos");
2933             deprecated_warning(configname,configlineno,"--no-show-photos",
2934                                "--verify-options ","no-show-photos");
2935             opt.list_options&=~LIST_SHOW_PHOTOS;
2936             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2937             break;
2938           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2939
2940           case oForceMDC: opt.force_mdc = 1; break;
2941           case oNoForceMDC: opt.force_mdc = 0; break;
2942           case oDisableMDC: opt.disable_mdc = 1; break;
2943           case oNoDisableMDC: opt.disable_mdc = 0; break;
2944
2945           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2946
2947           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2948           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2949           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2950           case oS2KCount:
2951             if (pargs.r.ret_int)
2952               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2953             else
2954               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2955             break;
2956
2957           case oRecipient:
2958           case oHiddenRecipient:
2959           case oRecipientFile:
2960           case oHiddenRecipientFile:
2961             /* Store the recipient.  Note that we also store the
2962              * option as private data in the flags.  This is achieved
2963              * by shifting the option value to the left so to keep
2964              * enough space for the flags.  */
2965             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2966             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2967             if (configfp)
2968               sl->flags |= PK_LIST_CONFIG;
2969             if (pargs.r_opt == oHiddenRecipient
2970                 || pargs.r_opt == oHiddenRecipientFile)
2971               sl->flags |= PK_LIST_HIDDEN;
2972             if (pargs.r_opt == oRecipientFile
2973                 || pargs.r_opt == oHiddenRecipientFile)
2974               sl->flags |= PK_LIST_FROM_FILE;
2975             any_explicit_recipient = 1;
2976             break;
2977
2978           case oEncryptTo:
2979           case oHiddenEncryptTo:
2980             /* Store an additional recipient.  */
2981             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2982             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
2983             if (configfp)
2984               sl->flags |= PK_LIST_CONFIG;
2985             if (pargs.r_opt == oHiddenEncryptTo)
2986               sl->flags |= PK_LIST_HIDDEN;
2987             break;
2988
2989           case oNoEncryptTo:
2990             opt.no_encrypt_to = 1;
2991             break;
2992           case oEncryptToDefaultKey:
2993             opt.encrypt_to_default_key = configfp ? 2 : 1;
2994             break;
2995
2996           case oTrySecretKey:
2997             add_to_strlist2 (&opt.secret_keys_to_try,
2998                              pargs.r.ret_str, utf8_strings);
2999             break;
3000
3001           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3002           case oTextmodeShort: opt.textmode = 2; break;
3003           case oTextmode: opt.textmode=1;  break;
3004           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3005
3006           case oExpert: opt.expert = 1; break;
3007           case oNoExpert: opt.expert = 0; break;
3008           case oDefSigExpire:
3009             if(*pargs.r.ret_str!='\0')
3010               {
3011                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3012                   log_error(_("'%s' is not a valid signature expiration\n"),
3013                             pargs.r.ret_str);
3014                 else
3015                   opt.def_sig_expire=pargs.r.ret_str;
3016               }
3017             break;
3018           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3019           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3020           case oDefCertExpire:
3021             if(*pargs.r.ret_str!='\0')
3022               {
3023                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3024                   log_error(_("'%s' is not a valid signature expiration\n"),
3025                             pargs.r.ret_str);
3026                 else
3027                   opt.def_cert_expire=pargs.r.ret_str;
3028               }
3029             break;
3030           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3031           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3032           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3033           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3034           case oAskCertLevel: opt.ask_cert_level = 1; break;
3035           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3036           case oLocalUser: /* store the local users */
3037             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3038             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3039             if (configfp)
3040               sl->flags |= PK_LIST_CONFIG;
3041             break;
3042           case oSender:
3043             {
3044               char *mbox = mailbox_from_userid (pargs.r.ret_str);
3045               if (!mbox)
3046                 log_error (_("\"%s\" is not a proper mail address\n"),
3047                            pargs.r.ret_str);
3048               else
3049                 {
3050                   add_to_strlist (&opt.sender_list, mbox);
3051                   xfree (mbox);
3052                 }
3053             }
3054             break;
3055           case oCompress:
3056             /* this is the -z command line option */
3057             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3058             break;
3059           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3060           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3061           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3062           case oPassphrase:
3063             set_passphrase_from_string(pargs.r.ret_str);
3064             break;
3065           case oPassphraseFD:
3066             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3067             break;
3068           case oPassphraseFile:
3069             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3070             break;
3071           case oPassphraseRepeat:
3072             opt.passphrase_repeat = pargs.r.ret_int;
3073             break;
3074
3075           case oPinentryMode:
3076             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3077             if (opt.pinentry_mode == -1)
3078               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3079             break;
3080
3081           case oCommandFD:
3082             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3083             if (! gnupg_fd_valid (opt.command_fd))
3084               log_fatal ("command-fd is invalid: %s\n", strerror (errno));
3085             break;
3086           case oCommandFile:
3087             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3088             break;
3089           case oCipherAlgo:
3090             def_cipher_string = xstrdup(pargs.r.ret_str);
3091             break;
3092           case oDigestAlgo:
3093             def_digest_string = xstrdup(pargs.r.ret_str);
3094             break;
3095           case oCompressAlgo:
3096             /* If it is all digits, stick a Z in front of it for
3097                later.  This is for backwards compatibility with
3098                versions that took the compress algorithm number. */
3099             {
3100               char *pt=pargs.r.ret_str;
3101               while(*pt)
3102                 {
3103                   if (!isascii (*pt) || !isdigit (*pt))
3104                     break;
3105
3106                   pt++;
3107                 }
3108
3109               if(*pt=='\0')
3110                 {
3111                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3112                   strcpy(compress_algo_string,"Z");
3113                   strcat(compress_algo_string,pargs.r.ret_str);
3114                 }
3115               else
3116                 compress_algo_string = xstrdup(pargs.r.ret_str);
3117             }
3118             break;
3119           case oCertDigestAlgo:
3120             cert_digest_string = xstrdup(pargs.r.ret_str);
3121             break;
3122
3123           case oNoSecmemWarn:
3124             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3125             break;
3126
3127           case oRequireSecmem: require_secmem=1; break;
3128           case oNoRequireSecmem: require_secmem=0; break;
3129           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3130           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3131           case oDisplayCharset:
3132             if( set_native_charset( pargs.r.ret_str ) )
3133                 log_error(_("'%s' is not a valid character set\n"),
3134                           pargs.r.ret_str);
3135             break;
3136           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3137           case oEscapeFrom: opt.escape_from = 1; break;
3138           case oNoEscapeFrom: opt.escape_from = 0; break;
3139           case oLockOnce: opt.lock_once = 1; break;
3140           case oLockNever:
3141             dotlock_disable ();
3142             break;
3143           case oLockMultiple:
3144 #ifndef __riscos__
3145             opt.lock_once = 0;
3146 #else /* __riscos__ */
3147             riscos_not_implemented("lock-multiple");
3148 #endif /* __riscos__ */
3149             break;
3150           case oKeyServer:
3151             {
3152               keyserver_spec_t keyserver;
3153               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3154               if (!keyserver)
3155                 log_error (_("could not parse keyserver URL\n"));
3156               else
3157                 {
3158                   /* We only support a single keyserver.  Later ones
3159                      override earlier ones.  (Since we parse the
3160                      config file first and then the command line
3161                      arguments, the command line takes
3162                      precedence.)  */
3163                   if (opt.keyserver)
3164                     free_keyserver_spec (opt.keyserver);
3165                   opt.keyserver = keyserver;
3166                 }
3167             }
3168             break;
3169           case oKeyServerOptions:
3170             if(!parse_keyserver_options(pargs.r.ret_str))
3171               {
3172                 if(configname)
3173                   log_error(_("%s:%d: invalid keyserver options\n"),
3174                             configname,configlineno);
3175                 else
3176                   log_error(_("invalid keyserver options\n"));
3177               }
3178             break;
3179           case oImportOptions:
3180             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3181               {
3182                 if(configname)
3183                   log_error(_("%s:%d: invalid import options\n"),
3184                             configname,configlineno);
3185                 else
3186                   log_error(_("invalid import options\n"));
3187               }
3188             break;
3189           case oImportFilter:
3190             rc = parse_and_set_import_filter (pargs.r.ret_str);
3191             if (rc)
3192               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3193             break;
3194           case oExportOptions:
3195             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3196               {
3197                 if(configname)
3198                   log_error(_("%s:%d: invalid export options\n"),
3199                             configname,configlineno);
3200                 else
3201                   log_error(_("invalid export options\n"));
3202               }
3203             break;
3204           case oExportFilter:
3205             rc = parse_and_set_export_filter (pargs.r.ret_str);
3206             if (rc)
3207               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3208             break;
3209           case oListOptions:
3210             if(!parse_list_options(pargs.r.ret_str))
3211               {
3212                 if(configname)
3213                   log_error(_("%s:%d: invalid list options\n"),
3214                             configname,configlineno);
3215                 else
3216                   log_error(_("invalid list options\n"));
3217               }
3218             break;
3219           case oVerifyOptions:
3220             {
3221               struct parse_options vopts[]=
3222                 {
3223                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3224                    N_("display photo IDs during signature verification")},
3225                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3226                    N_("show policy URLs during signature verification")},
3227                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3228                    N_("show all notations during signature verification")},
3229                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3230                    N_("show IETF standard notations during signature verification")},
3231                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3232                    NULL},
3233                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3234                    N_("show user-supplied notations during signature verification")},
3235                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3236                    N_("show preferred keyserver URLs during signature verification")},
3237                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3238                    N_("show user ID validity during signature verification")},
3239                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3240                    N_("show revoked and expired user IDs in signature verification")},
3241                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3242                    N_("show only the primary user ID in signature verification")},
3243                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3244                    N_("validate signatures with PKA data")},
3245                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3246                    N_("elevate the trust of signatures with valid PKA data")},
3247                   {NULL,0,NULL,NULL}
3248                 };
3249
3250               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3251                 {
3252                   if(configname)
3253                     log_error(_("%s:%d: invalid verify options\n"),
3254                               configname,configlineno);
3255                   else
3256                     log_error(_("invalid verify options\n"));
3257                 }
3258             }
3259             break;
3260           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3261           case oExecPath:
3262             if(set_exec_path(pargs.r.ret_str))
3263               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3264             else
3265               opt.exec_path_set=1;
3266             break;
3267           case oSetNotation:
3268             add_notation_data( pargs.r.ret_str, 0 );
3269             add_notation_data( pargs.r.ret_str, 1 );
3270             break;
3271           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3272           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3273           case oShowNotation:
3274             deprecated_warning(configname,configlineno,"--show-notation",
3275                                "--list-options ","show-notations");
3276             deprecated_warning(configname,configlineno,"--show-notation",
3277                                "--verify-options ","show-notations");
3278             opt.list_options|=LIST_SHOW_NOTATIONS;
3279             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3280             break;
3281           case oNoShowNotation:
3282             deprecated_warning(configname,configlineno,"--no-show-notation",
3283                                "--list-options ","no-show-notations");
3284             deprecated_warning(configname,configlineno,"--no-show-notation",
3285                                "--verify-options ","no-show-notations");
3286             opt.list_options&=~LIST_SHOW_NOTATIONS;
3287             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3288             break;
3289           case oUtf8Strings: utf8_strings = 1; break;
3290           case oNoUtf8Strings: utf8_strings = 0; break;
3291           case oDisableCipherAlgo:
3292             {
3293               int algo = string_to_cipher_algo (pargs.r.ret_str);
3294               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3295             }
3296             break;
3297           case oDisablePubkeyAlgo:
3298             {
3299               int algo = gcry_pk_map_name (pargs.r.ret_str);
3300               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3301             }
3302             break;
3303           case oNoSigCache: opt.no_sig_cache = 1; break;
3304           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3305           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3306           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3307           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3308           case oNoLiteral: opt.no_literal = 1; break;
3309           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3310           case oFastListMode: opt.fast_list_mode = 1; break;
3311           case oFixedListMode: /* Dummy */ break;
3312           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3313           case oPrintPKARecords: print_pka_records = 1; break;
3314           case oPrintDANERecords: print_dane_records = 1; break;
3315           case oListOnly: opt.list_only=1; break;
3316           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3317           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3318           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3319           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3320           case oNoRandomSeedFile: use_random_seed = 0; break;
3321           case oAutoKeyRetrieve:
3322           case oNoAutoKeyRetrieve:
3323                 if(pargs.r_opt==oAutoKeyRetrieve)
3324                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
3325                 else
3326                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
3327                 break;
3328           case oShowSessionKey: opt.show_session_key = 1; break;
3329           case oOverrideSessionKey:
3330                 opt.override_session_key = pargs.r.ret_str;
3331                 break;
3332           case oOverrideSessionKeyFD:
3333                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3334                 break;
3335           case oMergeOnly:
3336                 deprecated_warning(configname,configlineno,"--merge-only",
3337                                    "--import-options ","merge-only");
3338                 opt.import_options|=IMPORT_MERGE_ONLY;
3339             break;
3340           case oAllowSecretKeyImport: /* obsolete */ break;
3341           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3342           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3343
3344           case oEnableSpecialFilenames:
3345             enable_special_filenames ();
3346             break;
3347
3348           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3349           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3350           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3351           case oPreservePermissions: opt.preserve_permissions=1; break;
3352           case oDefaultPreferenceList:
3353             opt.def_preference_list = pargs.r.ret_str;
3354             break;
3355           case oDefaultKeyserverURL:
3356             {
3357               keyserver_spec_t keyserver;
3358               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3359               if (!keyserver)
3360                 log_error (_("could not parse keyserver URL\n"));
3361               else
3362                 free_keyserver_spec (keyserver);
3363
3364               opt.def_keyserver_url = pargs.r.ret_str;
3365             }
3366             break;
3367           case oPersonalCipherPreferences:
3368             pers_cipher_list=pargs.r.ret_str;
3369             break;
3370           case oPersonalDigestPreferences:
3371             pers_digest_list=pargs.r.ret_str;
3372             break;
3373           case oPersonalCompressPreferences:
3374             pers_compress_list=pargs.r.ret_str;
3375             break;
3376           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3377           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3378           case oWeakDigest:
3379             additional_weak_digest(pargs.r.ret_str);
3380             break;
3381           case oUnwrap:
3382             opt.unwrap_encryption = 1;
3383             break;
3384           case oOnlySignTextIDs:
3385             opt.only_sign_text_ids = 1;
3386             break;
3387
3388           case oDisplay:
3389             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3390             break;
3391           case oTTYname:
3392             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3393             break;
3394           case oTTYtype:
3395             set_opt_session_env ("TERM", pargs.r.ret_str);
3396             break;
3397           case oXauthority:
3398             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3399             break;
3400
3401           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3402           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3403
3404           case oGroup: add_group(pargs.r.ret_str); break;
3405           case oUnGroup: rm_group(pargs.r.ret_str); break;
3406           case oNoGroups:
3407             while(opt.grouplist)
3408               {
3409                 struct groupitem *iter=opt.grouplist;
3410                 free_strlist(iter->values);
3411                 opt.grouplist=opt.grouplist->next;
3412                 xfree(iter);
3413               }
3414             break;
3415
3416           case oStrict:
3417           case oNoStrict:
3418             /* Not used */
3419             break;
3420
3421           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3422           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3423           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3424           case oMultifile: multifile=1; break;
3425           case oKeyidFormat:
3426             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3427               opt.keyid_format=KF_SHORT;
3428             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3429               opt.keyid_format=KF_LONG;
3430             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3431               opt.keyid_format=KF_0xSHORT;
3432             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3433               opt.keyid_format=KF_0xLONG;
3434             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3435               opt.keyid_format = KF_NONE;
3436             else
3437               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3438             break;
3439
3440           case oExitOnStatusWriteError:
3441             opt.exit_on_status_write_error = 1;
3442             break;
3443
3444           case oLimitCardInsertTries:
3445             opt.limit_card_insert_tries = pargs.r.ret_int;
3446             break;
3447
3448           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3449           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3450
3451           case oAutoKeyLocate:
3452             if(!parse_auto_key_locate(pargs.r.ret_str))
3453               {
3454                 if(configname)
3455                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3456                             configname,configlineno);
3457                 else
3458                   log_error(_("invalid auto-key-locate list\n"));
3459               }
3460             break;
3461           case oNoAutoKeyLocate:
3462             release_akl();
3463             break;
3464
3465           case oEnableLargeRSA:
3466 #if SECMEM_BUFFER_SIZE >= 65536
3467             opt.flags.large_rsa=1;
3468 #else
3469             if (configname)
3470               log_info("%s:%d: WARNING: gpg not built with large secure "
3471                          "memory buffer.  Ignoring enable-large-rsa\n",
3472                         configname,configlineno);
3473             else
3474               log_info("WARNING: gpg not built with large secure "
3475                          "memory buffer.  Ignoring --enable-large-rsa\n");
3476 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3477             break;
3478           case oDisableLargeRSA: opt.flags.large_rsa=0;
3479             break;
3480
3481           case oEnableDSA2: opt.flags.dsa2=1; break;
3482           case oDisableDSA2: opt.flags.dsa2=0; break;
3483
3484           case oAllowMultisigVerification:
3485           case oAllowMultipleMessages:
3486             opt.flags.allow_multiple_messages=1;
3487             break;
3488
3489           case oNoAllowMultipleMessages:
3490             opt.flags.allow_multiple_messages=0;
3491             break;
3492
3493           case oAllowWeakDigestAlgos:
3494             opt.flags.allow_weak_digest_algos = 1;
3495             break;
3496
3497           case oFakedSystemTime:
3498             {
3499               size_t len = strlen (pargs.r.ret_str);
3500               int freeze = 0;
3501               time_t faked_time;
3502
3503               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3504                 {
3505                   freeze = 1;
3506                   pargs.r.ret_str[len-1] = '\0';
3507                 }
3508
3509               faked_time = isotime2epoch (pargs.r.ret_str);
3510               if (faked_time == (time_t)(-1))
3511                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3512               gnupg_set_time (faked_time, freeze);
3513             }
3514             break;
3515
3516           case oNoAutostart: opt.autostart = 0; break;
3517
3518           case oDefaultNewKeyAlgo:
3519             opt.def_new_key_algo = pargs.r.ret_str;
3520             break;
3521
3522           case oNoop: break;
3523
3524           default:
3525             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
3526             break;
3527           }
3528       }
3529
3530     if (configfp)
3531       {
3532         fclose( configfp );
3533         configfp = NULL;
3534         /* Remember the first config file name. */
3535         if (!save_configname)
3536           save_configname = configname;
3537         else
3538           xfree(configname);
3539         configname = NULL;
3540         goto next_pass;
3541       }
3542     xfree(configname); configname = NULL;
3543     if (log_get_errorcount (0))
3544       g10_exit(2);
3545
3546     /* The command --gpgconf-list is pretty simple and may be called
3547        directly after the option parsing. */
3548     if (cmd == aGPGConfList)
3549       {
3550         gpgconf_list (save_configname ? save_configname : default_configname);
3551         g10_exit (0);
3552       }
3553     xfree (save_configname);
3554     xfree (default_configname);
3555
3556     if (print_dane_records)
3557       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3558                  "--print-dane-records",
3559                  "--export-options export-dane");
3560     if (print_pka_records)
3561       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3562                  "--print-pks-records",
3563                  "--export-options export-pka");
3564     if (log_get_errorcount (0))
3565       g10_exit(2);
3566
3567
3568     if( nogreeting )
3569         greeting = 0;
3570
3571     if( greeting )
3572       {
3573         es_fprintf (es_stderr, "%s %s; %s\n",
3574                     strusage(11), strusage(13), strusage(14) );
3575         es_fprintf (es_stderr, "%s\n", strusage(15) );
3576       }
3577 #ifdef IS_DEVELOPMENT_VERSION
3578     if (!opt.batch)
3579       {
3580         const char *s;
3581
3582         if((s=strusage(25)))
3583           log_info("%s\n",s);
3584         if((s=strusage(26)))
3585           log_info("%s\n",s);
3586         if((s=strusage(27)))
3587           log_info("%s\n",s);
3588       }
3589 #endif
3590
3591     /* FIXME: We should use logging to a file only in server mode;
3592        however we have not yet implemetyed that.  Thus we try to get
3593        away with --batch as indication for logging to file
3594        required. */
3595     if (logfile && opt.batch)
3596       {
3597         log_set_file (logfile);
3598         log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
3599       }
3600
3601     if (opt.verbose > 2)
3602         log_info ("using character set '%s'\n", get_native_charset ());
3603
3604     if( may_coredump && !opt.quiet )
3605         log_info(_("WARNING: program may create a core file!\n"));
3606
3607     if (opt.flags.rfc4880bis)
3608         log_info ("WARNING: using experimental features from RFC4880bis!\n");
3609     else
3610       {
3611         opt.mimemode = 0; /* This will use text mode instead.  */
3612       }
3613
3614     if (eyes_only) {
3615       if (opt.set_filename)
3616           log_info(_("WARNING: %s overrides %s\n"),
3617                    "--for-your-eyes-only","--set-filename");
3618
3619       opt.set_filename="_CONSOLE";
3620     }
3621
3622     if (opt.no_literal) {
3623         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3624         if (opt.textmode)
3625             log_error(_("%s not allowed with %s!\n"),
3626                        "--textmode", "--no-literal" );
3627         if (opt.set_filename)
3628             log_error(_("%s makes no sense with %s!\n"),
3629                         eyes_only?"--for-your-eyes-only":"--set-filename",
3630                         "--no-literal" );
3631     }
3632
3633
3634     if (opt.set_filesize)
3635         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3636     if( opt.batch )
3637         tty_batchmode( 1 );
3638
3639     if (gnupg_faked_time_p ())
3640       {
3641         gnupg_isotime_t tbuf;
3642
3643         log_info (_("WARNING: running with faked system time: "));
3644         gnupg_get_isotime (tbuf);
3645         dump_isotime (tbuf);
3646         log_printf ("\n");
3647       }
3648
3649     /* Print a warning if an argument looks like an option.  */
3650     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3651       {
3652         int i;
3653
3654         for (i=0; i < argc; i++)
3655           if (argv[i][0] == '-' && argv[i][1] == '-')
3656             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3657       }
3658
3659
3660     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3661
3662     if(require_secmem && !got_secmem)
3663       {
3664         log_info(_("will not run with insecure memory due to %s\n"),
3665                  "--require-secmem");
3666         g10_exit(2);
3667       }
3668
3669     set_debug (debug_level);
3670     if (DBG_CLOCK)
3671       log_clock ("start");
3672
3673     /* Do these after the switch(), so they can override settings. */
3674     if(PGP6)
3675       {
3676         /* That does not anymore work because we have no more support
3677            for v3 signatures.  */
3678         opt.disable_mdc=1;
3679         opt.escape_from=1;
3680         opt.ask_sig_expire=0;
3681       }
3682     else if(PGP7)
3683       {
3684         /* That does not anymore work because we have no more support
3685            for v3 signatures.  */
3686         opt.escape_from=1;
3687         opt.ask_sig_expire=0;
3688       }
3689     else if(PGP8)
3690       {
3691         opt.escape_from=1;
3692       }
3693
3694
3695     if( def_cipher_string ) {
3696         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3697         xfree(def_cipher_string); def_cipher_string = NULL;
3698         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3699             log_error(_("selected cipher algorithm is invalid\n"));
3700     }
3701     if( def_digest_string ) {
3702         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3703         xfree(def_digest_string); def_digest_string = NULL;
3704         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3705             log_error(_("selected digest algorithm is invalid\n"));
3706     }
3707     if( compress_algo_string ) {
3708         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3709         xfree(compress_algo_string); compress_algo_string = NULL;
3710         if( check_compress_algo(opt.compress_algo) )
3711           log_error(_("selected compression algorithm is invalid\n"));
3712     }
3713     if( cert_digest_string ) {
3714         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3715         xfree(cert_digest_string); cert_digest_string = NULL;
3716         if (openpgp_md_test_algo(opt.cert_digest_algo))
3717           log_error(_("selected certification digest algorithm is invalid\n"));
3718     }
3719     if( s2k_cipher_string ) {
3720         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3721         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3722         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3723           log_error(_("selected cipher algorithm is invalid\n"));
3724     }
3725     if( s2k_digest_string ) {
3726         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3727         xfree(s2k_digest_string); s2k_digest_string = NULL;
3728         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3729           log_error(_("selected digest algorithm is invalid\n"));
3730     }
3731     if( opt.completes_needed < 1 )
3732       log_error(_("completes-needed must be greater than 0\n"));
3733     if( opt.marginals_needed < 2 )
3734       log_error(_("marginals-needed must be greater than 1\n"));
3735     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3736       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3737     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3738       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3739     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3740       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3741     switch( opt.s2k_mode ) {
3742       case 0:
3743         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3744         break;
3745       case 1: case 3: break;
3746       default:
3747         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3748     }
3749
3750     /* This isn't actually needed, but does serve to error out if the
3751        string is invalid. */
3752     if(opt.def_preference_list &&
3753         keygen_set_std_prefs(opt.def_preference_list,0))
3754       log_error(_("invalid default preferences\n"));
3755
3756     if(pers_cipher_list &&
3757        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3758       log_error(_("invalid personal cipher preferences\n"));
3759
3760     if(pers_digest_list &&
3761        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3762       log_error(_("invalid personal digest preferences\n"));
3763
3764     if(pers_compress_list &&
3765        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3766       log_error(_("invalid personal compress preferences\n"));
3767
3768     /* We don't support all possible commands with multifile yet */
3769     if(multifile)
3770       {
3771         char *cmdname;
3772
3773         switch(cmd)
3774           {
3775           case aSign:
3776             cmdname="--sign";
3777             break;
3778           case aSignEncr:
3779             cmdname="--sign --encrypt";
3780             break;
3781           case aClearsign:
3782             cmdname="--clear-sign";
3783             break;
3784           case aDetachedSign:
3785             cmdname="--detach-sign";
3786             break;
3787           case aSym:
3788             cmdname="--symmetric";
3789             break;
3790           case aEncrSym:
3791             cmdname="--symmetric --encrypt";
3792             break;
3793           case aStore:
3794             cmdname="--store";
3795             break;
3796           default:
3797             cmdname=NULL;
3798             break;
3799           }
3800
3801         if(cmdname)
3802           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3803       }
3804
3805     if( log_get_errorcount(0) )
3806         g10_exit(2);
3807
3808     if(opt.compress_level==0)
3809       opt.compress_algo=COMPRESS_ALGO_NONE;
3810
3811     /* Check our chosen algorithms against the list of legal
3812        algorithms. */
3813
3814     if(!GNUPG)
3815       {
3816         const char *badalg=NULL;
3817         preftype_t badtype=PREFTYPE_NONE;
3818
3819         if(opt.def_cipher_algo
3820            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3821           {
3822             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3823             badtype = PREFTYPE_SYM;
3824           }
3825         else if(opt.def_digest_algo
3826                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3827           {
3828             badalg = gcry_md_algo_name (opt.def_digest_algo);
3829             badtype = PREFTYPE_HASH;
3830           }
3831         else if(opt.cert_digest_algo
3832                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3833           {
3834             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3835             badtype = PREFTYPE_HASH;
3836           }
3837         else if(opt.compress_algo!=-1
3838                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3839           {
3840             badalg = compress_algo_to_string(opt.compress_algo);
3841             badtype = PREFTYPE_ZIP;
3842           }
3843
3844         if(badalg)
3845           {
3846             switch(badtype)
3847               {
3848               case PREFTYPE_SYM:
3849                 log_info(_("you may not use cipher algorithm '%s'"
3850                            " while in %s mode\n"),
3851                          badalg,compliance_option_string());
3852                 break;
3853               case PREFTYPE_HASH:
3854                 log_info(_("you may not use digest algorithm '%s'"
3855                            " while in %s mode\n"),
3856                          badalg,compliance_option_string());
3857                 break;
3858               case PREFTYPE_ZIP:
3859                 log_info(_("you may not use compression algorithm '%s'"
3860                            " while in %s mode\n"),
3861                          badalg,compliance_option_string());
3862                 break;
3863               default:
3864                 BUG();
3865               }
3866
3867             compliance_failure();
3868           }
3869       }
3870
3871     /* Set the random seed file. */
3872     if( use_random_seed ) {
3873       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
3874         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3875         if (!access (p, F_OK))
3876           register_secured_file (p);
3877         xfree(p);
3878     }
3879
3880     /* If there is no command but the --fingerprint is given, default
3881        to the --list-keys command.  */
3882     if (!cmd && fpr_maybe_cmd)
3883       {
3884         set_cmd (&cmd, aListKeys);
3885       }
3886
3887
3888     if( opt.verbose > 1 )
3889         set_packet_list_mode(1);
3890
3891     /* Add the keyrings, but not for some special commands.  We always
3892      * need to add the keyrings if we are running under SELinux, this
3893      * is so that the rings are added to the list of secured files.
3894      * We do not add any keyring if --no-keyring has been used.  */
3895     if (default_keyring >= 0
3896         && (ALWAYS_ADD_KEYRINGS
3897             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
3898       {
3899         if (!nrings || default_keyring > 0)  /* Add default ring. */
3900             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
3901                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3902         for (sl = nrings; sl; sl = sl->next )
3903           keydb_add_resource (sl->d, sl->flags);
3904       }
3905     FREE_STRLIST(nrings);
3906
3907     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
3908       /* In loopback mode, never ask for the password multiple
3909          times.  */
3910       {
3911         opt.passphrase_repeat = 0;
3912       }
3913
3914     if (cmd == aGPGConfTest)
3915       g10_exit(0);
3916
3917
3918     if (pwfd != -1)  /* Read the passphrase now. */
3919       read_passphrase_from_fd (pwfd);
3920
3921     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
3922       read_sessionkey_from_fd (ovrseskeyfd);
3923
3924     fname = argc? *argv : NULL;
3925
3926     if(fname && utf8_strings)
3927       opt.flags.utf8_filename=1;
3928
3929     ctrl = xcalloc (1, sizeof *ctrl);
3930     gpg_init_default_ctrl (ctrl);
3931
3932 #ifndef NO_TRUST_MODELS
3933     switch (cmd)
3934       {
3935       case aPrimegen:
3936       case aPrintMD:
3937       case aPrintMDs:
3938       case aGenRandom:
3939       case aDeArmor:
3940       case aEnArmor:
3941       case aListConfig:
3942       case aListGcryptConfig:
3943         break;
3944       case aFixTrustDB:
3945       case aExportOwnerTrust:
3946         rc = setup_trustdb (0, trustdb_name);
3947         break;
3948       case aListTrustDB:
3949         rc = setup_trustdb (argc? 1:0, trustdb_name);
3950         break;
3951       default:
3952         /* If we are using TM_ALWAYS, we do not need to create the
3953            trustdb.  */
3954         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3955         break;
3956       }
3957     if (rc)
3958       log_error (_("failed to initialize the TrustDB: %s\n"),
3959                  gpg_strerror (rc));
3960 #endif /*!NO_TRUST_MODELS*/
3961
3962     switch (cmd)
3963       {
3964       case aStore:
3965       case aSym:
3966       case aSign:
3967       case aSignSym:
3968       case aClearsign:
3969         if (!opt.quiet && any_explicit_recipient)
3970           log_info (_("WARNING: recipients (-r) given "
3971                       "without using public key encryption\n"));
3972         break;
3973       default:
3974         break;
3975       }
3976
3977
3978     /* Check for certain command whether we need to migrate a
3979        secring.gpg to the gpg-agent. */
3980     switch (cmd)
3981       {
3982       case aListSecretKeys:
3983       case aSign:
3984       case aSignEncr:
3985       case aSignEncrSym:
3986       case aSignSym:
3987       case aClearsign:
3988       case aDecrypt:
3989       case aSignKey:
3990       case aLSignKey:
3991       case aEditKey:
3992       case aPasswd:
3993       case aDeleteSecretKeys:
3994       case aDeleteSecretAndPublicKeys:
3995       case aQuickKeygen:
3996       case aQuickAddUid:
3997       case aQuickAddKey:
3998       case aQuickRevUid:
3999       case aFullKeygen:
4000       case aKeygen:
4001       case aImport:
4002       case aExportSecret:
4003       case aExportSecretSub:
4004       case aGenRevoke:
4005       case aDesigRevoke:
4006       case aCardEdit:
4007       case aChangePIN:
4008         migrate_secring (ctrl);
4009         break;
4010       case aListKeys:
4011         if (opt.with_secret)
4012           migrate_secring (ctrl);
4013         break;
4014       default:
4015         break;
4016       }
4017
4018     /* The command dispatcher.  */
4019     switch( cmd )
4020       {
4021       case aServer:
4022         gpg_server (ctrl);
4023         break;
4024
4025       case aStore: /* only store the file */
4026         if( argc > 1 )
4027             wrong_args("--store [filename]");
4028         if( (rc = encrypt_store(fname)) )
4029           {
4030             write_status_failure ("store", rc);
4031             log_error ("storing '%s' failed: %s\n",
4032                        print_fname_stdin(fname),gpg_strerror (rc) );
4033           }
4034         break;
4035       case aSym: /* encrypt the given file only with the symmetric cipher */
4036         if( argc > 1 )
4037             wrong_args("--symmetric [filename]");
4038         if( (rc = encrypt_symmetric(fname)) )
4039           {
4040             write_status_failure ("symencrypt", rc);
4041             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4042                         print_fname_stdin(fname),gpg_strerror (rc) );
4043           }
4044         break;
4045
4046       case aEncr: /* encrypt the given file */
4047         if(multifile)
4048           encrypt_crypt_files (ctrl, argc, argv, remusr);
4049         else
4050           {
4051             if( argc > 1 )
4052               wrong_args("--encrypt [filename]");
4053             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4054               {
4055                 write_status_failure ("encrypt", rc);
4056                 log_error("%s: encryption failed: %s\n",
4057                           print_fname_stdin(fname), gpg_strerror (rc) );
4058               }
4059           }
4060         break;
4061
4062       case aEncrSym:
4063         /* This works with PGP 8 in the sense that it acts just like a
4064            symmetric message.  It doesn't work at all with 2 or 6.  It
4065            might work with 7, but alas, I don't have a copy to test
4066            with right now. */
4067         if( argc > 1 )
4068           wrong_args("--symmetric --encrypt [filename]");
4069         else if(opt.s2k_mode==0)
4070           log_error(_("you cannot use --symmetric --encrypt"
4071                       " with --s2k-mode 0\n"));
4072         else if(PGP6 || PGP7)
4073           log_error(_("you cannot use --symmetric --encrypt"
4074                       " while in %s mode\n"),compliance_option_string());
4075         else
4076           {
4077             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4078               {
4079                 write_status_failure ("encrypt", rc);
4080                 log_error ("%s: encryption failed: %s\n",
4081                            print_fname_stdin(fname), gpg_strerror (rc) );
4082               }
4083           }
4084         break;
4085
4086       case aSign: /* sign the given file */
4087         sl = NULL;
4088         if( detached_sig ) { /* sign all files */
4089             for( ; argc; argc--, argv++ )
4090                 add_to_strlist( &sl, *argv );
4091         }
4092         else {
4093             if( argc > 1 )
4094                 wrong_args("--sign [filename]");
4095             if( argc ) {
4096                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4097                 strcpy(sl->d, fname);
4098             }
4099         }
4100         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)))
4101           {
4102             write_status_failure ("sign", rc);
4103             log_error ("signing failed: %s\n", gpg_strerror (rc) );
4104           }
4105         free_strlist(sl);
4106         break;
4107
4108       case aSignEncr: /* sign and encrypt the given file */
4109         if( argc > 1 )
4110             wrong_args("--sign --encrypt [filename]");
4111         if( argc ) {
4112             sl = xmalloc_clear( sizeof *sl + strlen(fname));
4113             strcpy(sl->d, fname);
4114         }
4115         else
4116             sl = NULL;
4117         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
4118           {
4119             write_status_failure ("sign-encrypt", rc);
4120             log_error("%s: sign+encrypt failed: %s\n",
4121                       print_fname_stdin(fname), gpg_strerror (rc) );
4122           }
4123         free_strlist(sl);
4124         break;
4125
4126       case aSignEncrSym: /* sign and encrypt the given file */
4127         if( argc > 1 )
4128             wrong_args("--symmetric --sign --encrypt [filename]");
4129         else if(opt.s2k_mode==0)
4130           log_error(_("you cannot use --symmetric --sign --encrypt"
4131                       " with --s2k-mode 0\n"));
4132         else if(PGP6 || PGP7)
4133           log_error(_("you cannot use --symmetric --sign --encrypt"
4134                       " while in %s mode\n"),compliance_option_string());
4135         else
4136           {
4137             if( argc )
4138               {
4139                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
4140                 strcpy(sl->d, fname);
4141               }
4142             else
4143               sl = NULL;
4144             if ((rc = sign_file (ctrl, sl, detached_sig, locusr,
4145                                  2, remusr, NULL)))
4146               {
4147                 write_status_failure ("sign-encrypt", rc);
4148                 log_error("%s: symmetric+sign+encrypt failed: %s\n",
4149                           print_fname_stdin(fname), gpg_strerror (rc) );
4150               }
4151             free_strlist(sl);
4152           }
4153         break;
4154
4155       case aSignSym: /* sign and conventionally encrypt the given file */
4156         if (argc > 1)
4157             wrong_args("--sign --symmetric [filename]");
4158         rc = sign_symencrypt_file (ctrl, fname, locusr);
4159         if (rc)
4160           {
4161             write_status_failure ("sign-symencrypt", rc);
4162             log_error("%s: sign+symmetric failed: %s\n",
4163                       print_fname_stdin(fname), gpg_strerror (rc) );
4164           }
4165         break;
4166
4167       case aClearsign: /* make a clearsig */
4168         if( argc > 1 )
4169             wrong_args("--clear-sign [filename]");
4170         if( (rc = clearsign_file (ctrl, fname, locusr, NULL)) )
4171           {
4172             write_status_failure ("sign", rc);
4173             log_error("%s: clear-sign failed: %s\n",
4174                       print_fname_stdin(fname), gpg_strerror (rc) );
4175           }
4176         break;
4177
4178       case aVerify:
4179         if (multifile)
4180           {
4181             if ((rc = verify_files (ctrl, argc, argv)))
4182               log_error("verify files failed: %s\n", gpg_strerror (rc) );
4183           }
4184         else
4185           {
4186             if ((rc = verify_signatures (ctrl, argc, argv)))
4187               log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
4188           }
4189         if (rc)
4190           write_status_failure ("verify", rc);
4191         break;
4192
4193       case aDecrypt:
4194         if (multifile)
4195           decrypt_messages (ctrl, argc, argv);
4196         else
4197           {
4198             if( argc > 1 )
4199               wrong_args("--decrypt [filename]");
4200             if( (rc = decrypt_message (ctrl, fname) ))
4201               {
4202                 write_status_failure ("decrypt", rc);
4203                 log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
4204               }
4205           }
4206         break;
4207
4208       case aQuickSignKey:
4209       case aQuickLSignKey:
4210         {
4211           const char *fpr;
4212
4213           if (argc < 1)
4214             wrong_args ("--quick-[l]sign-key fingerprint [userids]");
4215           fpr = *argv++; argc--;
4216           sl = NULL;
4217           for( ; argc; argc--, argv++)
4218             append_to_strlist2 (&sl, *argv, utf8_strings);
4219           keyedit_quick_sign (ctrl, fpr, sl, locusr, (cmd == aQuickLSignKey));
4220           free_strlist (sl);
4221         }
4222         break;
4223
4224       case aSignKey:
4225         if( argc != 1 )
4226           wrong_args("--sign-key user-id");
4227         /* fall through */
4228       case aLSignKey:
4229         if( argc != 1 )
4230           wrong_args("--lsign-key user-id");
4231         /* fall through */
4232
4233         sl=NULL;
4234
4235         if(cmd==aSignKey)
4236           append_to_strlist(&sl,"sign");
4237         else if(cmd==aLSignKey)
4238           append_to_strlist(&sl,"lsign");
4239         else
4240           BUG();
4241
4242         append_to_strlist( &sl, "save" );
4243         username = make_username( fname );
4244         keyedit_menu (ctrl, username, locusr, sl, 0, 0 );
4245         xfree(username);
4246         free_strlist(sl);
4247         break;
4248
4249       case aEditKey: /* Edit a key signature */
4250         if( !argc )
4251             wrong_args("--edit-key user-id [commands]");
4252         username = make_username( fname );
4253         if( argc > 1 ) {
4254             sl = NULL;
4255             for( argc--, argv++ ; argc; argc--, argv++ )
4256                 append_to_strlist( &sl, *argv );
4257             keyedit_menu (ctrl, username, locusr, sl, 0, 1 );
4258             free_strlist(sl);
4259         }
4260         else
4261             keyedit_menu (ctrl, username, locusr, NULL, 0, 1 );
4262         xfree(username);
4263         break;
4264
4265       case aPasswd:
4266         if (argc != 1)
4267           wrong_args("--change-passphrase <user-id>");
4268         else
4269           {
4270             username = make_username (fname);
4271             keyedit_passwd (ctrl, username);
4272             xfree (username);
4273           }
4274         break;
4275
4276       case aDeleteKeys:
4277       case aDeleteSecretKeys:
4278       case aDeleteSecretAndPublicKeys:
4279         sl = NULL;
4280         /* I'm adding these in reverse order as add_to_strlist2
4281            reverses them again, and it's easier to understand in the
4282            proper order :) */
4283         for( ; argc; argc-- )
4284           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
4285         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
4286         free_strlist(sl);
4287         break;
4288
4289       case aCheckKeys:
4290         opt.check_sigs = 1;
4291       case aListSigs:
4292         opt.list_sigs = 1;
4293       case aListKeys:
4294         sl = NULL;
4295         for( ; argc; argc--, argv++ )
4296             add_to_strlist2( &sl, *argv, utf8_strings );
4297         public_key_list (ctrl, sl, 0);
4298         free_strlist(sl);
4299         break;
4300       case aListSecretKeys:
4301         sl = NULL;
4302         for( ; argc; argc--, argv++ )
4303             add_to_strlist2( &sl, *argv, utf8_strings );
4304         secret_key_list (ctrl, sl);
4305         free_strlist(sl);
4306         break;
4307       case aLocateKeys:
4308         sl = NULL;
4309         for (; argc; argc--, argv++)
4310           add_to_strlist2( &sl, *argv, utf8_strings );
4311         public_key_list (ctrl, sl, 1);
4312         free_strlist (sl);
4313         break;
4314
4315       case aQuickKeygen:
4316         {
4317           const char *x_algo, *x_usage, *x_expire;
4318
4319           if (argc < 1 || argc > 4)
4320             wrong_args("--quick-generate-key USER-ID [ALGO [USAGE [EXPIRE]]]");
4321           username = make_username (fname);
4322           argv++, argc--;
4323           x_algo = "";
4324           x_usage = "";
4325           x_expire = "";
4326           if (argc)
4327             {
4328               x_algo = *argv++; argc--;
4329               if (argc)
4330                 {
4331                   x_usage = *argv++; argc--;
4332                   if (argc)
4333                     {
4334                       x_expire = *argv++; argc--;
4335                     }
4336                 }
4337             }
4338           quick_generate_keypair (ctrl, username, x_algo, x_usage, x_expire);
4339           xfree (username);
4340         }
4341         break;
4342
4343       case aKeygen: /* generate a key */
4344         if( opt.batch ) {
4345             if( argc > 1 )
4346                 wrong_args("--generate-key [parameterfile]");
4347             generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4348         }
4349         else {
4350             if (opt.command_fd != -1 && argc)
4351               {
4352                 if( argc > 1 )
4353                   wrong_args("--generate-key [parameterfile]");
4354
4355                 opt.batch = 1;
4356                 generate_keypair (ctrl, 0, argc? *argv : NULL, NULL, 0);
4357               }
4358             else if (argc)
4359               wrong_args ("--generate-key");
4360             else
4361               generate_keypair (ctrl, 0, NULL, NULL, 0);
4362         }
4363         break;
4364
4365       case aFullKeygen: /* Generate a key with all options. */
4366         if (opt.batch)
4367           {
4368             if (argc > 1)
4369               wrong_args ("--full-generate-key [parameterfile]");
4370             generate_keypair (ctrl, 1, argc? *argv : NULL, NULL, 0);
4371           }
4372         else
4373           {
4374             if (argc)
4375               wrong_args("--full-generate-key");
4376             generate_keypair (ctrl, 1, NULL, NULL, 0);
4377         }
4378         break;
4379
4380       case aQuickAddUid:
4381         {
4382           const char *uid, *newuid;
4383
4384           if (argc != 2)
4385             wrong_args ("--quick-add-uid USER-ID NEW-USER-ID");
4386           uid = *argv++; argc--;
4387           newuid = *argv++; argc--;
4388           keyedit_quick_adduid (ctrl, uid, newuid);
4389         }
4390         break;
4391
4392       case aQuickAddKey:
4393         {
4394           const char *x_fpr, *x_algo, *x_usage, *x_expire;
4395
4396           if (argc < 1 || argc > 4)
4397             wrong_args ("--quick-add-key FINGERPRINT [ALGO [USAGE [EXPIRE]]]");
4398           x_fpr = *argv++; argc--;
4399           x_algo = "";
4400           x_usage = "";
4401           x_expire = "";
4402           if (argc)
4403             {
4404               x_algo = *argv++; argc--;
4405               if (argc)
4406                 {
4407                   x_usage = *argv++; argc--;
4408                   if (argc)
4409                    {
4410                      x_expire = *argv++; argc--;
4411                    }
4412                 }
4413             }
4414           keyedit_quick_addkey (ctrl, x_fpr, x_algo, x_usage, x_expire);
4415         }
4416         break;
4417
4418       case aQuickRevUid:
4419         {
4420           const char *uid, *uidtorev;
4421
4422           if (argc != 2)
4423             wrong_args ("--quick-revoke-uid USER-ID USER-ID-TO-REVOKE");
4424           uid = *argv++; argc--;
4425           uidtorev = *argv++; argc--;
4426           keyedit_quick_revuid (ctrl, uid, uidtorev);
4427         }
4428         break;
4429
4430       case aQuickSetExpire:
4431         {
4432           const char *x_fpr, *x_expire;
4433
4434           if (argc != 2)
4435             wrong_args ("--quick-set-exipre FINGERPRINT EXPIRE");
4436           x_fpr = *argv++; argc--;
4437           x_expire = *argv++; argc--;
4438           keyedit_quick_set_expire (ctrl, x_fpr, x_expire);
4439         }
4440         break;
4441
4442       case aFastImport:
4443         opt.import_options |= IMPORT_FAST;
4444       case aImport:
4445         import_keys (ctrl, argc? argv:NULL, argc, NULL, opt.import_options);
4446         break;
4447
4448         /* TODO: There are a number of command that use this same
4449            "make strlist, call function, report error, free strlist"
4450            pattern.  Join them together here and avoid all that
4451            duplicated code. */
4452
4453       case aExport:
4454       case aSendKeys:
4455       case aRecvKeys:
4456         sl = NULL;
4457         for( ; argc; argc--, argv++ )
4458             append_to_strlist2( &sl, *argv, utf8_strings );
4459         if( cmd == aSendKeys )
4460             rc = keyserver_export (ctrl, sl );
4461         else if( cmd == aRecvKeys )
4462             rc = keyserver_import (ctrl, sl );
4463         else
4464           {
4465             export_stats_t stats = export_new_stats ();
4466             rc = export_pubkeys (ctrl, sl, opt.export_options, stats);
4467             export_print_stats (stats);
4468             export_release_stats (stats);
4469           }
4470         if(rc)
4471           {
4472             if(cmd==aSendKeys)
4473               {
4474                 write_status_failure ("send-keys", rc);
4475                 log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
4476               }
4477             else if(cmd==aRecvKeys)
4478               {
4479                 write_status_failure ("recv-keys", rc);
4480                 log_error (_("keyserver receive failed: %s\n"),
4481                            gpg_strerror (rc));
4482               }
4483             else
4484               {
4485                 write_status_failure ("export", rc);
4486                 log_error (_("key export failed: %s\n"), gpg_strerror (rc));
4487               }
4488           }
4489         free_strlist(sl);
4490         break;
4491
4492       case aExportSshKey:
4493         if (argc != 1)
4494           wrong_args ("--export-ssh-key <user-id>");
4495         rc = export_ssh_key (ctrl, argv[0]);
4496         if (rc)
4497           {
4498             write_status_failure ("export-ssh-key", rc);
4499             log_error (_("export as ssh key failed: %s\n"), gpg_strerror (rc));
4500           }
4501         break;
4502
4503      case aSearchKeys:
4504         sl = NULL;
4505         for (; argc; argc--, argv++)
4506           append_to_strlist2 (&sl, *argv, utf8_strings);
4507         rc = keyserver_search (ctrl, sl);
4508         if (rc)
4509           {
4510             write_status_failure ("search-keys", rc);
4511             log_error (_("keyserver search failed: %s\n"), gpg_strerror (rc));
4512           }
4513         free_strlist (sl);
4514         break;
4515
4516       case aRefreshKeys:
4517         sl = NULL;
4518         for( ; argc; argc--, argv++ )
4519             append_to_strlist2( &sl, *argv, utf8_strings );
4520         rc = keyserver_refresh (ctrl, sl);
4521         if(rc)
4522           {
4523             write_status_failure ("refresh-keys", rc);
4524             log_error (_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
4525           }
4526         free_strlist(sl);
4527         break;
4528
4529       case aFetchKeys:
4530         sl = NULL;
4531         for( ; argc; argc--, argv++ )
4532             append_to_strlist2( &sl, *argv, utf8_strings );
4533         rc = keyserver_fetch (ctrl, sl);
4534         if(rc)
4535           {
4536             write_status_failure ("fetch-keys", rc);
4537             log_error ("key fetch failed: %s\n",gpg_strerror (rc));
4538           }
4539         free_strlist(sl);
4540         break;
4541
4542       case aExportSecret:
4543         sl = NULL;
4544         for( ; argc; argc--, argv++ )
4545             add_to_strlist2( &sl, *argv, utf8_strings );
4546         {
4547           export_stats_t stats = export_new_stats ();
4548           export_seckeys (ctrl, sl, stats);
4549           export_print_stats (stats);
4550           export_release_stats (stats);
4551         }
4552         free_strlist(sl);
4553         break;
4554
4555       case aExportSecretSub:
4556         sl = NULL;
4557         for( ; argc; argc--, argv++ )
4558             add_to_strlist2( &sl, *argv, utf8_strings );
4559         {
4560           export_stats_t stats = export_new_stats ();
4561           export_secsubkeys (ctrl, sl, stats);
4562           export_print_stats (stats);
4563           export_release_stats (stats);
4564         }
4565         free_strlist(sl);
4566         break;
4567
4568       case aGenRevoke:
4569         if( argc != 1 )
4570             wrong_args("--generate-revocation user-id");
4571         username =  make_username(*argv);
4572         gen_revoke( username );
4573         xfree( username );
4574         break;
4575
4576       case aDesigRevoke:
4577         if (argc != 1)
4578             wrong_args ("--generate-designated-revocation user-id");
4579         username = make_username (*argv);
4580         gen_desig_revoke (ctrl, username, locusr);
4581         xfree (username);
4582         break;
4583
4584       case aDeArmor:
4585         if( argc > 1 )
4586             wrong_args("--dearmor [file]");
4587         rc = dearmor_file( argc? *argv: NULL );
4588         if( rc )
4589           {
4590             write_status_failure ("dearmor", rc);
4591             log_error (_("dearmoring failed: %s\n"), gpg_strerror (rc));
4592           }
4593         break;
4594
4595       case aEnArmor:
4596         if( argc > 1 )
4597             wrong_args("--enarmor [file]");
4598         rc = enarmor_file( argc? *argv: NULL );
4599         if( rc )
4600           {
4601             write_status_failure ("enarmor", rc);
4602             log_error (_("enarmoring failed: %s\n"), gpg_strerror (rc));
4603           }
4604         break;
4605
4606
4607       case aPrimegen:
4608 #if 0 /*FIXME*/
4609         {   int mode = argc < 2 ? 0 : atoi(*argv);
4610
4611             if( mode == 1 && argc == 2 ) {
4612                 mpi_print (es_stdout,
4613                            generate_public_prime( atoi(argv[1]) ), 1);
4614             }
4615             else if( mode == 2 && argc == 3 ) {
4616                 mpi_print (es_stdout, generate_elg_prime(
4617                                              0, atoi(argv[1]),
4618                                              atoi(argv[2]), NULL,NULL ), 1);
4619             }
4620             else if( mode == 3 && argc == 3 ) {
4621                 MPI *factors;
4622                 mpi_print (es_stdout, generate_elg_prime(
4623                                              1, atoi(argv[1]),
4624                                              atoi(argv[2]), NULL,&factors ), 1);
4625                 es_putc ('\n', es_stdout);
4626                 mpi_print (es_stdout, factors[0], 1 ); /* print q */
4627             }
4628             else if( mode == 4 && argc == 3 ) {
4629                 MPI g = mpi_alloc(1);
4630                 mpi_print (es_stdout, generate_elg_prime(
4631                                                  0, atoi(argv[1]),
4632                                                  atoi(argv[2]), g, NULL ), 1);
4633                 es_putc ('\n', es_stdout);
4634                 mpi_print (es_stdout, g, 1 );
4635                 mpi_free (g);
4636             }
4637             else
4638                 wrong_args("--gen-prime mode bits [qbits] ");
4639             es_putc ('\n', es_stdout);
4640         }
4641 #endif
4642         wrong_args("--gen-prime not yet supported ");
4643         break;
4644
4645       case aGenRandom:
4646         {
4647             int level = argc ? atoi(*argv):0;
4648             int count = argc > 1 ? atoi(argv[1]): 0;
4649             int endless = !count;
4650
4651             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
4652                 wrong_args("--gen-random 0|1|2 [count]");
4653
4654             while( endless || count ) {
4655                 byte *p;
4656                 /* Wee need a multiple of 3, so that in case of
4657                    armored output we get a correct string.  No
4658                    linefolding is done, as it is best to levae this to
4659                    other tools */
4660                 size_t n = !endless && count < 99? count : 99;
4661
4662                 p = gcry_random_bytes (n, level);
4663 #ifdef HAVE_DOSISH_SYSTEM
4664                 setmode ( fileno(stdout), O_BINARY );
4665 #endif
4666                 if (opt.armor) {
4667                     char *tmp = make_radix64_string (p, n);
4668                     es_fputs (tmp, es_stdout);
4669                     xfree (tmp);
4670                     if (n%3 == 1)
4671                       es_putc ('=', es_stdout);
4672                     if (n%3)
4673                       es_putc ('=', es_stdout);
4674                 } else {
4675                     es_fwrite( p, n, 1, es_stdout );
4676                 }
4677                 xfree(p);
4678                 if( !endless )
4679                     count -= n;
4680             }
4681             if (opt.armor)
4682               es_putc ('\n', es_stdout);
4683         }
4684         break;
4685
4686       case aPrintMD:
4687         if( argc < 1)
4688             wrong_args("--print-md algo [files]");
4689         {
4690             int all_algos = (**argv=='*' && !(*argv)[1]);
4691             int algo = all_algos? 0 : gcry_md_map_name (*argv);
4692
4693             if( !algo && !all_algos )
4694                 log_error(_("invalid hash algorithm '%s'\n"), *argv );
4695             else {
4696                 argc--; argv++;
4697                 if( !argc )
4698                     print_mds(NULL, algo);
4699                 else {
4700                     for(; argc; argc--, argv++ )
4701                         print_mds(*argv, algo);
4702                 }
4703             }
4704         }
4705         break;
4706
4707       case aPrintMDs: /* old option */
4708         if( !argc )
4709             print_mds(NULL,0);
4710         else {
4711             for(; argc; argc--, argv++ )
4712                 print_mds(*argv,0);
4713         }
4714         break;
4715
4716 #ifndef NO_TRUST_MODELS
4717       case aListTrustDB:
4718         if( !argc )
4719           list_trustdb (es_stdout, NULL);
4720         else {
4721             for( ; argc; argc--, argv++ )
4722               list_trustdb (es_stdout, *argv );
4723         }
4724         break;
4725
4726       case aUpdateTrustDB:
4727         if( argc )
4728             wrong_args("--update-trustdb");
4729         update_trustdb (ctrl);
4730         break;
4731
4732       case aCheckTrustDB:
4733         /* Old versions allowed for arguments - ignore them */
4734         check_trustdb (ctrl);
4735         break;
4736
4737       case aFixTrustDB:
4738         how_to_fix_the_trustdb ();
4739         break;
4740
4741       case aListTrustPath:
4742         if( !argc )
4743             wrong_args("--list-trust-path <user-ids>");
4744         for( ; argc; argc--, argv++ ) {
4745             username = make_username( *argv );
4746             list_trust_path( username );
4747             xfree(username);
4748         }
4749         break;
4750
4751       case aExportOwnerTrust:
4752         if( argc )
4753             wrong_args("--export-ownertrust");
4754         export_ownertrust();
4755         break;
4756
4757       case aImportOwnerTrust:
4758         if( argc > 1 )
4759             wrong_args("--import-ownertrust [file]");
4760         import_ownertrust( argc? *argv:NULL );
4761         break;
4762 #endif /*!NO_TRUST_MODELS*/
4763
4764       case aRebuildKeydbCaches:
4765         if (argc)
4766             wrong_args ("--rebuild-keydb-caches");
4767         keydb_rebuild_caches (1);
4768         break;
4769
4770 #ifdef ENABLE_CARD_SUPPORT
4771       case aCardStatus:
4772         if (argc)
4773             wrong_args ("--card-status");
4774         card_status (es_stdout, NULL, 0);
4775         break;
4776
4777       case aCardEdit:
4778         if (argc) {
4779             sl = NULL;
4780             for (argc--, argv++ ; argc; argc--, argv++)
4781                 append_to_strlist (&sl, *argv);
4782             card_edit (ctrl, sl);
4783             free_strlist (sl);
4784         }
4785         else
4786           card_edit (ctrl, NULL);
4787         break;
4788
4789       case aChangePIN:
4790         if (!argc)
4791             change_pin (0,1);
4792         else if (argc == 1)
4793             change_pin (atoi (*argv),1);
4794         else
4795             wrong_args ("--change-pin [no]");
4796         break;
4797 #endif /* ENABLE_CARD_SUPPORT*/
4798
4799       case aListConfig:
4800         {
4801           char *str=collapse_args(argc,argv);
4802           list_config(str);
4803           xfree(str);
4804         }
4805         break;
4806
4807       case aListGcryptConfig:
4808         /* Fixme: It would be nice to integrate that with
4809            --list-config but unfortunately there is no way yet to have
4810            libgcrypt print it to an estream for further parsing.  */
4811         gcry_control (GCRYCTL_PRINT_CONFIG, stdout);
4812         break;
4813
4814       case aTOFUPolicy:
4815 #ifdef USE_TOFU
4816         {
4817           int policy;
4818           int i;
4819           KEYDB_HANDLE hd;
4820
4821           if (argc < 2)
4822             wrong_args ("--tofu-policy POLICY KEYID [KEYID...]");
4823
4824           policy = parse_tofu_policy (argv[0]);
4825
4826           hd = keydb_new ();
4827           if (! hd)
4828             g10_exit (1);
4829
4830           tofu_begin_batch_update (ctrl);
4831
4832           for (i = 1; i < argc; i ++)
4833             {
4834               KEYDB_SEARCH_DESC desc;
4835               kbnode_t kb;
4836
4837               rc = classify_user_id (argv[i], &desc, 0);
4838               if (rc)
4839                 {
4840                   log_error (_("error parsing key specification '%s': %s\n"),
4841                              argv[i], gpg_strerror (rc));
4842                   g10_exit (1);
4843                 }
4844
4845               if (! (desc.mode == KEYDB_SEARCH_MODE_SHORT_KID
4846                      || desc.mode == KEYDB_SEARCH_MODE_LONG_KID
4847                      || desc.mode == KEYDB_SEARCH_MODE_FPR16
4848                      || desc.mode == KEYDB_SEARCH_MODE_FPR20
4849                      || desc.mode == KEYDB_SEARCH_MODE_FPR
4850                      || desc.mode == KEYDB_SEARCH_MODE_KEYGRIP))
4851                 {
4852                   log_error (_("'%s' does not appear to be a valid"
4853                                " key ID, fingerprint or keygrip\n"),
4854                              argv[i]);
4855                   g10_exit (1);
4856                 }
4857
4858               rc = keydb_search_reset (hd);
4859               if (rc)
4860                 {
4861                   /* This should not happen, thus no need to tranalate
4862                      the string.  */
4863                   log_error ("keydb_search_reset failed: %s\n",
4864                              gpg_strerror (rc));
4865                   g10_exit (1);
4866                 }
4867
4868               rc = keydb_search (hd, &desc, 1, NULL);
4869               if (rc)
4870                 {
4871                   log_error (_("key \"%s\" not found: %s\n"), argv[i],
4872                              gpg_strerror (rc));
4873                   g10_exit (1);
4874                 }
4875
4876               rc = keydb_get_keyblock (hd, &kb);
4877               if (rc)
4878                 {
4879                   log_error (_("error reading keyblock: %s\n"),
4880                              gpg_strerror (rc));
4881                   g10_exit (1);
4882                 }
4883
4884               merge_keys_and_selfsig (kb);
4885               if (tofu_set_policy (ctrl, kb, policy))
4886                 g10_exit (1);
4887
4888               release_kbnode (kb);
4889             }
4890
4891           tofu_end_batch_update (ctrl);
4892
4893           keydb_release (hd);
4894         }
4895 #endif /*USE_TOFU*/
4896         break;
4897
4898       default:
4899         if (!opt.quiet)
4900           log_info (_("WARNING: no command supplied."
4901                       "  Trying to guess what you mean ...\n"));
4902         /*FALLTHU*/
4903       case aListPackets:
4904         if( argc > 1 )
4905             wrong_args("[filename]");
4906         /* Issue some output for the unix newbie */
4907         if (!fname && !opt.outfile
4908             && gnupg_isatty (fileno (stdin))
4909             && gnupg_isatty (fileno (stdout))
4910             && gnupg_isatty (fileno (stderr)))
4911             log_info(_("Go ahead and type your message ...\n"));
4912
4913         a = iobuf_open(fname);
4914         if (a && is_secured_file (iobuf_get_fd (a)))
4915           {
4916             iobuf_close (a);
4917             a = NULL;
4918             gpg_err_set_errno (EPERM);
4919           }
4920         if( !a )
4921             log_error(_("can't open '%s'\n"), print_fname_stdin(fname));
4922         else {
4923
4924             if( !opt.no_armor ) {
4925                 if( use_armor_filter( a ) ) {
4926                     afx = new_armor_context ();
4927                     push_armor_filter (afx, a);
4928                 }
4929             }
4930             if( cmd == aListPackets ) {
4931                 opt.list_packets=1;
4932                 set_packet_list_mode(1);
4933             }
4934             rc = proc_packets (ctrl, NULL, a );
4935             if( rc )
4936               {
4937                 write_status_failure ("-", rc);
4938                 log_error ("processing message failed: %s\n",
4939                            gpg_strerror (rc));
4940               }
4941             iobuf_close(a);
4942         }
4943         break;
4944       }
4945
4946     /* cleanup */
4947     gpg_deinit_default_ctrl (ctrl);
4948     xfree (ctrl);
4949     release_armor_context (afx);
4950     FREE_STRLIST(remusr);
4951     FREE_STRLIST(locusr);
4952     g10_exit(0);
4953     return 8; /*NEVER REACHED*/
4954 }
4955
4956
4957 /* Note: This function is used by signal handlers!. */
4958 static void
4959 emergency_cleanup (void)
4960 {
4961   gcry_control (GCRYCTL_TERM_SECMEM );
4962 }
4963
4964
4965 void
4966 g10_exit( int rc )
4967 {
4968   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
4969   if (DBG_CLOCK)
4970     log_clock ("stop");
4971
4972   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
4973     {
4974       keydb_dump_stats ();
4975       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
4976       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
4977     }
4978   if (opt.debug)
4979     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
4980
4981   emergency_cleanup ();
4982
4983   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
4984   exit (rc);
4985 }
4986
4987
4988 /* Pretty-print hex hashes.  This assumes at least an 80-character
4989    display, but there are a few other similar assumptions in the
4990    display code. */
4991 static void
4992 print_hex (gcry_md_hd_t md, int algo, const char *fname)
4993 {
4994   int i,n,count,indent=0;
4995   const byte *p;
4996
4997   if (fname)
4998     indent = es_printf("%s: ",fname);
4999
5000   if (indent>40)
5001     {
5002       es_printf ("\n");
5003       indent=0;
5004     }
5005
5006   if (algo==DIGEST_ALGO_RMD160)
5007     indent += es_printf("RMD160 = ");
5008   else if (algo>0)
5009     indent += es_printf("%6s = ", gcry_md_algo_name (algo));
5010   else
5011     algo = abs(algo);
5012
5013   count = indent;
5014
5015   p = gcry_md_read (md, algo);
5016   n = gcry_md_get_algo_dlen (algo);
5017
5018   count += es_printf ("%02X",*p++);
5019
5020   for(i=1;i<n;i++,p++)
5021     {
5022       if(n==16)
5023         {
5024           if(count+2>79)
5025             {
5026               es_printf ("\n%*s",indent," ");
5027               count = indent;
5028             }
5029           else
5030             count += es_printf(" ");
5031
5032           if (!(i%8))
5033             count += es_printf(" ");
5034         }
5035       else if (n==20)
5036         {
5037           if(!(i%2))
5038             {
5039               if(count+4>79)
5040                 {
5041                   es_printf ("\n%*s",indent," ");
5042                   count=indent;
5043                 }
5044               else
5045                 count += es_printf(" ");
5046             }
5047
5048           if (!(i%10))
5049             count += es_printf(" ");
5050         }
5051       else
5052         {
5053           if(!(i%4))
5054             {
5055               if (count+8>79)
5056                 {
5057                   es_printf ("\n%*s",indent," ");
5058                   count=indent;
5059                 }
5060               else
5061                 count += es_printf(" ");
5062             }
5063         }
5064
5065       count += es_printf("%02X",*p);
5066     }
5067
5068   es_printf ("\n");
5069 }
5070
5071 static void
5072 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
5073 {
5074   int i, n;
5075   const byte *p;
5076
5077   if ( fname )
5078     {
5079       for (p = fname; *p; p++ )
5080         {
5081           if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
5082             es_printf ("%%%02X", *p );
5083           else
5084             es_putc (*p, es_stdout);
5085         }
5086     }
5087   es_putc (':', es_stdout);
5088   es_printf ("%d:", algo);
5089   p = gcry_md_read (md, algo);
5090   n = gcry_md_get_algo_dlen (algo);
5091   for(i=0; i < n ; i++, p++ )
5092     es_printf ("%02X", *p);
5093   es_fputs (":\n", es_stdout);
5094 }
5095
5096
5097 static void
5098 print_mds( const char *fname, int algo )
5099 {
5100   estream_t fp;
5101   char buf[1024];
5102   size_t n;
5103   gcry_md_hd_t md;
5104
5105   if (!fname)
5106     {
5107       fp = es_stdin;
5108       es_set_binary (fp);
5109     }
5110   else
5111     {
5112       fp = es_fopen (fname, "rb" );
5113       if (fp && is_secured_file (es_fileno (fp)))
5114         {
5115           es_fclose (fp);
5116           fp = NULL;
5117           gpg_err_set_errno (EPERM);
5118         }
5119     }
5120   if (!fp)
5121     {
5122       log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
5123       return;
5124     }
5125
5126   gcry_md_open (&md, 0, 0);
5127   if (algo)
5128     gcry_md_enable (md, algo);
5129   else
5130     {
5131       if (!gcry_md_test_algo (GCRY_MD_MD5))
5132         gcry_md_enable (md, GCRY_MD_MD5);
5133       gcry_md_enable (md, GCRY_MD_SHA1);
5134       if (!gcry_md_test_algo (GCRY_MD_RMD160))
5135         gcry_md_enable (md, GCRY_MD_RMD160);
5136       if (!gcry_md_test_algo (GCRY_MD_SHA224))
5137         gcry_md_enable (md, GCRY_MD_SHA224);
5138       if (!gcry_md_test_algo (GCRY_MD_SHA256))
5139         gcry_md_enable (md, GCRY_MD_SHA256);
5140       if (!gcry_md_test_algo (GCRY_MD_SHA384))
5141         gcry_md_enable (md, GCRY_MD_SHA384);
5142       if (!gcry_md_test_algo (GCRY_MD_SHA512))
5143         gcry_md_enable (md, GCRY_MD_SHA512);
5144     }
5145
5146   while ((n=es_fread (buf, 1, DIM(buf), fp)))
5147     gcry_md_write (md, buf, n);
5148
5149   if (es_ferror(fp))
5150     log_error ("%s: %s\n", fname?fname:"[stdin]", strerror(errno));
5151   else
5152     {
5153       gcry_md_final (md);
5154       if (opt.with_colons)
5155         {
5156           if ( algo )
5157             print_hashline (md, algo, fname);
5158           else
5159             {
5160               if (!gcry_md_test_algo (GCRY_MD_MD5))
5161                 print_hashline( md, GCRY_MD_MD5, fname );
5162               print_hashline( md, GCRY_MD_SHA1, fname );
5163               if (!gcry_md_test_algo (GCRY_MD_RMD160))
5164                 print_hashline( md, GCRY_MD_RMD160, fname );
5165               if (!gcry_md_test_algo (GCRY_MD_SHA224))
5166                 print_hashline (md, GCRY_MD_SHA224, fname);
5167               if (!gcry_md_test_algo (GCRY_MD_SHA256))
5168                 print_hashline( md, GCRY_MD_SHA256, fname );
5169               if (!gcry_md_test_algo (GCRY_MD_SHA384))
5170                 print_hashline ( md, GCRY_MD_SHA384, fname );
5171               if (!gcry_md_test_algo (GCRY_MD_SHA512))
5172                 print_hashline ( md, GCRY_MD_SHA512, fname );
5173             }
5174         }
5175       else
5176         {
5177           if (algo)
5178             print_hex (md, -algo, fname);
5179           else
5180             {
5181               if (!gcry_md_test_algo (GCRY_MD_MD5))
5182                 print_hex (md, GCRY_MD_MD5, fname);
5183               print_hex (md, GCRY_MD_SHA1, fname );
5184               if (!gcry_md_test_algo (GCRY_MD_RMD160))
5185                 print_hex (md, GCRY_MD_RMD160, fname );
5186               if (!gcry_md_test_algo (GCRY_MD_SHA224))
5187                 print_hex (md, GCRY_MD_SHA224, fname);
5188               if (!gcry_md_test_algo (GCRY_MD_SHA256))
5189                 print_hex (md, GCRY_MD_SHA256, fname );
5190               if (!gcry_md_test_algo (GCRY_MD_SHA384))
5191                 print_hex (md, GCRY_MD_SHA384, fname );
5192               if (!gcry_md_test_algo (GCRY_MD_SHA512))
5193                 print_hex (md, GCRY_MD_SHA512, fname );
5194             }
5195         }
5196     }
5197   gcry_md_close (md);
5198
5199   if (fp != es_stdin)
5200     es_fclose (fp);
5201 }
5202
5203
5204 /****************
5205  * Check the supplied name,value string and add it to the notation
5206  * data to be used for signatures.  which==0 for sig notations, and 1
5207  * for cert notations.
5208 */
5209 static void
5210 add_notation_data( const char *string, int which )
5211 {
5212   struct notation *notation;
5213
5214   notation=string_to_notation(string,utf8_strings);
5215   if(notation)
5216     {
5217       if(which)
5218         {
5219           notation->next=opt.cert_notations;
5220           opt.cert_notations=notation;
5221         }
5222       else
5223         {
5224           notation->next=opt.sig_notations;
5225           opt.sig_notations=notation;
5226         }
5227     }
5228 }
5229
5230 static void
5231 add_policy_url( const char *string, int which )
5232 {
5233   unsigned int i,critical=0;
5234   strlist_t sl;
5235
5236   if(*string=='!')
5237     {
5238       string++;
5239       critical=1;
5240     }
5241
5242   for(i=0;i<strlen(string);i++)
5243     if( !isascii (string[i]) || iscntrl(string[i]))
5244       break;
5245
5246   if(i==0 || i<strlen(string))
5247     {
5248       if(which)
5249         log_error(_("the given certification policy URL is invalid\n"));
5250       else
5251         log_error(_("the given signature policy URL is invalid\n"));
5252     }
5253
5254   if(which)
5255     sl=add_to_strlist( &opt.cert_policy_url, string );
5256   else
5257     sl=add_to_strlist( &opt.sig_policy_url, string );
5258
5259   if(critical)
5260     sl->flags |= 1;
5261 }
5262
5263 static void
5264 add_keyserver_url( const char *string, int which )
5265 {
5266   unsigned int i,critical=0;
5267   strlist_t sl;
5268
5269   if(*string=='!')
5270     {
5271       string++;
5272       critical=1;
5273     }
5274
5275   for(i=0;i<strlen(string);i++)
5276     if( !isascii (string[i]) || iscntrl(string[i]))
5277       break;
5278
5279   if(i==0 || i<strlen(string))
5280     {
5281       if(which)
5282         BUG();
5283       else
5284         log_error(_("the given preferred keyserver URL is invalid\n"));
5285     }
5286
5287   if(which)
5288     BUG();
5289   else
5290     sl=add_to_strlist( &opt.sig_keyserver_url, string );
5291
5292   if(critical)
5293     sl->flags |= 1;
5294 }
5295
5296
5297 static void
5298 read_sessionkey_from_fd (int fd)
5299 {
5300   int i, len;
5301   char *line;
5302
5303   if (! gnupg_fd_valid (fd))
5304     log_fatal ("override-session-key-fd is invalid: %s\n", strerror (errno));
5305
5306   for (line = NULL, i = len = 100; ; i++ )
5307     {
5308       if (i >= len-1 )
5309         {
5310           char *tmp = line;
5311           len += 100;
5312           line = xmalloc_secure (len);
5313           if (tmp)
5314             {
5315               memcpy (line, tmp, i);
5316               xfree (tmp);
5317             }
5318           else
5319             i=0;
5320         }
5321       if (read (fd, line + i, 1) != 1 || line[i] == '\n')
5322         break;
5323     }
5324   line[i] = 0;
5325   log_debug ("seskey: %s\n", line);
5326   gpgrt_annotate_leaked_object (line);
5327   opt.override_session_key = line;
5328 }