gpg: Relax printing of STATUS_FAILURE.
[gnupg.git] / 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-2017 Werner Koch
4  * Copyright (C) 2015-2017 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 "../common/util.h"
45 #include "packet.h"
46 #include "../common/membuf.h"
47 #include "main.h"
48 #include "options.h"
49 #include "keydb.h"
50 #include "trustdb.h"
51 #include "filter.h"
52 #include "../common/ttyio.h"
53 #include "../common/i18n.h"
54 #include "../common/sysutils.h"
55 #include "../common/status.h"
56 #include "keyserver-internal.h"
57 #include "exec.h"
58 #include "../common/gc-opt-flags.h"
59 #include "../common/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 #include "../common/compliance.h"
66
67 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
68 #define MY_O_BINARY  O_BINARY
69 #ifndef S_IRGRP
70 # define S_IRGRP 0
71 # define S_IWGRP 0
72 #endif
73 #else
74 #define MY_O_BINARY  0
75 #endif
76
77 #ifdef __MINGW32__
78 int _dowildcard = -1;
79 #endif
80
81 enum cmd_and_opt_values
82   {
83     aNull = 0,
84     oArmor        = 'a',
85     aDetachedSign = 'b',
86     aSym          = 'c',
87     aDecrypt      = 'd',
88     aEncr         = 'e',
89     oRecipientFile       = 'f',
90     oHiddenRecipientFile = 'F',
91     oInteractive  = 'i',
92     aListKeys     = 'k',
93     oDryRun       = 'n',
94     oOutput       = 'o',
95     oQuiet        = 'q',
96     oRecipient    = 'r',
97     oHiddenRecipient = 'R',
98     aSign         = 's',
99     oTextmodeShort= 't',
100     oLocalUser    = 'u',
101     oVerbose      = 'v',
102     oCompress     = 'z',
103     oSetNotation  = 'N',
104     aListSecretKeys = 'K',
105     oBatch        = 500,
106     oMaxOutput,
107     oInputSizeHint,
108     oSigNotation,
109     oCertNotation,
110     oShowNotation,
111     oNoShowNotation,
112     aEncrFiles,
113     aEncrSym,
114     aDecryptFiles,
115     aClearsign,
116     aStore,
117     aQuickKeygen,
118     aFullKeygen,
119     aKeygen,
120     aSignEncr,
121     aSignEncrSym,
122     aSignSym,
123     aSignKey,
124     aLSignKey,
125     aQuickSignKey,
126     aQuickLSignKey,
127     aQuickAddUid,
128     aQuickAddKey,
129     aQuickRevUid,
130     aQuickSetExpire,
131     aQuickSetPrimaryUid,
132     aListConfig,
133     aListGcryptConfig,
134     aGPGConfList,
135     aGPGConfTest,
136     aListPackets,
137     aEditKey,
138     aDeleteKeys,
139     aDeleteSecretKeys,
140     aDeleteSecretAndPublicKeys,
141     aImport,
142     aFastImport,
143     aVerify,
144     aVerifyFiles,
145     aListSigs,
146     aSendKeys,
147     aRecvKeys,
148     aLocateKeys,
149     aSearchKeys,
150     aRefreshKeys,
151     aFetchKeys,
152     aExport,
153     aExportSecret,
154     aExportSecretSub,
155     aExportSshKey,
156     aCheckKeys,
157     aGenRevoke,
158     aDesigRevoke,
159     aPrimegen,
160     aPrintMD,
161     aPrintMDs,
162     aCheckTrustDB,
163     aUpdateTrustDB,
164     aFixTrustDB,
165     aListTrustDB,
166     aListTrustPath,
167     aExportOwnerTrust,
168     aImportOwnerTrust,
169     aDeArmor,
170     aEnArmor,
171     aGenRandom,
172     aRebuildKeydbCaches,
173     aCardStatus,
174     aCardEdit,
175     aChangePIN,
176     aPasswd,
177     aServer,
178     aTOFUPolicy,
179
180     oMimemode,
181     oTextmode,
182     oNoTextmode,
183     oExpert,
184     oNoExpert,
185     oDefSigExpire,
186     oAskSigExpire,
187     oNoAskSigExpire,
188     oDefCertExpire,
189     oAskCertExpire,
190     oNoAskCertExpire,
191     oDefCertLevel,
192     oMinCertLevel,
193     oAskCertLevel,
194     oNoAskCertLevel,
195     oFingerprint,
196     oWithFingerprint,
197     oWithSubkeyFingerprint,
198     oWithICAOSpelling,
199     oWithKeygrip,
200     oWithSecret,
201     oWithWKDHash,
202     oWithColons,
203     oWithKeyData,
204     oWithKeyOrigin,
205     oWithTofuInfo,
206     oWithSigList,
207     oWithSigCheck,
208     oAnswerYes,
209     oAnswerNo,
210     oKeyring,
211     oPrimaryKeyring,
212     oSecretKeyring,
213     oShowKeyring,
214     oDefaultKey,
215     oDefRecipient,
216     oDefRecipientSelf,
217     oNoDefRecipient,
218     oTrySecretKey,
219     oOptions,
220     oDebug,
221     oDebugLevel,
222     oDebugAll,
223     oDebugIOLBF,
224     oStatusFD,
225     oStatusFile,
226     oAttributeFD,
227     oAttributeFile,
228     oEmitVersion,
229     oNoEmitVersion,
230     oCompletesNeeded,
231     oMarginalsNeeded,
232     oMaxCertDepth,
233     oLoadExtension,
234     oCompliance,
235     oGnuPG,
236     oRFC2440,
237     oRFC4880,
238     oRFC4880bis,
239     oOpenPGP,
240     oPGP6,
241     oPGP7,
242     oPGP8,
243     oDE_VS,
244     oRFC2440Text,
245     oNoRFC2440Text,
246     oCipherAlgo,
247     oDigestAlgo,
248     oCertDigestAlgo,
249     oCompressAlgo,
250     oCompressLevel,
251     oBZ2CompressLevel,
252     oBZ2DecompressLowmem,
253     oPassphrase,
254     oPassphraseFD,
255     oPassphraseFile,
256     oPassphraseRepeat,
257     oPinentryMode,
258     oCommandFD,
259     oCommandFile,
260     oQuickRandom,
261     oNoVerbose,
262     oTrustDBName,
263     oNoSecmemWarn,
264     oRequireSecmem,
265     oNoRequireSecmem,
266     oNoPermissionWarn,
267     oNoMDCWarn,
268     oNoArmor,
269     oNoDefKeyring,
270     oNoKeyring,
271     oNoGreeting,
272     oNoTTY,
273     oNoOptions,
274     oNoBatch,
275     oHomedir,
276     oSkipVerify,
277     oSkipHiddenRecipients,
278     oNoSkipHiddenRecipients,
279     oAlwaysTrust,
280     oTrustModel,
281     oForceOwnertrust,
282     oSetFilename,
283     oForYourEyesOnly,
284     oNoForYourEyesOnly,
285     oSetPolicyURL,
286     oSigPolicyURL,
287     oCertPolicyURL,
288     oShowPolicyURL,
289     oNoShowPolicyURL,
290     oSigKeyserverURL,
291     oUseEmbeddedFilename,
292     oNoUseEmbeddedFilename,
293     oComment,
294     oDefaultComment,
295     oNoComments,
296     oThrowKeyids,
297     oNoThrowKeyids,
298     oShowPhotos,
299     oNoShowPhotos,
300     oPhotoViewer,
301     oForceMDC,
302     oNoForceMDC,
303     oDisableMDC,
304     oNoDisableMDC,
305     oS2KMode,
306     oS2KDigest,
307     oS2KCipher,
308     oS2KCount,
309     oDisplayCharset,
310     oNotDashEscaped,
311     oEscapeFrom,
312     oNoEscapeFrom,
313     oLockOnce,
314     oLockMultiple,
315     oLockNever,
316     oKeyServer,
317     oKeyServerOptions,
318     oImportOptions,
319     oImportFilter,
320     oExportOptions,
321     oExportFilter,
322     oListOptions,
323     oVerifyOptions,
324     oTempDir,
325     oExecPath,
326     oEncryptTo,
327     oHiddenEncryptTo,
328     oNoEncryptTo,
329     oEncryptToDefaultKey,
330     oLoggerFD,
331     oLoggerFile,
332     oUtf8Strings,
333     oNoUtf8Strings,
334     oDisableCipherAlgo,
335     oDisablePubkeyAlgo,
336     oAllowNonSelfsignedUID,
337     oNoAllowNonSelfsignedUID,
338     oAllowFreeformUID,
339     oNoAllowFreeformUID,
340     oAllowSecretKeyImport,
341     oEnableSpecialFilenames,
342     oNoLiteral,
343     oSetFilesize,
344     oHonorHttpProxy,
345     oFastListMode,
346     oListOnly,
347     oIgnoreTimeConflict,
348     oIgnoreValidFrom,
349     oIgnoreCrcError,
350     oIgnoreMDCError,
351     oShowSessionKey,
352     oOverrideSessionKey,
353     oOverrideSessionKeyFD,
354     oNoRandomSeedFile,
355     oAutoKeyRetrieve,
356     oNoAutoKeyRetrieve,
357     oUseAgent,
358     oNoUseAgent,
359     oGpgAgentInfo,
360     oMergeOnly,
361     oTryAllSecrets,
362     oTrustedKey,
363     oNoExpensiveTrustChecks,
364     oFixedListMode,
365     oLegacyListMode,
366     oNoSigCache,
367     oAutoCheckTrustDB,
368     oNoAutoCheckTrustDB,
369     oPreservePermissions,
370     oDefaultPreferenceList,
371     oDefaultKeyserverURL,
372     oPersonalCipherPreferences,
373     oPersonalDigestPreferences,
374     oPersonalCompressPreferences,
375     oAgentProgram,
376     oDirmngrProgram,
377     oDisableDirmngr,
378     oDisplay,
379     oTTYname,
380     oTTYtype,
381     oLCctype,
382     oLCmessages,
383     oXauthority,
384     oGroup,
385     oUnGroup,
386     oNoGroups,
387     oStrict,
388     oNoStrict,
389     oMangleDosFilenames,
390     oNoMangleDosFilenames,
391     oEnableProgressFilter,
392     oMultifile,
393     oKeyidFormat,
394     oExitOnStatusWriteError,
395     oLimitCardInsertTries,
396     oReaderPort,
397     octapiDriver,
398     opcscDriver,
399     oDisableCCID,
400     oRequireCrossCert,
401     oNoRequireCrossCert,
402     oAutoKeyLocate,
403     oNoAutoKeyLocate,
404     oAllowMultisigVerification,
405     oEnableLargeRSA,
406     oDisableLargeRSA,
407     oEnableDSA2,
408     oDisableDSA2,
409     oAllowMultipleMessages,
410     oNoAllowMultipleMessages,
411     oAllowWeakDigestAlgos,
412     oFakedSystemTime,
413     oNoAutostart,
414     oPrintPKARecords,
415     oPrintDANERecords,
416     oTOFUDefaultPolicy,
417     oTOFUDBFormat,
418     oDefaultNewKeyAlgo,
419     oWeakDigest,
420     oUnwrap,
421     oOnlySignTextIDs,
422     oDisableSignerUID,
423     oSender,
424     oKeyOrigin,
425     oRequestOrigin,
426     oNoSymkeyCache,
427
428     oNoop
429   };
430
431
432 static ARGPARSE_OPTS opts[] = {
433
434   ARGPARSE_group (300, N_("@Commands:\n ")),
435
436   ARGPARSE_c (aSign, "sign", N_("make a signature")),
437   ARGPARSE_c (aClearsign, "clear-sign", N_("make a clear text signature")),
438   ARGPARSE_c (aClearsign, "clearsign", "@"),
439   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
440   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
441   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
442   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
443   ARGPARSE_c (aStore, "store",     "@"),
444   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
445   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
446   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
447   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
448   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
449   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
450   ARGPARSE_c (aListSigs, "list-signatures", N_("list keys and signatures")),
451   ARGPARSE_c (aListSigs, "list-sigs", "@"),
452   ARGPARSE_c (aCheckKeys, "check-signatures",
453               N_("list and check key signatures")),
454   ARGPARSE_c (aCheckKeys, "check-sigs", "@"),
455   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
456   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
457   ARGPARSE_c (aKeygen,      "generate-key",
458               N_("generate a new key pair")),
459   ARGPARSE_c (aKeygen,      "gen-key", "@"),
460   ARGPARSE_c (aQuickKeygen, "quick-generate-key" ,
461               N_("quickly generate a new key pair")),
462   ARGPARSE_c (aQuickKeygen, "quick-gen-key", "@"),
463   ARGPARSE_c (aQuickAddUid,  "quick-add-uid",
464               N_("quickly add a new user-id")),
465   ARGPARSE_c (aQuickAddUid,  "quick-adduid", "@"),
466   ARGPARSE_c (aQuickAddKey,  "quick-add-key", "@"),
467   ARGPARSE_c (aQuickAddKey,  "quick-addkey", "@"),
468   ARGPARSE_c (aQuickRevUid,  "quick-revoke-uid",
469               N_("quickly revoke a user-id")),
470   ARGPARSE_c (aQuickRevUid,  "quick-revuid", "@"),
471   ARGPARSE_c (aQuickSetExpire,  "quick-set-expire",
472               N_("quickly set a new expiration date")),
473   ARGPARSE_c (aQuickSetPrimaryUid,  "quick-set-primary-uid", "@"),
474   ARGPARSE_c (aFullKeygen,  "full-generate-key" ,
475               N_("full featured key pair generation")),
476   ARGPARSE_c (aFullKeygen,  "full-gen-key", "@"),
477   ARGPARSE_c (aGenRevoke, "generate-revocation",
478               N_("generate a revocation certificate")),
479   ARGPARSE_c (aGenRevoke, "gen-revoke", "@"),
480   ARGPARSE_c (aDeleteKeys,"delete-keys",
481               N_("remove keys from the public keyring")),
482   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
483               N_("remove keys from the secret keyring")),
484   ARGPARSE_c (aQuickSignKey,  "quick-sign-key" ,
485               N_("quickly sign a key")),
486   ARGPARSE_c (aQuickLSignKey, "quick-lsign-key",
487               N_("quickly sign a key locally")),
488   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
489   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
490   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
491   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
492   ARGPARSE_c (aPasswd,   "change-passphrase", N_("change a passphrase")),
493   ARGPARSE_c (aPasswd,   "passwd", "@"),
494   ARGPARSE_c (aDesigRevoke, "generate-designated-revocation", "@"),
495   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
496   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
497   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a keyserver") ),
498   ARGPARSE_c (aRecvKeys, "receive-keys" , N_("import keys from a keyserver") ),
499   ARGPARSE_c (aRecvKeys, "recv-keys"     , "@"),
500   ARGPARSE_c (aSearchKeys, "search-keys" ,
501               N_("search for keys on a keyserver") ),
502   ARGPARSE_c (aRefreshKeys, "refresh-keys",
503               N_("update all keys from a keyserver")),
504   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
505   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
506   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
507   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
508   ARGPARSE_c (aExportSshKey, "export-ssh-key", "@" ),
509   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
510   ARGPARSE_c (aFastImport, "fast-import", "@"),
511 #ifdef ENABLE_CARD_SUPPORT
512   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
513   ARGPARSE_c (aCardEdit,   "edit-card",  N_("change data on a card")),
514   ARGPARSE_c (aCardEdit,   "card-edit", "@"),
515   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
516 #endif
517   ARGPARSE_c (aListConfig, "list-config", "@"),
518   ARGPARSE_c (aListGcryptConfig, "list-gcrypt-config", "@"),
519   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
520   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
521   ARGPARSE_c (aListPackets, "list-packets","@"),
522
523 #ifndef NO_TRUST_MODELS
524   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
525   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
526   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
527               N_("update the trust database")),
528   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
529   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
530 #endif
531
532   ARGPARSE_c (aDeArmor, "dearmor", "@"),
533   ARGPARSE_c (aDeArmor, "dearmour", "@"),
534   ARGPARSE_c (aEnArmor, "enarmor", "@"),
535   ARGPARSE_c (aEnArmor, "enarmour", "@"),
536   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
537   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
538   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
539   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
540   ARGPARSE_c (aTOFUPolicy, "tofu-policy",
541               N_("|VALUE|set the TOFU policy for a key")),
542
543   ARGPARSE_group (301, N_("@\nOptions:\n ")),
544
545   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
546   ARGPARSE_s_n (oArmor, "armour", "@"),
547
548   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
549   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
550   ARGPARSE_s_s (oRecipientFile, "recipient-file", "@"),
551   ARGPARSE_s_s (oHiddenRecipientFile, "hidden-recipient-file", "@"),
552   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
553   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
554   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
555   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
556
557   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
558   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
559   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
560   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
561   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
562   ARGPARSE_s_n (oEncryptToDefaultKey, "encrypt-to-default-key", "@"),
563   ARGPARSE_s_s (oLocalUser, "local-user",
564                 N_("|USER-ID|use USER-ID to sign or decrypt")),
565   ARGPARSE_s_s (oSender, "sender", "@"),
566
567   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
568
569   ARGPARSE_s_i (oCompress, NULL,
570                 N_("|N|set compress level to N (0 disables)")),
571   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
572   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
573   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
574
575   ARGPARSE_s_n (oMimemode, "mimemode", "@"),
576   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
577   ARGPARSE_s_n (oTextmode,   "textmode", N_("use canonical text mode")),
578   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
579
580   ARGPARSE_s_n (oExpert,      "expert", "@"),
581   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
582
583   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
584   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
585   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
586   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
587   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
588   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
589   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
590   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
591   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
592   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
593
594   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
595   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
596   ARGPARSE_s_s (oInputSizeHint, "input-size-hint", "@"),
597
598   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
599   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
600   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
601
602   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
603   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
604   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
605   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
606
607   ARGPARSE_s_n (oDisableSignerUID, "disable-signer-uid", "@"),
608
609   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
610   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
611
612   ARGPARSE_s_n (oBatch, "batch", "@"),
613   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
614   ARGPARSE_s_n (oAnswerNo, "no", "@"),
615   ARGPARSE_s_s (oKeyring, "keyring", "@"),
616   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
617   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
618   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
619   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
620
621   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
622   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
623   ARGPARSE_s_s (oKeyOrigin, "key-origin", "@"),
624   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
625   ARGPARSE_s_s (oImportFilter,  "import-filter", "@"),
626   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
627   ARGPARSE_s_s (oExportFilter,  "export-filter", "@"),
628   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
629   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
630
631   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
632   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
633   ARGPARSE_s_s (oOptions, "options", "@"),
634
635   ARGPARSE_s_s (oDebug, "debug", "@"),
636   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
637   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
638   ARGPARSE_s_n (oDebugIOLBF, "debug-iolbf", "@"),
639   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
640   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
641   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
642   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
643
644   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
645   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
646   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
647   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
648
649   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
650
651   ARGPARSE_s_s (oCompliance, "compliance",   "@"),
652   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
653   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
654   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
655   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
656   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
657   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
658   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
659   ARGPARSE_s_n (oRFC4880bis, "rfc4880bis", "@"),
660   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
661   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
662   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
663   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
664
665   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
666   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
667   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
668   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
669   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
670   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
671   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
672   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
673   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
674   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
675   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
676   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
677   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
678   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
679   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
680   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
681   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
682   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
683   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
684
685   ARGPARSE_group (302, N_(
686   "@\n(See the man page for a complete listing of all commands and options)\n"
687                       )),
688
689   ARGPARSE_group (303, N_("@\nExamples:\n\n"
690     " -se -r Bob [file]          sign and encrypt for user Bob\n"
691     " --clear-sign [file]        make a clear text signature\n"
692     " --detach-sign [file]       make a detached signature\n"
693     " --list-keys [names]        show keys\n"
694     " --fingerprint [names]      show fingerprints\n")),
695
696   /* More hidden commands and options. */
697   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
698 #ifndef NO_TRUST_MODELS
699   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
700 #endif
701
702   /* Not yet used:
703      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
704   ARGPARSE_c (aDeleteSecretAndPublicKeys,
705               "delete-secret-and-public-keys", "@"),
706   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
707
708   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
709   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
710   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
711   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
712   ARGPARSE_s_s (oPinentryMode,    "pinentry-mode", "@"),
713   ARGPARSE_s_s (oRequestOrigin,   "request-origin", "@"),
714   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
715   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
716   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
717   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
718
719 #ifndef NO_TRUST_MODELS
720   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
721   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
722   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
723   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
724 #endif
725
726   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
727   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
728   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
729   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
730   ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
731   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
732   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
733   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
734   ARGPARSE_s_n (oNoKeyring, "no-keyring", "@"),
735   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
736   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
737   ARGPARSE_s_s (oHomedir, "homedir", "@"),
738   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
739   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
740   ARGPARSE_s_n (oWithTofuInfo,"with-tofu-info", "@"),
741   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
742   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
743   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
744   ARGPARSE_c (aListKeys, "list-key", "@"),   /* alias */
745   ARGPARSE_c (aListSigs, "list-sig", "@"),   /* alias */
746   ARGPARSE_c (aCheckKeys, "check-sig", "@"), /* alias */
747   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
748   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
749   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
750   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
751 #ifndef NO_TRUST_MODELS
752   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
753 #endif
754   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
755   ARGPARSE_s_s (oTOFUDefaultPolicy, "tofu-default-policy", "@"),
756   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
757   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
758   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
759   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
760   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
761   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
762   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
763   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
764   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
765   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
766   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
767   ARGPARSE_s_s (oComment, "comment", "@"),
768   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
769   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
770   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
771   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
772   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
773   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
774   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
775   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
776   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
777   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
778   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
779   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
780   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
781   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
782   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
783   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
784   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
785   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
786   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
787   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprint", "@"),
788   ARGPARSE_s_n (oWithSubkeyFingerprint, "with-subkey-fingerprints", "@"),
789   ARGPARSE_s_n (oWithICAOSpelling, "with-icao-spelling", "@"),
790   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
791   ARGPARSE_s_n (oWithSecret,      "with-secret", "@"),
792   ARGPARSE_s_n (oWithWKDHash,     "with-wkd-hash", "@"),
793   ARGPARSE_s_n (oWithKeyOrigin,   "with-key-origin", "@"),
794   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
795   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
796   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
797   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
798   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
799   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
800   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
801   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
802   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
803   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
804   ARGPARSE_s_n (oLegacyListMode, "legacy-list-mode", "@"),
805   ARGPARSE_s_n (oListOnly, "list-only", "@"),
806   ARGPARSE_s_n (oPrintPKARecords, "print-pka-records", "@"),
807   ARGPARSE_s_n (oPrintDANERecords, "print-dane-records", "@"),
808   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
809   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
810   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
811   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
812   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
813   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
814   ARGPARSE_s_i (oOverrideSessionKeyFD, "override-session-key-fd", "@"),
815   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
816   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
817   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
818   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
819   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
820   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
821   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
822   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
823   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
824   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
825   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
826   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
827   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
828   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
829   ARGPARSE_s_s (oPersonalCompressPreferences,
830                                          "personal-compress-preferences", "@"),
831   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
832   ARGPARSE_s_s (oWeakDigest, "weak-digest","@"),
833   ARGPARSE_s_n (oUnwrap, "unwrap", "@"),
834   ARGPARSE_s_n (oOnlySignTextIDs, "only-sign-text-ids", "@"),
835
836   /* Aliases.  I constantly mistype these, and assume other people do
837      as well. */
838   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
839   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
840   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
841
842   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
843   ARGPARSE_s_s (oDirmngrProgram, "dirmngr-program", "@"),
844   ARGPARSE_s_n (oDisableDirmngr, "disable-dirmngr", "@"),
845   ARGPARSE_s_s (oDisplay,    "display",    "@"),
846   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
847   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
848   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
849   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
850   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
851   ARGPARSE_s_s (oGroup,      "group",      "@"),
852   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
853   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
854   ARGPARSE_s_n (oStrict,     "strict",     "@"),
855   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
856   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
857   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
858   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
859   ARGPARSE_s_n (oMultifile, "multifile", "@"),
860   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
861   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
862   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
863
864   ARGPARSE_s_n (oAllowMultisigVerification,
865                 "allow-multisig-verification", "@"),
866   ARGPARSE_s_n (oEnableLargeRSA, "enable-large-rsa", "@"),
867   ARGPARSE_s_n (oDisableLargeRSA, "disable-large-rsa", "@"),
868   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
869   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
870   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
871   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
872   ARGPARSE_s_n (oAllowWeakDigestAlgos, "allow-weak-digest-algos", "@"),
873
874   ARGPARSE_s_s (oDefaultNewKeyAlgo, "default-new-key-algo", "@"),
875
876   /* These two are aliases to help users of the PGP command line
877      product use gpg with minimal pain.  Many commands are common
878      already as they seem to have borrowed commands from us.  Now I'm
879      returning the favor. */
880   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
881   ARGPARSE_s_s (oRecipient, "user", "@"),
882
883   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
884   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
885   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
886   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
887
888   /* New options.  Fixme: Should go more to the top.  */
889   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
890   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
891   ARGPARSE_s_n (oNoAutostart, "no-autostart", "@"),
892   ARGPARSE_s_n (oNoSymkeyCache, "no-symkey-cache", "@"),
893
894   /* Dummy options with warnings.  */
895   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
896   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
897   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
898   ARGPARSE_s_s (oReaderPort, "reader-port", "@"),
899   ARGPARSE_s_s (octapiDriver, "ctapi-driver", "@"),
900   ARGPARSE_s_s (opcscDriver, "pcsc-driver", "@"),
901   ARGPARSE_s_n (oDisableCCID, "disable-ccid", "@"),
902   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
903   ARGPARSE_s_s (oTOFUDBFormat, "tofu-db-format", "@"),
904
905   /* Dummy options.  */
906   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
907   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
908   ARGPARSE_s_n (oNoop, "compress-keys", "@"),
909   ARGPARSE_s_n (oNoop, "compress-sigs", "@"),
910   ARGPARSE_s_n (oNoop, "force-v3-sigs", "@"),
911   ARGPARSE_s_n (oNoop, "no-force-v3-sigs", "@"),
912   ARGPARSE_s_n (oNoop, "force-v4-certs", "@"),
913   ARGPARSE_s_n (oNoop, "no-force-v4-certs", "@"),
914
915   ARGPARSE_end ()
916 };
917
918
919 /* The list of supported debug flags.  */
920 static struct debug_flags_s debug_flags [] =
921   {
922     { DBG_PACKET_VALUE , "packet"  },
923     { DBG_MPI_VALUE    , "mpi"     },
924     { DBG_CRYPTO_VALUE , "crypto"  },
925     { DBG_FILTER_VALUE , "filter"  },
926     { DBG_IOBUF_VALUE  , "iobuf"   },
927     { DBG_MEMORY_VALUE , "memory"  },
928     { DBG_CACHE_VALUE  , "cache"   },
929     { DBG_MEMSTAT_VALUE, "memstat" },
930     { DBG_TRUST_VALUE  , "trust"   },
931     { DBG_HASHING_VALUE, "hashing" },
932     { DBG_IPC_VALUE    , "ipc"     },
933     { DBG_CLOCK_VALUE  , "clock"   },
934     { DBG_LOOKUP_VALUE , "lookup"  },
935     { DBG_EXTPROG_VALUE, "extprog" },
936     { 0, NULL }
937   };
938
939
940 #ifdef ENABLE_SELINUX_HACKS
941 #define ALWAYS_ADD_KEYRINGS 1
942 #else
943 #define ALWAYS_ADD_KEYRINGS 0
944 #endif
945
946
947 int g10_errors_seen = 0;
948
949 static int utf8_strings = 0;
950 static int maybe_setuid = 1;
951
952 static char *build_list( const char *text, char letter,
953                          const char *(*mapf)(int), int (*chkf)(int) );
954 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
955                         enum cmd_and_opt_values new_cmd );
956 static void print_mds( const char *fname, int algo );
957 static void add_notation_data( const char *string, int which );
958 static void add_policy_url( const char *string, int which );
959 static void add_keyserver_url( const char *string, int which );
960 static void emergency_cleanup (void);
961 static void read_sessionkey_from_fd (int fd);
962
963
964 static char *
965 make_libversion (const char *libname, const char *(*getfnc)(const char*))
966 {
967   const char *s;
968   char *result;
969
970   if (maybe_setuid)
971     {
972       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
973       maybe_setuid = 0;
974     }
975   s = getfnc (NULL);
976   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
977   strcpy (stpcpy (stpcpy (result, libname), " "), s);
978   return result;
979 }
980
981
982 static int
983 build_list_pk_test_algo (int algo)
984 {
985   /* Show only one "RSA" string.  If RSA_E or RSA_S is available RSA
986      is also available.  */
987   if (algo == PUBKEY_ALGO_RSA_E
988       || algo == PUBKEY_ALGO_RSA_S)
989     return GPG_ERR_DIGEST_ALGO;
990
991   return openpgp_pk_test_algo (algo);
992 }
993
994 static const char *
995 build_list_pk_algo_name (int algo)
996 {
997   return openpgp_pk_algo_name (algo);
998 }
999
1000 static int
1001 build_list_cipher_test_algo (int algo)
1002 {
1003   return openpgp_cipher_test_algo (algo);
1004 }
1005
1006 static const char *
1007 build_list_cipher_algo_name (int algo)
1008 {
1009   return openpgp_cipher_algo_name (algo);
1010 }
1011
1012 static int
1013 build_list_md_test_algo (int algo)
1014 {
1015   /* By default we do not accept MD5 based signatures.  To avoid
1016      confusion we do not announce support for it either.  */
1017   if (algo == DIGEST_ALGO_MD5)
1018     return GPG_ERR_DIGEST_ALGO;
1019
1020   return openpgp_md_test_algo (algo);
1021 }
1022
1023 static const char *
1024 build_list_md_algo_name (int algo)
1025 {
1026   return openpgp_md_algo_name (algo);
1027 }
1028
1029
1030 static const char *
1031 my_strusage( int level )
1032 {
1033   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
1034   const char *p;
1035
1036     switch( level ) {
1037       case 11: p = "@GPG@ (@GNUPG@)";
1038         break;
1039       case 13: p = VERSION; break;
1040       case 17: p = PRINTABLE_OS_NAME; break;
1041       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
1042
1043     case 20:
1044       if (!ver_gcry)
1045         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
1046       p = ver_gcry;
1047       break;
1048
1049 #ifdef IS_DEVELOPMENT_VERSION
1050       case 25:
1051         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
1052         break;
1053       case 26:
1054         p="It is only intended for test purposes and should NOT be";
1055         break;
1056       case 27:
1057         p="used in a production environment or with production keys!";
1058         break;
1059 #endif
1060
1061       case 1:
1062       case 40:  p =
1063             _("Usage: @GPG@ [options] [files] (-h for help)");
1064         break;
1065       case 41:  p =
1066             _("Syntax: @GPG@ [options] [files]\n"
1067               "Sign, check, encrypt or decrypt\n"
1068               "Default operation depends on the input data\n");
1069         break;
1070
1071       case 31: p = "\nHome: "; break;
1072 #ifndef __riscos__
1073       case 32: p = gnupg_homedir (); break;
1074 #else /* __riscos__ */
1075       case 32: p = make_filename(gnupg_homedir (), NULL); break;
1076 #endif /* __riscos__ */
1077       case 33: p = _("\nSupported algorithms:\n"); break;
1078       case 34:
1079         if (!pubkeys)
1080             pubkeys = build_list (_("Pubkey: "), 1,
1081                                   build_list_pk_algo_name,
1082                                   build_list_pk_test_algo );
1083         p = pubkeys;
1084         break;
1085       case 35:
1086         if( !ciphers )
1087             ciphers = build_list(_("Cipher: "), 'S',
1088                                  build_list_cipher_algo_name,
1089                                  build_list_cipher_test_algo );
1090         p = ciphers;
1091         break;
1092       case 36:
1093         if( !digests )
1094             digests = build_list(_("Hash: "), 'H',
1095                                  build_list_md_algo_name,
1096                                  build_list_md_test_algo );
1097         p = digests;
1098         break;
1099       case 37:
1100         if( !zips )
1101             zips = build_list(_("Compression: "),'Z',
1102                               compress_algo_to_string,
1103                               check_compress_algo);
1104         p = zips;
1105         break;
1106
1107       default:  p = NULL;
1108     }
1109     return p;
1110 }
1111
1112
1113 static char *
1114 build_list (const char *text, char letter,
1115             const char * (*mapf)(int), int (*chkf)(int))
1116 {
1117   membuf_t mb;
1118   int indent;
1119   int i, j, len;
1120   const char *s;
1121   char *string;
1122
1123   if (maybe_setuid)
1124     gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
1125
1126   indent = utf8_charcount (text, -1);
1127   len = 0;
1128   init_membuf (&mb, 512);
1129
1130   for (i=0; i <= 110; i++ )
1131     {
1132       if (!chkf (i) && (s = mapf (i)))
1133         {
1134           if (mb.len - len > 60)
1135             {
1136               put_membuf_str (&mb, ",\n");
1137               len = mb.len;
1138               for (j=0; j < indent; j++)
1139                 put_membuf_str (&mb, " ");
1140             }
1141           else if (mb.len)
1142             put_membuf_str (&mb, ", ");
1143           else
1144             put_membuf_str (&mb, text);
1145
1146           put_membuf_str (&mb, s);
1147           if (opt.verbose && letter)
1148             {
1149               char num[20];
1150               if (letter == 1)
1151                 snprintf (num, sizeof num, " (%d)", i);
1152               else
1153                 snprintf (num, sizeof num, " (%c%d)", letter, i);
1154               put_membuf_str (&mb, num);
1155             }
1156         }
1157     }
1158   if (mb.len)
1159     put_membuf_str (&mb, "\n");
1160   put_membuf (&mb, "", 1);
1161
1162   string = get_membuf (&mb, NULL);
1163   return xrealloc (string, strlen (string)+1);
1164 }
1165
1166
1167 static void
1168 wrong_args( const char *text)
1169 {
1170   es_fprintf (es_stderr, _("usage: %s [options] %s\n"), GPG_NAME, text);
1171   log_inc_errorcount ();
1172   g10_exit(2);
1173 }
1174
1175
1176 static char *
1177 make_username( const char *string )
1178 {
1179     char *p;
1180     if( utf8_strings )
1181         p = xstrdup(string);
1182     else
1183         p = native_to_utf8( string );
1184     return p;
1185 }
1186
1187
1188 static void
1189 set_opt_session_env (const char *name, const char *value)
1190 {
1191   gpg_error_t err;
1192
1193   err = session_env_setenv (opt.session_env, name, value);
1194   if (err)
1195     log_fatal ("error setting session environment: %s\n",
1196                gpg_strerror (err));
1197 }
1198
1199
1200 /* Setup the debugging.  With a LEVEL of NULL only the active debug
1201    flags are propagated to the subsystems.  With LEVEL set, a specific
1202    set of debug flags is set; thus overriding all flags already
1203    set. */
1204 static void
1205 set_debug (const char *level)
1206 {
1207   int numok = (level && digitp (level));
1208   int numlvl = numok? atoi (level) : 0;
1209
1210   if (!level)
1211     ;
1212   else if (!strcmp (level, "none") || (numok && numlvl < 1))
1213     opt.debug = 0;
1214   else if (!strcmp (level, "basic") || (numok && numlvl <= 2))
1215     opt.debug = DBG_MEMSTAT_VALUE;
1216   else if (!strcmp (level, "advanced") || (numok && numlvl <= 5))
1217     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
1218   else if (!strcmp (level, "expert")  || (numok && numlvl <= 8))
1219     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
1220                  |DBG_CACHE_VALUE|DBG_LOOKUP|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
1221   else if (!strcmp (level, "guru") || numok)
1222     {
1223       opt.debug = ~0;
1224       /* Unless the "guru" string has been used we don't want to allow
1225          hashing debugging.  The rationale is that people tend to
1226          select the highest debug value and would then clutter their
1227          disk with debug files which may reveal confidential data.  */
1228       if (numok)
1229         opt.debug &= ~(DBG_HASHING_VALUE);
1230     }
1231   else
1232     {
1233       log_error (_("invalid debug-level '%s' given\n"), level);
1234       g10_exit (2);
1235     }
1236
1237   if ((opt.debug & DBG_MEMORY_VALUE))
1238     memory_debug_mode = 1;
1239   if ((opt.debug & DBG_MEMSTAT_VALUE))
1240     memory_stat_debug_mode = 1;
1241   if (DBG_MPI)
1242     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
1243   if (DBG_CRYPTO)
1244     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
1245   if ((opt.debug & DBG_IOBUF_VALUE))
1246     iobuf_debug_mode = 1;
1247   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
1248
1249   if (opt.debug)
1250     parse_debug_flag (NULL, &opt.debug, debug_flags);
1251 }
1252
1253
1254 /* We set the screen dimensions for UI purposes.  Do not allow screens
1255    smaller than 80x24 for the sake of simplicity. */
1256 static void
1257 set_screen_dimensions(void)
1258 {
1259 #ifndef HAVE_W32_SYSTEM
1260   char *str;
1261
1262   str=getenv("COLUMNS");
1263   if(str)
1264     opt.screen_columns=atoi(str);
1265
1266   str=getenv("LINES");
1267   if(str)
1268     opt.screen_lines=atoi(str);
1269 #endif
1270
1271   if(opt.screen_columns<80 || opt.screen_columns>255)
1272     opt.screen_columns=80;
1273
1274   if(opt.screen_lines<24 || opt.screen_lines>255)
1275     opt.screen_lines=24;
1276 }
1277
1278
1279 /* Helper to open a file FNAME either for reading or writing to be
1280    used with --status-file etc functions.  Not generally useful but it
1281    avoids the riscos specific functions and well some Windows people
1282    might like it too.  Prints an error message and returns -1 on
1283    error.  On success the file descriptor is returned.  */
1284 static int
1285 open_info_file (const char *fname, int for_write, int binary)
1286 {
1287 #ifdef __riscos__
1288   return riscos_fdopenfile (fname, for_write);
1289 #elif defined (ENABLE_SELINUX_HACKS)
1290   /* We can't allow these even when testing for a secured filename
1291      because files to be secured might not yet been secured.  This is
1292      similar to the option file but in that case it is unlikely that
1293      sensitive information may be retrieved by means of error
1294      messages.  */
1295   (void)fname;
1296   (void)for_write;
1297   (void)binary;
1298   return -1;
1299 #else
1300   int fd;
1301
1302   if (binary)
1303     binary = MY_O_BINARY;
1304
1305 /*   if (is_secured_filename (fname)) */
1306 /*     { */
1307 /*       fd = -1; */
1308 /*       gpg_err_set_errno (EPERM); */
1309 /*     } */
1310 /*   else */
1311 /*     { */
1312       do
1313         {
1314           if (for_write)
1315             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY | binary,
1316                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1317           else
1318             fd = open (fname, O_RDONLY | binary);
1319         }
1320       while (fd == -1 && errno == EINTR);
1321 /*     } */
1322   if ( fd == -1)
1323     log_error ( for_write? _("can't create '%s': %s\n")
1324                          : _("can't open '%s': %s\n"), fname, strerror(errno));
1325
1326   return fd;
1327 #endif
1328 }
1329
1330 static void
1331 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1332 {
1333     enum cmd_and_opt_values cmd = *ret_cmd;
1334
1335     if( !cmd || cmd == new_cmd )
1336         cmd = new_cmd;
1337     else if( cmd == aSign && new_cmd == aEncr )
1338         cmd = aSignEncr;
1339     else if( cmd == aEncr && new_cmd == aSign )
1340         cmd = aSignEncr;
1341     else if( cmd == aSign && new_cmd == aSym )
1342         cmd = aSignSym;
1343     else if( cmd == aSym && new_cmd == aSign )
1344         cmd = aSignSym;
1345     else if( cmd == aSym && new_cmd == aEncr )
1346         cmd = aEncrSym;
1347     else if( cmd == aEncr && new_cmd == aSym )
1348         cmd = aEncrSym;
1349     else if (cmd == aSignEncr && new_cmd == aSym)
1350         cmd = aSignEncrSym;
1351     else if (cmd == aSignSym && new_cmd == aEncr)
1352         cmd = aSignEncrSym;
1353     else if (cmd == aEncrSym && new_cmd == aSign)
1354         cmd = aSignEncrSym;
1355     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1356              || ( cmd == aClearsign && new_cmd == aSign )  )
1357         cmd = aClearsign;
1358     else {
1359         log_error(_("conflicting commands\n"));
1360         g10_exit(2);
1361     }
1362
1363     *ret_cmd = cmd;
1364 }
1365
1366
1367 static void
1368 add_group(char *string)
1369 {
1370   char *name,*value;
1371   struct groupitem *item;
1372
1373   /* Break off the group name */
1374   name=strsep(&string,"=");
1375   if(string==NULL)
1376     {
1377       log_error(_("no = sign found in group definition '%s'\n"),name);
1378       return;
1379     }
1380
1381   trim_trailing_ws(name,strlen(name));
1382
1383   /* Does this group already exist? */
1384   for(item=opt.grouplist;item;item=item->next)
1385     if(strcasecmp(item->name,name)==0)
1386       break;
1387
1388   if(!item)
1389     {
1390       item=xmalloc(sizeof(struct groupitem));
1391       item->name=name;
1392       item->next=opt.grouplist;
1393       item->values=NULL;
1394       opt.grouplist=item;
1395     }
1396
1397   /* Break apart the values */
1398   while ((value= strsep(&string," \t")))
1399     {
1400       if (*value)
1401         add_to_strlist2(&item->values,value,utf8_strings);
1402     }
1403 }
1404
1405
1406 static void
1407 rm_group(char *name)
1408 {
1409   struct groupitem *item,*last=NULL;
1410
1411   trim_trailing_ws(name,strlen(name));
1412
1413   for(item=opt.grouplist;item;last=item,item=item->next)
1414     {
1415       if(strcasecmp(item->name,name)==0)
1416         {
1417           if(last)
1418             last->next=item->next;
1419           else
1420             opt.grouplist=item->next;
1421
1422           free_strlist(item->values);
1423           xfree(item);
1424           break;
1425         }
1426     }
1427 }
1428
1429
1430 /* We need to check three things.
1431
1432    0) The homedir.  It must be x00, a directory, and owned by the
1433    user.
1434
1435    1) The options/gpg.conf file.  Okay unless it or its containing
1436    directory is group or other writable or not owned by us.  Disable
1437    exec in this case.
1438
1439    2) Extensions.  Same as #1.
1440
1441    Returns true if the item is unsafe. */
1442 static int
1443 check_permissions (const char *path, int item)
1444 {
1445 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1446   static int homedir_cache=-1;
1447   char *tmppath,*dir;
1448   struct stat statbuf,dirbuf;
1449   int homedir=0,ret=0,checkonly=0;
1450   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1451
1452   if(opt.no_perm_warn)
1453     return 0;
1454
1455   log_assert(item==0 || item==1 || item==2);
1456
1457   /* extensions may attach a path */
1458   if(item==2 && path[0]!=DIRSEP_C)
1459     {
1460       if(strchr(path,DIRSEP_C))
1461         tmppath=make_filename(path,NULL);
1462       else
1463         tmppath=make_filename(gnupg_libdir (),path,NULL);
1464     }
1465   else
1466     tmppath=xstrdup(path);
1467
1468   /* If the item is located in the homedir, but isn't the homedir,
1469      don't continue if we already checked the homedir itself.  This is
1470      to avoid user confusion with an extra options file warning which
1471      could be rectified if the homedir itself had proper
1472      permissions. */
1473   if(item!=0 && homedir_cache>-1
1474      && !ascii_strncasecmp (gnupg_homedir (), tmppath,
1475                             strlen (gnupg_homedir ())))
1476     {
1477       ret=homedir_cache;
1478       goto end;
1479     }
1480
1481   /* It's okay if the file or directory doesn't exist */
1482   if(stat(tmppath,&statbuf)!=0)
1483     {
1484       ret=0;
1485       goto end;
1486     }
1487
1488   /* Now check the enclosing directory.  Theoretically, we could walk
1489      this test up to the root directory /, but for the sake of sanity,
1490      I'm stopping at one level down. */
1491   dir=make_dirname(tmppath);
1492
1493   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1494     {
1495       /* Weird error */
1496       ret=1;
1497       goto end;
1498     }
1499
1500   xfree(dir);
1501
1502   /* Assume failure */
1503   ret=1;
1504
1505   if(item==0)
1506     {
1507       /* The homedir must be x00, a directory, and owned by the user. */
1508
1509       if(S_ISDIR(statbuf.st_mode))
1510         {
1511           if(statbuf.st_uid==getuid())
1512             {
1513               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1514                 ret=0;
1515               else
1516                 perm=1;
1517             }
1518           else
1519             own=1;
1520
1521           homedir_cache=ret;
1522         }
1523     }
1524   else if(item==1 || item==2)
1525     {
1526       /* The options or extension file.  Okay unless it or its
1527          containing directory is group or other writable or not owned
1528          by us or root. */
1529
1530       if(S_ISREG(statbuf.st_mode))
1531         {
1532           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1533             {
1534               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1535                 {
1536                   /* it's not writable, so make sure the enclosing
1537                      directory is also not writable */
1538                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1539                     {
1540                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1541                         ret=0;
1542                       else
1543                         enc_dir_perm=1;
1544                     }
1545                   else
1546                     enc_dir_own=1;
1547                 }
1548               else
1549                 {
1550                   /* it's writable, so the enclosing directory had
1551                      better not let people get to it. */
1552                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1553                     {
1554                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1555                         ret=0;
1556                       else
1557                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1558                     }
1559                   else
1560                     enc_dir_own=1;
1561                 }
1562             }
1563           else
1564             own=1;
1565         }
1566     }
1567   else
1568     BUG();
1569
1570   if(!checkonly)
1571     {
1572       if(own)
1573         {
1574           if(item==0)
1575             log_info(_("WARNING: unsafe ownership on"
1576                        " homedir '%s'\n"),tmppath);
1577           else if(item==1)
1578             log_info(_("WARNING: unsafe ownership on"
1579                        " configuration file '%s'\n"),tmppath);
1580           else
1581             log_info(_("WARNING: unsafe ownership on"
1582                        " extension '%s'\n"),tmppath);
1583         }
1584       if(perm)
1585         {
1586           if(item==0)
1587             log_info(_("WARNING: unsafe permissions on"
1588                        " homedir '%s'\n"),tmppath);
1589           else if(item==1)
1590             log_info(_("WARNING: unsafe permissions on"
1591                        " configuration file '%s'\n"),tmppath);
1592           else
1593             log_info(_("WARNING: unsafe permissions on"
1594                        " extension '%s'\n"),tmppath);
1595         }
1596       if(enc_dir_own)
1597         {
1598           if(item==0)
1599             log_info(_("WARNING: unsafe enclosing directory ownership on"
1600                        " homedir '%s'\n"),tmppath);
1601           else if(item==1)
1602             log_info(_("WARNING: unsafe enclosing directory ownership on"
1603                        " configuration file '%s'\n"),tmppath);
1604           else
1605             log_info(_("WARNING: unsafe enclosing directory ownership on"
1606                        " extension '%s'\n"),tmppath);
1607         }
1608       if(enc_dir_perm)
1609         {
1610           if(item==0)
1611             log_info(_("WARNING: unsafe enclosing directory permissions on"
1612                        " homedir '%s'\n"),tmppath);
1613           else if(item==1)
1614             log_info(_("WARNING: unsafe enclosing directory permissions on"
1615                        " configuration file '%s'\n"),tmppath);
1616           else
1617             log_info(_("WARNING: unsafe enclosing directory permissions on"
1618                        " extension '%s'\n"),tmppath);
1619         }
1620     }
1621
1622  end:
1623   xfree(tmppath);
1624
1625   if(homedir)
1626     homedir_cache=ret;
1627
1628   return ret;
1629
1630 #else /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1631   (void)path;
1632   (void)item;
1633   return 0;
1634 #endif /*!(HAVE_STAT && !HAVE_DOSISH_SYSTEM)*/
1635 }
1636
1637
1638 /* Print the OpenPGP defined algo numbers.  */
1639 static void
1640 print_algo_numbers(int (*checker)(int))
1641 {
1642   int i,first=1;
1643
1644   for(i=0;i<=110;i++)
1645     {
1646       if(!checker(i))
1647         {
1648           if(first)
1649             first=0;
1650           else
1651             es_printf (";");
1652           es_printf ("%d",i);
1653         }
1654     }
1655 }
1656
1657
1658 static void
1659 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1660 {
1661   int i,first=1;
1662
1663   for(i=0;i<=110;i++)
1664     {
1665       if(!checker(i))
1666         {
1667           if(first)
1668             first=0;
1669           else
1670             es_printf (";");
1671           es_printf ("%s",mapper(i));
1672         }
1673     }
1674 }
1675
1676 /* In the future, we can do all sorts of interesting configuration
1677    output here.  For now, just give "group" as the Enigmail folks need
1678    it, and pubkey, cipher, hash, and compress as they may be useful
1679    for frontends. */
1680 static void
1681 list_config(char *items)
1682 {
1683   int show_all = !items;
1684   char *name = NULL;
1685   const char *s;
1686   struct groupitem *giter;
1687   int first, iter;
1688
1689   if(!opt.with_colons)
1690     return;
1691
1692   while(show_all || (name=strsep(&items," ")))
1693     {
1694       int any=0;
1695
1696       if(show_all || ascii_strcasecmp(name,"group")==0)
1697         {
1698           for (giter = opt.grouplist; giter; giter = giter->next)
1699             {
1700               strlist_t sl;
1701
1702               es_fprintf (es_stdout, "cfg:group:");
1703               es_write_sanitized (es_stdout, giter->name, strlen(giter->name),
1704                                   ":", NULL);
1705               es_putc (':', es_stdout);
1706
1707               for(sl=giter->values; sl; sl=sl->next)
1708                 {
1709                   es_write_sanitized (es_stdout, sl->d, strlen (sl->d),
1710                                       ":;", NULL);
1711                   if(sl->next)
1712                     es_printf(";");
1713                 }
1714
1715               es_printf("\n");
1716             }
1717
1718           any=1;
1719         }
1720
1721       if(show_all || ascii_strcasecmp(name,"version")==0)
1722         {
1723           es_printf("cfg:version:");
1724           es_write_sanitized (es_stdout, VERSION, strlen(VERSION), ":", NULL);
1725           es_printf ("\n");
1726           any=1;
1727         }
1728
1729       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1730         {
1731           es_printf ("cfg:pubkey:");
1732           print_algo_numbers (build_list_pk_test_algo);
1733           es_printf ("\n");
1734           any=1;
1735         }
1736
1737       if(show_all || ascii_strcasecmp(name,"pubkeyname")==0)
1738         {
1739           es_printf ("cfg:pubkeyname:");
1740           print_algo_names (build_list_pk_test_algo,
1741                             build_list_pk_algo_name);
1742           es_printf ("\n");
1743           any=1;
1744         }
1745
1746       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1747         {
1748           es_printf ("cfg:cipher:");
1749           print_algo_numbers (build_list_cipher_test_algo);
1750           es_printf ("\n");
1751           any=1;
1752         }
1753
1754       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1755         {
1756           es_printf ("cfg:ciphername:");
1757           print_algo_names (build_list_cipher_test_algo,
1758                             build_list_cipher_algo_name);
1759           es_printf ("\n");
1760           any = 1;
1761         }
1762
1763       if(show_all
1764          || ascii_strcasecmp(name,"digest")==0
1765          || ascii_strcasecmp(name,"hash")==0)
1766         {
1767           es_printf ("cfg:digest:");
1768           print_algo_numbers (build_list_md_test_algo);
1769           es_printf ("\n");
1770           any=1;
1771         }
1772
1773       if (show_all
1774           || !ascii_strcasecmp(name,"digestname")
1775           || !ascii_strcasecmp(name,"hashname"))
1776         {
1777           es_printf ("cfg:digestname:");
1778           print_algo_names (build_list_md_test_algo,
1779                             build_list_md_algo_name);
1780           es_printf ("\n");
1781           any=1;
1782         }
1783
1784       if(show_all || ascii_strcasecmp(name,"compress")==0)
1785         {
1786           es_printf ("cfg:compress:");
1787           print_algo_numbers(check_compress_algo);
1788           es_printf ("\n");
1789           any=1;
1790         }
1791
1792       if(show_all || ascii_strcasecmp (name, "compressname") == 0)
1793         {
1794           es_printf ("cfg:compressname:");
1795           print_algo_names (check_compress_algo,
1796                             compress_algo_to_string);
1797           es_printf ("\n");
1798           any=1;
1799         }
1800
1801       if (show_all || !ascii_strcasecmp(name,"ccid-reader-id"))
1802         {
1803           /* We ignore this for GnuPG 1.4 backward compatibility.  */
1804           any=1;
1805         }
1806
1807       if (show_all || !ascii_strcasecmp (name,"curve"))
1808         {
1809           es_printf ("cfg:curve:");
1810           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first=0)
1811             es_printf ("%s%s", first?"":";", s);
1812           es_printf ("\n");
1813           any=1;
1814         }
1815
1816       /* Curve OIDs are rarely useful and thus only printed if requested.  */
1817       if (name && !ascii_strcasecmp (name,"curveoid"))
1818         {
1819           es_printf ("cfg:curveoid:");
1820           for (iter=0, first=1; (s = openpgp_enum_curves (&iter)); first = 0)
1821             {
1822               s = openpgp_curve_to_oid (s, NULL);
1823               es_printf ("%s%s", first?"":";", s? s:"[?]");
1824             }
1825           es_printf ("\n");
1826           any=1;
1827         }
1828
1829       if(show_all)
1830         break;
1831
1832       if(!any)
1833         log_error(_("unknown configuration item '%s'\n"),name);
1834     }
1835 }
1836
1837
1838 /* List options and default values in the GPG Conf format.  This is a
1839    new tool distributed with gnupg 1.9.x but we also want some limited
1840    support in older gpg versions.  The output is the name of the
1841    configuration file and a list of options available for editing by
1842    gpgconf.  */
1843 static void
1844 gpgconf_list (const char *configfile)
1845 {
1846   char *configfile_esc = percent_escape (configfile, NULL);
1847
1848   es_printf ("%s-%s.conf:%lu:\"%s\n",
1849              GPGCONF_NAME, GPG_NAME,
1850              GC_OPT_FLAG_DEFAULT,
1851              configfile_esc ? configfile_esc : "/dev/null");
1852   es_printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1853   es_printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1854   es_printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1855   es_printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1856   es_printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1857   es_printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1858   es_printf ("try-secret-key:%lu:\n", GC_OPT_FLAG_NONE);
1859   es_printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1860   es_printf ("auto-key-retrieve:%lu:\n", GC_OPT_FLAG_NONE);
1861   es_printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1862   es_printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1863   es_printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1864   es_printf ("compliance:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT, "gnupg");
1865   es_printf ("default-new-key-algo:%lu:\n", GC_OPT_FLAG_NONE);
1866   es_printf ("trust-model:%lu:\n", GC_OPT_FLAG_NONE);
1867   es_printf ("disable-dirmngr:%lu:\n", GC_OPT_FLAG_NONE);
1868   es_printf ("max-cert-depth:%lu:\n", GC_OPT_FLAG_NONE);
1869   es_printf ("completes-needed:%lu:\n", GC_OPT_FLAG_NONE);
1870   es_printf ("marginals-needed:%lu:\n", GC_OPT_FLAG_NONE);
1871
1872   /* The next one is an info only item and should match the macros at
1873      the top of keygen.c  */
1874   es_printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1875              get_default_pubkey_algo ());
1876
1877   xfree (configfile_esc);
1878 }
1879
1880
1881 static int
1882 parse_subpacket_list(char *list)
1883 {
1884   char *tok;
1885   byte subpackets[128],i;
1886   int count=0;
1887
1888   if(!list)
1889     {
1890       /* No arguments means all subpackets */
1891       memset(subpackets+1,1,sizeof(subpackets)-1);
1892       count=127;
1893     }
1894   else
1895     {
1896       memset(subpackets,0,sizeof(subpackets));
1897
1898       /* Merge with earlier copy */
1899       if(opt.show_subpackets)
1900         {
1901           byte *in;
1902
1903           for(in=opt.show_subpackets;*in;in++)
1904             {
1905               if(*in>127 || *in<1)
1906                 BUG();
1907
1908               if(!subpackets[*in])
1909                 count++;
1910               subpackets[*in]=1;
1911             }
1912         }
1913
1914       while((tok=strsep(&list," ,")))
1915         {
1916           if(!*tok)
1917             continue;
1918
1919           i=atoi(tok);
1920           if(i>127 || i<1)
1921             return 0;
1922
1923           if(!subpackets[i])
1924             count++;
1925           subpackets[i]=1;
1926         }
1927     }
1928
1929   xfree(opt.show_subpackets);
1930   opt.show_subpackets=xmalloc(count+1);
1931   opt.show_subpackets[count--]=0;
1932
1933   for(i=1;i<128 && count>=0;i++)
1934     if(subpackets[i])
1935       opt.show_subpackets[count--]=i;
1936
1937   return 1;
1938 }
1939
1940
1941 static int
1942 parse_list_options(char *str)
1943 {
1944   char *subpackets=""; /* something that isn't NULL */
1945   struct parse_options lopts[]=
1946     {
1947       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1948        N_("display photo IDs during key listings")},
1949       {"show-usage",LIST_SHOW_USAGE,NULL,
1950        N_("show key usage information during key listings")},
1951       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1952        N_("show policy URLs during signature listings")},
1953       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1954        N_("show all notations during signature listings")},
1955       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1956        N_("show IETF standard notations during signature listings")},
1957       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1958        NULL},
1959       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1960        N_("show user-supplied notations during signature listings")},
1961       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1962        N_("show preferred keyserver URLs during signature listings")},
1963       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1964        N_("show user ID validity during key listings")},
1965       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1966        N_("show revoked and expired user IDs in key listings")},
1967       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1968        N_("show revoked and expired subkeys in key listings")},
1969       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1970        N_("show the keyring name in key listings")},
1971       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1972        N_("show expiration dates during signature listings")},
1973       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1974        NULL},
1975       {NULL,0,NULL,NULL}
1976     };
1977
1978   /* C99 allows for non-constant initializers, but we'd like to
1979      compile everywhere, so fill in the show-sig-subpackets argument
1980      here.  Note that if the parse_options array changes, we'll have
1981      to change the subscript here. */
1982   lopts[13].value=&subpackets;
1983
1984   if(parse_options(str,&opt.list_options,lopts,1))
1985     {
1986       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1987         {
1988           /* Unset so users can pass multiple lists in. */
1989           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1990           if(!parse_subpacket_list(subpackets))
1991             return 0;
1992         }
1993       else if(subpackets==NULL && opt.show_subpackets)
1994         {
1995           /* User did 'no-show-subpackets' */
1996           xfree(opt.show_subpackets);
1997           opt.show_subpackets=NULL;
1998         }
1999
2000       return 1;
2001     }
2002   else
2003     return 0;
2004 }
2005
2006
2007 /* Collapses argc/argv into a single string that must be freed */
2008 static char *
2009 collapse_args(int argc,char *argv[])
2010 {
2011   char *str=NULL;
2012   int i,first=1,len=0;
2013
2014   for(i=0;i<argc;i++)
2015     {
2016       len+=strlen(argv[i])+2;
2017       str=xrealloc(str,len);
2018       if(first)
2019         {
2020           str[0]='\0';
2021           first=0;
2022         }
2023       else
2024         strcat(str," ");
2025
2026       strcat(str,argv[i]);
2027     }
2028
2029   return str;
2030 }
2031
2032
2033 #ifndef NO_TRUST_MODELS
2034 static void
2035 parse_trust_model(const char *model)
2036 {
2037   if(ascii_strcasecmp(model,"pgp")==0)
2038     opt.trust_model=TM_PGP;
2039   else if(ascii_strcasecmp(model,"classic")==0)
2040     opt.trust_model=TM_CLASSIC;
2041   else if(ascii_strcasecmp(model,"always")==0)
2042     opt.trust_model=TM_ALWAYS;
2043   else if(ascii_strcasecmp(model,"direct")==0)
2044     opt.trust_model=TM_DIRECT;
2045 #ifdef USE_TOFU
2046   else if(ascii_strcasecmp(model,"tofu")==0)
2047     opt.trust_model=TM_TOFU;
2048   else if(ascii_strcasecmp(model,"tofu+pgp")==0)
2049     opt.trust_model=TM_TOFU_PGP;
2050 #endif /*USE_TOFU*/
2051   else if(ascii_strcasecmp(model,"auto")==0)
2052     opt.trust_model=TM_AUTO;
2053   else
2054     log_error("unknown trust model '%s'\n",model);
2055 }
2056 #endif /*NO_TRUST_MODELS*/
2057
2058
2059 static int
2060 parse_tofu_policy (const char *policystr)
2061 {
2062 #ifdef USE_TOFU
2063   struct { const char *keyword; int policy; } list[] = {
2064     { "auto",    TOFU_POLICY_AUTO },
2065     { "good",    TOFU_POLICY_GOOD },
2066     { "unknown", TOFU_POLICY_UNKNOWN },
2067     { "bad",     TOFU_POLICY_BAD },
2068     { "ask",     TOFU_POLICY_ASK }
2069   };
2070   int i;
2071
2072   if (!ascii_strcasecmp (policystr, "help"))
2073     {
2074       log_info (_("valid values for option '%s':\n"), "--tofu-policy");
2075       for (i=0; i < DIM (list); i++)
2076         log_info ("  %s\n", list[i].keyword);
2077       g10_exit (1);
2078     }
2079
2080   for (i=0; i < DIM (list); i++)
2081     if (!ascii_strcasecmp (policystr, list[i].keyword))
2082       return list[i].policy;
2083 #endif /*USE_TOFU*/
2084
2085   log_error (_("unknown TOFU policy '%s'\n"), policystr);
2086   if (!opt.quiet)
2087     log_info (_("(use \"help\" to list choices)\n"));
2088   g10_exit (1);
2089 }
2090
2091
2092 static struct gnupg_compliance_option compliance_options[] =
2093   {
2094     { "gnupg",      oGnuPG },
2095     { "openpgp",    oOpenPGP },
2096     { "rfc4880bis", oRFC4880bis },
2097     { "rfc4880",    oRFC4880 },
2098     { "rfc2440",    oRFC2440 },
2099     { "pgp6",       oPGP6 },
2100     { "pgp7",       oPGP7 },
2101     { "pgp8",       oPGP8 },
2102     { "de-vs",      oDE_VS }
2103   };
2104
2105
2106 /* Helper to set compliance related options.  This is a separate
2107  * function so that it can also be used by the --compliance option
2108  * parser.  */
2109 static void
2110 set_compliance_option (enum cmd_and_opt_values option)
2111 {
2112   switch (option)
2113     {
2114     case oRFC4880bis:
2115       opt.flags.rfc4880bis = 1;
2116       /* fall through.  */
2117     case oOpenPGP:
2118     case oRFC4880:
2119       /* This is effectively the same as RFC2440, but with
2120          "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2121          --require-cross-certification". */
2122       opt.compliance = CO_RFC4880;
2123       opt.flags.dsa2 = 1;
2124       opt.flags.require_cross_cert = 1;
2125       opt.rfc2440_text = 0;
2126       opt.allow_non_selfsigned_uid = 1;
2127       opt.allow_freeform_uid = 1;
2128       opt.escape_from = 1;
2129       opt.not_dash_escaped = 0;
2130       opt.def_cipher_algo = 0;
2131       opt.def_digest_algo = 0;
2132       opt.cert_digest_algo = 0;
2133       opt.compress_algo = -1;
2134       opt.s2k_mode = 3; /* iterated+salted */
2135       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2136       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2137       break;
2138     case oRFC2440:
2139       opt.compliance = CO_RFC2440;
2140       opt.flags.dsa2 = 0;
2141       opt.rfc2440_text = 1;
2142       opt.allow_non_selfsigned_uid = 1;
2143       opt.allow_freeform_uid = 1;
2144       opt.escape_from = 0;
2145       opt.not_dash_escaped = 0;
2146       opt.def_cipher_algo = 0;
2147       opt.def_digest_algo = 0;
2148       opt.cert_digest_algo = 0;
2149       opt.compress_algo = -1;
2150       opt.s2k_mode = 3; /* iterated+salted */
2151       opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2152       opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2153       break;
2154     case oPGP6:  opt.compliance = CO_PGP6;  break;
2155     case oPGP7:  opt.compliance = CO_PGP7;  break;
2156     case oPGP8:  opt.compliance = CO_PGP8;  break;
2157     case oGnuPG: opt.compliance = CO_GNUPG; break;
2158
2159     case oDE_VS:
2160       set_compliance_option (oOpenPGP);
2161       opt.compliance = CO_DE_VS;
2162       opt.force_mdc = 1;
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   ctrl->magic = SERVER_CONTROL_MAGIC;
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   keydb_release (ctrl->cached_getkey_kdb);
2197 }
2198
2199
2200 char *
2201 get_default_configname (void)
2202 {
2203   char *configname = NULL;
2204   char *name = xstrdup (GPG_NAME EXTSEP_S "conf-" SAFE_VERSION);
2205   char *ver = &name[strlen (GPG_NAME EXTSEP_S "conf-")];
2206
2207   do
2208     {
2209       if (configname)
2210         {
2211           char *tok;
2212
2213           xfree (configname);
2214           configname = NULL;
2215
2216           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
2217             *tok='\0';
2218           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
2219             *tok='\0';
2220           else
2221             break;
2222         }
2223
2224       configname = make_filename (gnupg_homedir (), name, NULL);
2225     }
2226   while (access (configname, R_OK));
2227
2228   xfree(name);
2229
2230   if (! configname)
2231     configname = make_filename (gnupg_homedir (),
2232                                 GPG_NAME EXTSEP_S "conf", NULL);
2233   if (! access (configname, R_OK))
2234     {
2235       /* Print a warning when both config files are present.  */
2236       char *p = make_filename (gnupg_homedir (), "options", NULL);
2237       if (! access (p, R_OK))
2238         log_info (_("Note: old default options file '%s' ignored\n"), p);
2239       xfree (p);
2240     }
2241   else
2242     {
2243       /* Use the old default only if it exists.  */
2244       char *p = make_filename (gnupg_homedir (), "options", NULL);
2245       if (!access (p, R_OK))
2246         {
2247           xfree (configname);
2248           configname = p;
2249         }
2250       else
2251         xfree (p);
2252     }
2253
2254   return configname;
2255 }
2256
2257 int
2258 main (int argc, char **argv)
2259 {
2260     ARGPARSE_ARGS pargs;
2261     IOBUF a;
2262     int rc=0;
2263     int orig_argc;
2264     char **orig_argv;
2265     const char *fname;
2266     char *username;
2267     int may_coredump;
2268     strlist_t sl;
2269     strlist_t remusr = NULL;
2270     strlist_t locusr = NULL;
2271     strlist_t nrings = NULL;
2272     armor_filter_context_t *afx = NULL;
2273     int detached_sig = 0;
2274     FILE *configfp = NULL;
2275     char *configname = NULL;
2276     char *save_configname = NULL;
2277     char *default_configname = NULL;
2278     unsigned configlineno;
2279     int parse_debug = 0;
2280     int default_config = 1;
2281     int default_keyring = 1;
2282     int greeting = 0;
2283     int nogreeting = 0;
2284     char *logfile = NULL;
2285     int use_random_seed = 1;
2286     enum cmd_and_opt_values cmd = 0;
2287     const char *debug_level = NULL;
2288 #ifndef NO_TRUST_MODELS
2289     const char *trustdb_name = NULL;
2290 #endif /*!NO_TRUST_MODELS*/
2291     char *def_cipher_string = NULL;
2292     char *def_digest_string = NULL;
2293     char *compress_algo_string = NULL;
2294     char *cert_digest_string = NULL;
2295     char *s2k_cipher_string = NULL;
2296     char *s2k_digest_string = NULL;
2297     char *pers_cipher_list = NULL;
2298     char *pers_digest_list = NULL;
2299     char *pers_compress_list = NULL;
2300     int eyes_only=0;
2301     int multifile=0;
2302     int pwfd = -1;
2303     int ovrseskeyfd = -1;
2304     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
2305     int any_explicit_recipient = 0;
2306     int default_akl = 1;
2307     int require_secmem = 0;
2308     int got_secmem = 0;
2309     struct assuan_malloc_hooks malloc_hooks;
2310     ctrl_t ctrl;
2311
2312     static int print_dane_records;
2313     static int print_pka_records;
2314
2315
2316 #ifdef __riscos__
2317     opt.lock_once = 1;
2318 #endif /* __riscos__ */
2319
2320     /* Please note that we may running SUID(ROOT), so be very CAREFUL
2321        when adding any stuff between here and the call to
2322        secmem_init() somewhere after the option parsing. */
2323     early_system_init ();
2324     gnupg_reopen_std (GPG_NAME);
2325     trap_unaligned ();
2326     gnupg_rl_initialize ();
2327     set_strusage (my_strusage);
2328     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
2329     log_set_prefix (GPG_NAME, GPGRT_LOG_WITH_PREFIX);
2330
2331     /* Make sure that our subsystems are ready.  */
2332     i18n_init();
2333     init_common_subsystems (&argc, &argv);
2334
2335     /* Use our own logging handler for Libcgrypt.  */
2336     setup_libgcrypt_logging ();
2337
2338     /* Put random number into secure memory */
2339     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
2340
2341     may_coredump = disable_core_dumps();
2342
2343     gnupg_init_signals (0, emergency_cleanup);
2344
2345     dotlock_create (NULL, 0); /* Register lock file cleanup. */
2346
2347     /* Tell the compliance module who we are.  */
2348     gnupg_initialize_compliance (GNUPG_MODULE_NAME_GPG);
2349
2350     opt.autostart = 1;
2351     opt.session_env = session_env_new ();
2352     if (!opt.session_env)
2353       log_fatal ("error allocating session environment block: %s\n",
2354                  strerror (errno));
2355
2356     opt.command_fd = -1; /* no command fd */
2357     opt.compress_level = -1; /* defaults to standard compress level */
2358     opt.bz2_compress_level = -1; /* defaults to standard compress level */
2359     /* note: if you change these lines, look at oOpenPGP */
2360     opt.def_cipher_algo = 0;
2361     opt.def_digest_algo = 0;
2362     opt.cert_digest_algo = 0;
2363     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
2364     opt.s2k_mode = 3; /* iterated+salted */
2365     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
2366     opt.s2k_cipher_algo = DEFAULT_CIPHER_ALGO;
2367     opt.completes_needed = 1;
2368     opt.marginals_needed = 3;
2369     opt.max_cert_depth = 5;
2370     opt.escape_from = 1;
2371     opt.flags.require_cross_cert = 1;
2372     opt.import_options = IMPORT_REPAIR_KEYS;
2373     opt.export_options = EXPORT_ATTRIBUTES;
2374     opt.keyserver_options.import_options = (IMPORT_REPAIR_KEYS
2375                                             | IMPORT_REPAIR_PKS_SUBKEY_BUG);
2376     opt.keyserver_options.export_options = EXPORT_ATTRIBUTES;
2377     opt.keyserver_options.options = KEYSERVER_HONOR_PKA_RECORD;
2378     opt.verify_options = (LIST_SHOW_UID_VALIDITY
2379                           | VERIFY_SHOW_POLICY_URLS
2380                           | VERIFY_SHOW_STD_NOTATIONS
2381                           | VERIFY_SHOW_KEYSERVER_URLS);
2382     opt.list_options   = (LIST_SHOW_UID_VALIDITY
2383                           | LIST_SHOW_USAGE);
2384 #ifdef NO_TRUST_MODELS
2385     opt.trust_model = TM_ALWAYS;
2386 #else
2387     opt.trust_model = TM_AUTO;
2388 #endif
2389     opt.tofu_default_policy = TOFU_POLICY_AUTO;
2390     opt.mangle_dos_filenames = 0;
2391     opt.min_cert_level = 2;
2392     set_screen_dimensions ();
2393     opt.keyid_format = KF_NONE;
2394     opt.def_sig_expire = "0";
2395     opt.def_cert_expire = "0";
2396     gnupg_set_homedir (NULL);
2397     opt.passphrase_repeat = 1;
2398     opt.emit_version = 0;
2399     opt.weak_digests = NULL;
2400
2401     /* Check whether we have a config file on the command line.  */
2402     orig_argc = argc;
2403     orig_argv = argv;
2404     pargs.argc = &argc;
2405     pargs.argv = &argv;
2406     pargs.flags= (ARGPARSE_FLAG_KEEP | ARGPARSE_FLAG_NOVERSION);
2407     while( arg_parse( &pargs, opts) ) {
2408         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2409             parse_debug++;
2410         else if (pargs.r_opt == oDebugIOLBF)
2411             es_setvbuf (es_stdout, NULL, _IOLBF, 0);
2412         else if( pargs.r_opt == oOptions ) {
2413             /* yes there is one, so we do not try the default one, but
2414              * read the option file when it is encountered at the commandline
2415              */
2416             default_config = 0;
2417         }
2418         else if( pargs.r_opt == oNoOptions )
2419           {
2420             default_config = 0; /* --no-options */
2421             opt.no_homedir_creation = 1;
2422           }
2423         else if( pargs.r_opt == oHomedir )
2424             gnupg_set_homedir (pargs.r.ret_str);
2425         else if( pargs.r_opt == oNoPermissionWarn )
2426             opt.no_perm_warn=1;
2427         else if (pargs.r_opt == oStrict )
2428           {
2429             /* Not used */
2430           }
2431         else if (pargs.r_opt == oNoStrict )
2432           {
2433             /* Not used */
2434           }
2435     }
2436
2437 #ifdef HAVE_DOSISH_SYSTEM
2438     if ( strchr (gnupg_homedir (), '\\') ) {
2439       char *d, *buf = xmalloc (strlen (gnupg_homedir ())+1);
2440       const char *s;
2441       for (d=buf, s = gnupg_homedir (); *s; s++)
2442           {
2443             *d++ = *s == '\\'? '/': *s;
2444 #ifdef HAVE_W32_SYSTEM
2445             if (s[1] && IsDBCSLeadByte (*s))
2446               *d++ = *++s;
2447 #endif
2448           }
2449         *d = 0;
2450         gnupg_set_homedir (buf);
2451     }
2452 #endif
2453
2454     /* Initialize the secure memory. */
2455     if (!gcry_control (GCRYCTL_INIT_SECMEM, SECMEM_BUFFER_SIZE, 0))
2456       got_secmem = 1;
2457 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2458     /* There should be no way to get to this spot while still carrying
2459        setuid privs.  Just in case, bomb out if we are. */
2460     if ( getuid () != geteuid () )
2461       BUG ();
2462 #endif
2463     maybe_setuid = 0;
2464
2465     /* Okay, we are now working under our real uid */
2466
2467     /* malloc hooks go here ... */
2468     malloc_hooks.malloc = gcry_malloc;
2469     malloc_hooks.realloc = gcry_realloc;
2470     malloc_hooks.free = gcry_free;
2471     assuan_set_malloc_hooks (&malloc_hooks);
2472     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2473     setup_libassuan_logging (&opt.debug, NULL);
2474
2475     /* Set default options which require that malloc stuff is ready.  */
2476     additional_weak_digest ("MD5");
2477     parse_auto_key_locate ("local,wkd");
2478
2479     /* Try for a version specific config file first */
2480     default_configname = get_default_configname ();
2481     if (default_config)
2482       configname = xstrdup (default_configname);
2483
2484     argc = orig_argc;
2485     argv = orig_argv;
2486     pargs.argc = &argc;
2487     pargs.argv = &argv;
2488     pargs.flags= ARGPARSE_FLAG_KEEP;
2489
2490     /* By this point we have a homedir, and cannot change it. */
2491     check_permissions (gnupg_homedir (), 0);
2492
2493   next_pass:
2494     if( configname ) {
2495       if(check_permissions(configname,1))
2496         {
2497           /* If any options file is unsafe, then disable any external
2498              programs for keyserver calls or photo IDs.  Since the
2499              external program to call is set in the options file, a
2500              unsafe options file can lead to an arbitrary program
2501              being run. */
2502
2503           opt.exec_disable=1;
2504         }
2505
2506         configlineno = 0;
2507         configfp = fopen( configname, "r" );
2508         if (configfp && is_secured_file (fileno (configfp)))
2509           {
2510             fclose (configfp);
2511             configfp = NULL;
2512             gpg_err_set_errno (EPERM);
2513           }
2514         if( !configfp ) {
2515             if( default_config ) {
2516                 if( parse_debug )
2517                     log_info(_("Note: no default option file '%s'\n"),
2518                                                             configname );
2519             }
2520             else {
2521                 log_error(_("option file '%s': %s\n"),
2522                                     configname, strerror(errno) );
2523                 g10_exit(2);
2524             }
2525             xfree(configname); configname = NULL;
2526         }
2527         if( parse_debug && configname )
2528             log_info(_("reading options from '%s'\n"), configname );
2529         default_config = 0;
2530     }
2531
2532     while( optfile_parse( configfp, configname, &configlineno,
2533                                                 &pargs, opts) )
2534       {
2535         switch( pargs.r_opt )
2536           {
2537           case aListConfig:
2538           case aListGcryptConfig:
2539           case aGPGConfList:
2540           case aGPGConfTest:
2541             set_cmd (&cmd, pargs.r_opt);
2542             /* Do not register a keyring for these commands.  */
2543             default_keyring = -1;
2544             break;
2545
2546           case aCheckKeys:
2547           case aListPackets:
2548           case aImport:
2549           case aFastImport:
2550           case aSendKeys:
2551           case aRecvKeys:
2552           case aSearchKeys:
2553           case aRefreshKeys:
2554           case aFetchKeys:
2555           case aExport:
2556 #ifdef ENABLE_CARD_SUPPORT
2557           case aCardStatus:
2558           case aCardEdit:
2559           case aChangePIN:
2560 #endif /* ENABLE_CARD_SUPPORT*/
2561           case aListKeys:
2562           case aLocateKeys:
2563           case aListSigs:
2564           case aExportSecret:
2565           case aExportSecretSub:
2566           case aExportSshKey:
2567           case aSym:
2568           case aClearsign:
2569           case aGenRevoke:
2570           case aDesigRevoke:
2571           case aPrimegen:
2572           case aGenRandom:
2573           case aPrintMD:
2574           case aPrintMDs:
2575           case aListTrustDB:
2576           case aCheckTrustDB:
2577           case aUpdateTrustDB:
2578           case aFixTrustDB:
2579           case aListTrustPath:
2580           case aDeArmor:
2581           case aEnArmor:
2582           case aSign:
2583           case aQuickSignKey:
2584           case aQuickLSignKey:
2585           case aSignKey:
2586           case aLSignKey:
2587           case aStore:
2588           case aQuickKeygen:
2589           case aQuickAddUid:
2590           case aQuickAddKey:
2591           case aQuickRevUid:
2592           case aQuickSetExpire:
2593           case aQuickSetPrimaryUid:
2594           case aExportOwnerTrust:
2595           case aImportOwnerTrust:
2596           case aRebuildKeydbCaches:
2597             set_cmd (&cmd, pargs.r_opt);
2598             break;
2599
2600           case aKeygen:
2601           case aFullKeygen:
2602           case aEditKey:
2603           case aDeleteSecretKeys:
2604           case aDeleteSecretAndPublicKeys:
2605           case aDeleteKeys:
2606           case aPasswd:
2607             set_cmd (&cmd, pargs.r_opt);
2608             greeting=1;
2609             break;
2610
2611           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2612
2613           case aDecryptFiles: multifile=1; /* fall through */
2614           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2615
2616           case aEncrFiles: multifile=1; /* fall through */
2617           case aEncr: set_cmd( &cmd, aEncr); break;
2618
2619           case aVerifyFiles: multifile=1; /* fall through */
2620           case aVerify: set_cmd( &cmd, aVerify); break;
2621
2622           case aServer:
2623             set_cmd (&cmd, pargs.r_opt);
2624             opt.batch = 1;
2625             break;
2626
2627           case aTOFUPolicy:
2628             set_cmd (&cmd, pargs.r_opt);
2629             break;
2630
2631           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2632           case oOutput: opt.outfile = pargs.r.ret_str; break;
2633
2634           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2635
2636           case oInputSizeHint:
2637             opt.input_size_hint = string_to_u64 (pargs.r.ret_str);
2638             break;
2639
2640           case oQuiet: opt.quiet = 1; break;
2641           case oNoTTY: tty_no_terminal(1); break;
2642           case oDryRun: opt.dry_run = 1; break;
2643           case oInteractive: opt.interactive = 1; break;
2644           case oVerbose:
2645             opt.verbose++;
2646             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2647             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2648             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2649             break;
2650
2651           case oBatch:
2652             opt.batch = 1;
2653             nogreeting = 1;
2654             break;
2655
2656           case oUseAgent: /* Dummy. */
2657             break;
2658
2659           case oNoUseAgent:
2660             obsolete_option (configname, configlineno, "no-use-agent");
2661             break;
2662           case oGpgAgentInfo:
2663             obsolete_option (configname, configlineno, "gpg-agent-info");
2664             break;
2665           case oReaderPort:
2666             obsolete_scdaemon_option (configname, configlineno, "reader-port");
2667             break;
2668           case octapiDriver:
2669             obsolete_scdaemon_option (configname, configlineno, "ctapi-driver");
2670             break;
2671           case opcscDriver:
2672             obsolete_scdaemon_option (configname, configlineno, "pcsc-driver");
2673             break;
2674           case oDisableCCID:
2675             obsolete_scdaemon_option (configname, configlineno, "disable-ccid");
2676             break;
2677           case oHonorHttpProxy:
2678             obsolete_option (configname, configlineno, "honor-http-proxy");
2679             break;
2680
2681           case oAnswerYes: opt.answer_yes = 1; break;
2682           case oAnswerNo: opt.answer_no = 1; break;
2683           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2684           case oPrimaryKeyring:
2685             sl = append_to_strlist (&nrings, pargs.r.ret_str);
2686             sl->flags = KEYDB_RESOURCE_FLAG_PRIMARY;
2687             break;
2688           case oShowKeyring:
2689             deprecated_warning(configname,configlineno,"--show-keyring",
2690                                "--list-options ","show-keyring");
2691             opt.list_options|=LIST_SHOW_KEYRING;
2692             break;
2693
2694           case oDebug:
2695             if (parse_debug_flag (pargs.r.ret_str, &opt.debug, debug_flags))
2696               {
2697                 pargs.r_opt = ARGPARSE_INVALID_ARG;
2698                 pargs.err = ARGPARSE_PRINT_ERROR;
2699               }
2700             break;
2701
2702           case oDebugAll: opt.debug = ~0; break;
2703           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2704
2705           case oDebugIOLBF: break; /* Already set in pre-parse step.  */
2706
2707           case oStatusFD:
2708             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2709             break;
2710           case oStatusFile:
2711             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2712             break;
2713           case oAttributeFD:
2714             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2715             break;
2716           case oAttributeFile:
2717             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2718             break;
2719           case oLoggerFD:
2720             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2721             break;
2722           case oLoggerFile:
2723             logfile = pargs.r.ret_str;
2724             break;
2725
2726           case oWithFingerprint:
2727             opt.with_fingerprint = 1;
2728             opt.fingerprint++;
2729             break;
2730           case oWithSubkeyFingerprint:
2731             opt.with_subkey_fingerprint = 1;
2732             break;
2733           case oWithICAOSpelling:
2734             opt.with_icao_spelling = 1;
2735             break;
2736           case oFingerprint:
2737             opt.fingerprint++;
2738             fpr_maybe_cmd = 1;
2739             break;
2740
2741           case oWithKeygrip:
2742             opt.with_keygrip = 1;
2743             break;
2744
2745           case oWithSecret:
2746             opt.with_secret = 1;
2747             break;
2748
2749           case oWithWKDHash:
2750             opt.with_wkd_hash = 1;
2751             break;
2752
2753           case oWithKeyOrigin:
2754             opt.with_key_origin = 1;
2755             break;
2756
2757           case oSecretKeyring:
2758             /* Ignore this old option.  */
2759             break;
2760
2761           case oOptions:
2762             /* config files may not be nested (silently ignore them) */
2763             if( !configfp ) {
2764                 xfree(configname);
2765                 configname = xstrdup(pargs.r.ret_str);
2766                 goto next_pass;
2767             }
2768             break;
2769           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2770
2771           case oNoDefKeyring:
2772             if (default_keyring > 0)
2773               default_keyring = 0;
2774             break;
2775           case oNoKeyring:
2776             default_keyring = -1;
2777             break;
2778
2779           case oNoGreeting: nogreeting = 1; break;
2780           case oNoVerbose:
2781             opt.verbose = 0;
2782             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2783             opt.list_sigs=0;
2784             break;
2785           case oQuickRandom:
2786             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2787             break;
2788           case oEmitVersion: opt.emit_version++; break;
2789           case oNoEmitVersion: opt.emit_version=0; break;
2790           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2791           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2792           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2793
2794 #ifndef NO_TRUST_MODELS
2795           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2796
2797 #endif /*!NO_TRUST_MODELS*/
2798           case oDefaultKey:
2799             sl = add_to_strlist (&opt.def_secret_key, pargs.r.ret_str);
2800             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2801             if (configfp)
2802               sl->flags |= PK_LIST_CONFIG;
2803             break;
2804           case oDefRecipient:
2805             if( *pargs.r.ret_str )
2806               {
2807                 xfree (opt.def_recipient);
2808                 opt.def_recipient = make_username(pargs.r.ret_str);
2809               }
2810             break;
2811           case oDefRecipientSelf:
2812             xfree(opt.def_recipient); opt.def_recipient = NULL;
2813             opt.def_recipient_self = 1;
2814             break;
2815           case oNoDefRecipient:
2816             xfree(opt.def_recipient); opt.def_recipient = NULL;
2817             opt.def_recipient_self = 0;
2818             break;
2819           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2820           case oHomedir: break;
2821           case oNoBatch: opt.batch = 0; break;
2822
2823           case oWithTofuInfo: opt.with_tofu_info = 1; break;
2824
2825           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2826           case oWithColons: opt.with_colons=':'; break;
2827
2828           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2829           case oWithSigList: opt.list_sigs = 1; break;
2830
2831           case oSkipVerify: opt.skip_verify=1; break;
2832
2833           case oSkipHiddenRecipients: opt.skip_hidden_recipients = 1; break;
2834           case oNoSkipHiddenRecipients: opt.skip_hidden_recipients = 0; break;
2835
2836           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2837
2838 #ifndef NO_TRUST_MODELS
2839             /* There are many programs (like mutt) that call gpg with
2840                --always-trust so keep this option around for a long
2841                time. */
2842           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2843           case oTrustModel:
2844             parse_trust_model(pargs.r.ret_str);
2845             break;
2846 #endif /*!NO_TRUST_MODELS*/
2847           case oTOFUDefaultPolicy:
2848             opt.tofu_default_policy = parse_tofu_policy (pargs.r.ret_str);
2849             break;
2850           case oTOFUDBFormat:
2851             obsolete_option (configname, configlineno, "tofu-db-format");
2852             break;
2853
2854           case oForceOwnertrust:
2855             log_info(_("Note: %s is not for normal use!\n"),
2856                      "--force-ownertrust");
2857             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2858             if(opt.force_ownertrust==-1)
2859               {
2860                 log_error("invalid ownertrust '%s'\n",pargs.r.ret_str);
2861                 opt.force_ownertrust=0;
2862               }
2863             break;
2864           case oLoadExtension:
2865             /* Dummy so that gpg 1.4 conf files can work. Should
2866                eventually be removed.  */
2867             break;
2868
2869           case oCompliance:
2870             {
2871               int compliance = gnupg_parse_compliance_option
2872                 (pargs.r.ret_str,
2873                  compliance_options, DIM (compliance_options),
2874                  opt.quiet);
2875               if (compliance < 0)
2876                 g10_exit (1);
2877               set_compliance_option (compliance);
2878             }
2879             break;
2880           case oOpenPGP:
2881           case oRFC2440:
2882           case oRFC4880:
2883           case oRFC4880bis:
2884           case oPGP6:
2885           case oPGP7:
2886           case oPGP8:
2887           case oGnuPG:
2888             set_compliance_option (pargs.r_opt);
2889             break;
2890
2891           case oRFC2440Text: opt.rfc2440_text=1; break;
2892           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2893
2894           case oSetFilename:
2895             if(utf8_strings)
2896               opt.set_filename = pargs.r.ret_str;
2897             else
2898               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2899             break;
2900           case oForYourEyesOnly: eyes_only = 1; break;
2901           case oNoForYourEyesOnly: eyes_only = 0; break;
2902           case oSetPolicyURL:
2903             add_policy_url(pargs.r.ret_str,0);
2904             add_policy_url(pargs.r.ret_str,1);
2905             break;
2906           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2907           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2908           case oShowPolicyURL:
2909             deprecated_warning(configname,configlineno,"--show-policy-url",
2910                                "--list-options ","show-policy-urls");
2911             deprecated_warning(configname,configlineno,"--show-policy-url",
2912                                "--verify-options ","show-policy-urls");
2913             opt.list_options|=LIST_SHOW_POLICY_URLS;
2914             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2915             break;
2916           case oNoShowPolicyURL:
2917             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2918                                "--list-options ","no-show-policy-urls");
2919             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2920                                "--verify-options ","no-show-policy-urls");
2921             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2922             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2923             break;
2924           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2925           case oUseEmbeddedFilename:
2926             opt.flags.use_embedded_filename=1;
2927             break;
2928           case oNoUseEmbeddedFilename:
2929             opt.flags.use_embedded_filename=0;
2930             break;
2931           case oComment:
2932             if(pargs.r.ret_str[0])
2933               append_to_strlist(&opt.comments,pargs.r.ret_str);
2934             break;
2935           case oDefaultComment:
2936             deprecated_warning(configname,configlineno,
2937                                "--default-comment","--no-comments","");
2938             /* fall through */
2939           case oNoComments:
2940             free_strlist(opt.comments);
2941             opt.comments=NULL;
2942             break;
2943           case oThrowKeyids: opt.throw_keyids = 1; break;
2944           case oNoThrowKeyids: opt.throw_keyids = 0; break;
2945           case oShowPhotos:
2946             deprecated_warning(configname,configlineno,"--show-photos",
2947                                "--list-options ","show-photos");
2948             deprecated_warning(configname,configlineno,"--show-photos",
2949                                "--verify-options ","show-photos");
2950             opt.list_options|=LIST_SHOW_PHOTOS;
2951             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2952             break;
2953           case oNoShowPhotos:
2954             deprecated_warning(configname,configlineno,"--no-show-photos",
2955                                "--list-options ","no-show-photos");
2956             deprecated_warning(configname,configlineno,"--no-show-photos",
2957                                "--verify-options ","no-show-photos");
2958             opt.list_options&=~LIST_SHOW_PHOTOS;
2959             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2960             break;
2961           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2962
2963           case oForceMDC: opt.force_mdc = 1; break;
2964           case oNoForceMDC: opt.force_mdc = 0; break;
2965           case oDisableMDC: opt.disable_mdc = 1; break;
2966           case oNoDisableMDC: opt.disable_mdc = 0; break;
2967
2968           case oDisableSignerUID: opt.flags.disable_signer_uid = 1; break;
2969
2970           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2971           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2972           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2973           case oS2KCount:
2974             if (pargs.r.ret_int)
2975               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2976             else
2977               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2978             break;
2979
2980           case oRecipient:
2981           case oHiddenRecipient:
2982           case oRecipientFile:
2983           case oHiddenRecipientFile:
2984             /* Store the recipient.  Note that we also store the
2985              * option as private data in the flags.  This is achieved
2986              * by shifting the option value to the left so to keep
2987              * enough space for the flags.  */
2988             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2989             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
2990             if (configfp)
2991               sl->flags |= PK_LIST_CONFIG;
2992             if (pargs.r_opt == oHiddenRecipient
2993                 || pargs.r_opt == oHiddenRecipientFile)
2994               sl->flags |= PK_LIST_HIDDEN;
2995             if (pargs.r_opt == oRecipientFile
2996                 || pargs.r_opt == oHiddenRecipientFile)
2997               sl->flags |= PK_LIST_FROM_FILE;
2998             any_explicit_recipient = 1;
2999             break;
3000
3001           case oEncryptTo:
3002           case oHiddenEncryptTo:
3003             /* Store an additional recipient.  */
3004             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
3005             sl->flags = ((pargs.r_opt << PK_LIST_SHIFT) | PK_LIST_ENCRYPT_TO);
3006             if (configfp)
3007               sl->flags |= PK_LIST_CONFIG;
3008             if (pargs.r_opt == oHiddenEncryptTo)
3009               sl->flags |= PK_LIST_HIDDEN;
3010             break;
3011
3012           case oNoEncryptTo:
3013             opt.no_encrypt_to = 1;
3014             break;
3015           case oEncryptToDefaultKey:
3016             opt.encrypt_to_default_key = configfp ? 2 : 1;
3017             break;
3018
3019           case oTrySecretKey:
3020             add_to_strlist2 (&opt.secret_keys_to_try,
3021                              pargs.r.ret_str, utf8_strings);
3022             break;
3023
3024           case oMimemode: opt.mimemode = opt.textmode = 1; break;
3025           case oTextmodeShort: opt.textmode = 2; break;
3026           case oTextmode: opt.textmode=1;  break;
3027           case oNoTextmode: opt.textmode=opt.mimemode=0;  break;
3028
3029           case oExpert: opt.expert = 1; break;
3030           case oNoExpert: opt.expert = 0; break;
3031           case oDefSigExpire:
3032             if(*pargs.r.ret_str!='\0')
3033               {
3034                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3035                   log_error(_("'%s' is not a valid signature expiration\n"),
3036                             pargs.r.ret_str);
3037                 else
3038                   opt.def_sig_expire=pargs.r.ret_str;
3039               }
3040             break;
3041           case oAskSigExpire: opt.ask_sig_expire = 1; break;
3042           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
3043           case oDefCertExpire:
3044             if(*pargs.r.ret_str!='\0')
3045               {
3046                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
3047                   log_error(_("'%s' is not a valid signature expiration\n"),
3048                             pargs.r.ret_str);
3049                 else
3050                   opt.def_cert_expire=pargs.r.ret_str;
3051               }
3052             break;
3053           case oAskCertExpire: opt.ask_cert_expire = 1; break;
3054           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
3055           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
3056           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
3057           case oAskCertLevel: opt.ask_cert_level = 1; break;
3058           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
3059           case oLocalUser: /* store the local users */
3060             sl = add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
3061             sl->flags = (pargs.r_opt << PK_LIST_SHIFT);
3062             if (configfp)
3063               sl->flags |= PK_LIST_CONFIG;
3064             break;
3065           case oSender:
3066             {
3067               char *mbox = mailbox_from_userid (pargs.r.ret_str);
3068               if (!mbox)
3069                 log_error (_("\"%s\" is not a proper mail address\n"),
3070                            pargs.r.ret_str);
3071               else
3072                 {
3073                   add_to_strlist (&opt.sender_list, mbox);
3074                   xfree (mbox);
3075                 }
3076             }
3077             break;
3078           case oCompress:
3079             /* this is the -z command line option */
3080             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
3081             break;
3082           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
3083           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
3084           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
3085           case oPassphrase:
3086             set_passphrase_from_string(pargs.r.ret_str);
3087             break;
3088           case oPassphraseFD:
3089             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3090             break;
3091           case oPassphraseFile:
3092             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
3093             break;
3094           case oPassphraseRepeat:
3095             opt.passphrase_repeat = pargs.r.ret_int;
3096             break;
3097
3098           case oPinentryMode:
3099             opt.pinentry_mode = parse_pinentry_mode (pargs.r.ret_str);
3100             if (opt.pinentry_mode == -1)
3101               log_error (_("invalid pinentry mode '%s'\n"), pargs.r.ret_str);
3102             break;
3103
3104           case oRequestOrigin:
3105             opt.request_origin = parse_request_origin (pargs.r.ret_str);
3106             if (opt.request_origin == -1)
3107               log_error (_("invalid request origin '%s'\n"), pargs.r.ret_str);
3108             break;
3109
3110           case oCommandFD:
3111             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3112             if (! gnupg_fd_valid (opt.command_fd))
3113               log_error ("command-fd is invalid: %s\n", strerror (errno));
3114             break;
3115           case oCommandFile:
3116             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
3117             break;
3118           case oCipherAlgo:
3119             def_cipher_string = xstrdup(pargs.r.ret_str);
3120             break;
3121           case oDigestAlgo:
3122             def_digest_string = xstrdup(pargs.r.ret_str);
3123             break;
3124           case oCompressAlgo:
3125             /* If it is all digits, stick a Z in front of it for
3126                later.  This is for backwards compatibility with
3127                versions that took the compress algorithm number. */
3128             {
3129               char *pt=pargs.r.ret_str;
3130               while(*pt)
3131                 {
3132                   if (!isascii (*pt) || !isdigit (*pt))
3133                     break;
3134
3135                   pt++;
3136                 }
3137
3138               if(*pt=='\0')
3139                 {
3140                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
3141                   strcpy(compress_algo_string,"Z");
3142                   strcat(compress_algo_string,pargs.r.ret_str);
3143                 }
3144               else
3145                 compress_algo_string = xstrdup(pargs.r.ret_str);
3146             }
3147             break;
3148           case oCertDigestAlgo:
3149             cert_digest_string = xstrdup(pargs.r.ret_str);
3150             break;
3151
3152           case oNoSecmemWarn:
3153             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
3154             break;
3155
3156           case oRequireSecmem: require_secmem=1; break;
3157           case oNoRequireSecmem: require_secmem=0; break;
3158           case oNoPermissionWarn: opt.no_perm_warn=1; break;
3159           case oNoMDCWarn: opt.no_mdc_warn=1; break;
3160           case oDisplayCharset:
3161             if( set_native_charset( pargs.r.ret_str ) )
3162                 log_error(_("'%s' is not a valid character set\n"),
3163                           pargs.r.ret_str);
3164             break;
3165           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
3166           case oEscapeFrom: opt.escape_from = 1; break;
3167           case oNoEscapeFrom: opt.escape_from = 0; break;
3168           case oLockOnce: opt.lock_once = 1; break;
3169           case oLockNever:
3170             dotlock_disable ();
3171             break;
3172           case oLockMultiple:
3173 #ifndef __riscos__
3174             opt.lock_once = 0;
3175 #else /* __riscos__ */
3176             riscos_not_implemented("lock-multiple");
3177 #endif /* __riscos__ */
3178             break;
3179           case oKeyServer:
3180             {
3181               keyserver_spec_t keyserver;
3182               keyserver = parse_keyserver_uri (pargs.r.ret_str, 0);
3183               if (!keyserver)
3184                 log_error (_("could not parse keyserver URL\n"));
3185               else
3186                 {
3187                   /* We only support a single keyserver.  Later ones
3188                      override earlier ones.  (Since we parse the
3189                      config file first and then the command line
3190                      arguments, the command line takes
3191                      precedence.)  */
3192                   if (opt.keyserver)
3193                     free_keyserver_spec (opt.keyserver);
3194                   opt.keyserver = keyserver;
3195                 }
3196             }
3197             break;
3198           case oKeyServerOptions:
3199             if(!parse_keyserver_options(pargs.r.ret_str))
3200               {
3201                 if(configname)
3202                   log_error(_("%s:%d: invalid keyserver options\n"),
3203                             configname,configlineno);
3204                 else
3205                   log_error(_("invalid keyserver options\n"));
3206               }
3207             break;
3208           case oImportOptions:
3209             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
3210               {
3211                 if(configname)
3212                   log_error(_("%s:%d: invalid import options\n"),
3213                             configname,configlineno);
3214                 else
3215                   log_error(_("invalid import options\n"));
3216               }
3217             break;
3218           case oImportFilter:
3219             rc = parse_and_set_import_filter (pargs.r.ret_str);
3220             if (rc)
3221               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3222             break;
3223           case oExportOptions:
3224             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
3225               {
3226                 if(configname)
3227                   log_error(_("%s:%d: invalid export options\n"),
3228                             configname,configlineno);
3229                 else
3230                   log_error(_("invalid export options\n"));
3231               }
3232             break;
3233           case oExportFilter:
3234             rc = parse_and_set_export_filter (pargs.r.ret_str);
3235             if (rc)
3236               log_error (_("invalid filter option: %s\n"), gpg_strerror (rc));
3237             break;
3238           case oListOptions:
3239             if(!parse_list_options(pargs.r.ret_str))
3240               {
3241                 if(configname)
3242                   log_error(_("%s:%d: invalid list options\n"),
3243                             configname,configlineno);
3244                 else
3245                   log_error(_("invalid list options\n"));
3246               }
3247             break;
3248           case oVerifyOptions:
3249             {
3250               struct parse_options vopts[]=
3251                 {
3252                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
3253                    N_("display photo IDs during signature verification")},
3254                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
3255                    N_("show policy URLs during signature verification")},
3256                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
3257                    N_("show all notations during signature verification")},
3258                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3259                    N_("show IETF standard notations during signature verification")},
3260                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
3261                    NULL},
3262                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
3263                    N_("show user-supplied notations during signature verification")},
3264                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
3265                    N_("show preferred keyserver URLs during signature verification")},
3266                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
3267                    N_("show user ID validity during signature verification")},
3268                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
3269                    N_("show revoked and expired user IDs in signature verification")},
3270                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
3271                    N_("show only the primary user ID in signature verification")},
3272                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
3273                    N_("validate signatures with PKA data")},
3274                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
3275                    N_("elevate the trust of signatures with valid PKA data")},
3276                   {NULL,0,NULL,NULL}
3277                 };
3278
3279               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
3280                 {
3281                   if(configname)
3282                     log_error(_("%s:%d: invalid verify options\n"),
3283                               configname,configlineno);
3284                   else
3285                     log_error(_("invalid verify options\n"));
3286                 }
3287             }
3288             break;
3289           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
3290           case oExecPath:
3291             if(set_exec_path(pargs.r.ret_str))
3292               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
3293             else
3294               opt.exec_path_set=1;
3295             break;
3296           case oSetNotation:
3297             add_notation_data( pargs.r.ret_str, 0 );
3298             add_notation_data( pargs.r.ret_str, 1 );
3299             break;
3300           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
3301           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
3302           case oShowNotation:
3303             deprecated_warning(configname,configlineno,"--show-notation",
3304                                "--list-options ","show-notations");
3305             deprecated_warning(configname,configlineno,"--show-notation",
3306                                "--verify-options ","show-notations");
3307             opt.list_options|=LIST_SHOW_NOTATIONS;
3308             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
3309             break;
3310           case oNoShowNotation:
3311             deprecated_warning(configname,configlineno,"--no-show-notation",
3312                                "--list-options ","no-show-notations");
3313             deprecated_warning(configname,configlineno,"--no-show-notation",
3314                                "--verify-options ","no-show-notations");
3315             opt.list_options&=~LIST_SHOW_NOTATIONS;
3316             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
3317             break;
3318           case oUtf8Strings: utf8_strings = 1; break;
3319           case oNoUtf8Strings: utf8_strings = 0; break;
3320           case oDisableCipherAlgo:
3321             {
3322               int algo = string_to_cipher_algo (pargs.r.ret_str);
3323               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3324             }
3325             break;
3326           case oDisablePubkeyAlgo:
3327             {
3328               int algo = gcry_pk_map_name (pargs.r.ret_str);
3329               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
3330             }
3331             break;
3332           case oNoSigCache: opt.no_sig_cache = 1; break;
3333           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
3334           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
3335           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
3336           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
3337           case oNoLiteral: opt.no_literal = 1; break;
3338           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
3339           case oFastListMode: opt.fast_list_mode = 1; break;
3340           case oFixedListMode: /* Dummy */ break;
3341           case oLegacyListMode: opt.legacy_list_mode = 1; break;
3342           case oPrintPKARecords: print_pka_records = 1; break;
3343           case oPrintDANERecords: print_dane_records = 1; break;
3344           case oListOnly: opt.list_only=1; break;
3345           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
3346           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
3347           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
3348           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
3349           case oNoRandomSeedFile: use_random_seed = 0; break;
3350
3351           case oAutoKeyRetrieve:
3352             opt.keyserver_options.options |= KEYSERVER_AUTO_KEY_RETRIEVE;
3353             break;
3354           case oNoAutoKeyRetrieve:
3355             opt.keyserver_options.options &= ~KEYSERVER_AUTO_KEY_RETRIEVE;
3356             break;
3357
3358           case oShowSessionKey: opt.show_session_key = 1; break;
3359           case oOverrideSessionKey:
3360                 opt.override_session_key = pargs.r.ret_str;
3361                 break;
3362           case oOverrideSessionKeyFD:
3363                 ovrseskeyfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
3364                 break;
3365           case oMergeOnly:
3366                 deprecated_warning(configname,configlineno,"--merge-only",
3367                                    "--import-options ","merge-only");
3368                 opt.import_options|=IMPORT_MERGE_ONLY;
3369             break;
3370           case oAllowSecretKeyImport: /* obsolete */ break;
3371           case oTryAllSecrets: opt.try_all_secrets = 1; break;
3372           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
3373
3374           case oEnableSpecialFilenames:
3375             enable_special_filenames ();
3376             break;
3377
3378           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
3379           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
3380           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
3381           case oPreservePermissions: opt.preserve_permissions=1; break;
3382           case oDefaultPreferenceList:
3383             opt.def_preference_list = pargs.r.ret_str;
3384             break;
3385           case oDefaultKeyserverURL:
3386             {
3387               keyserver_spec_t keyserver;
3388               keyserver = parse_keyserver_uri (pargs.r.ret_str,1 );
3389               if (!keyserver)
3390                 log_error (_("could not parse keyserver URL\n"));
3391               else
3392                 free_keyserver_spec (keyserver);
3393
3394               opt.def_keyserver_url = pargs.r.ret_str;
3395             }
3396             break;
3397           case oPersonalCipherPreferences:
3398             pers_cipher_list=pargs.r.ret_str;
3399             break;
3400           case oPersonalDigestPreferences:
3401             pers_digest_list=pargs.r.ret_str;
3402             break;
3403           case oPersonalCompressPreferences:
3404             pers_compress_list=pargs.r.ret_str;
3405             break;
3406           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
3407           case oDirmngrProgram: opt.dirmngr_program = pargs.r.ret_str; break;
3408           case oDisableDirmngr: opt.disable_dirmngr = 1;  break;
3409           case oWeakDigest:
3410             additional_weak_digest(pargs.r.ret_str);
3411             break;
3412           case oUnwrap:
3413             opt.unwrap_encryption = 1;
3414             break;
3415           case oOnlySignTextIDs:
3416             opt.only_sign_text_ids = 1;
3417             break;
3418
3419           case oDisplay:
3420             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
3421             break;
3422           case oTTYname:
3423             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
3424             break;
3425           case oTTYtype:
3426             set_opt_session_env ("TERM", pargs.r.ret_str);
3427             break;
3428           case oXauthority:
3429             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
3430             break;
3431
3432           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
3433           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
3434
3435           case oGroup: add_group(pargs.r.ret_str); break;
3436           case oUnGroup: rm_group(pargs.r.ret_str); break;
3437           case oNoGroups:
3438             while(opt.grouplist)
3439               {
3440                 struct groupitem *iter=opt.grouplist;
3441                 free_strlist(iter->values);
3442                 opt.grouplist=opt.grouplist->next;
3443                 xfree(iter);
3444               }
3445             break;
3446
3447           case oStrict:
3448           case oNoStrict:
3449             /* Not used */
3450             break;
3451
3452           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
3453           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
3454           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
3455           case oMultifile: multifile=1; break;
3456           case oKeyidFormat:
3457             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
3458               opt.keyid_format=KF_SHORT;
3459             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
3460               opt.keyid_format=KF_LONG;
3461             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
3462               opt.keyid_format=KF_0xSHORT;
3463             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
3464               opt.keyid_format=KF_0xLONG;
3465             else if(ascii_strcasecmp(pargs.r.ret_str,"none")==0)
3466               opt.keyid_format = KF_NONE;
3467             else
3468               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
3469             break;
3470
3471           case oExitOnStatusWriteError:
3472             opt.exit_on_status_write_error = 1;
3473             break;
3474
3475           case oLimitCardInsertTries:
3476             opt.limit_card_insert_tries = pargs.r.ret_int;
3477             break;
3478
3479           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
3480           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
3481
3482           case oAutoKeyLocate:
3483             if (default_akl)
3484               {
3485                 /* This is the first time --aito-key-locate is seen.
3486                  * We need to reset the default akl.  */
3487                 default_akl = 0;
3488                 release_akl();
3489               }
3490             if(!parse_auto_key_locate(pargs.r.ret_str))
3491               {
3492                 if(configname)
3493                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
3494                             configname,configlineno);
3495                 else
3496                   log_error(_("invalid auto-key-locate list\n"));
3497               }
3498             break;
3499           case oNoAutoKeyLocate:
3500             release_akl();
3501             break;
3502
3503           case oKeyOrigin:
3504             if(!parse_key_origin (pargs.r.ret_str))
3505               log_error (_("invalid argument for option \"%.50s\"\n"),
3506                          "--key-origin");
3507             break;
3508
3509           case oEnableLargeRSA:
3510 #if SECMEM_BUFFER_SIZE >= 65536
3511             opt.flags.large_rsa=1;
3512 #else
3513             if (configname)
3514               log_info("%s:%d: WARNING: gpg not built with large secure "
3515                          "memory buffer.  Ignoring enable-large-rsa\n",
3516                         configname,configlineno);
3517             else
3518               log_info("WARNING: gpg not built with large secure "
3519                          "memory buffer.  Ignoring --enable-large-rsa\n");
3520 #endif /* SECMEM_BUFFER_SIZE >= 65536 */
3521             break;
3522           case oDisableLargeRSA: opt.flags.large_rsa=0;
3523             break;
3524
3525           case oEnableDSA2: opt.flags.dsa2=1; break;
3526           case oDisableDSA2: opt.flags.dsa2=0; break;
3527
3528           case oAllowMultisigVerification:
3529           case oAllowMultipleMessages:
3530             opt.flags.allow_multiple_messages=1;
3531             break;
3532
3533           case oNoAllowMultipleMessages:
3534             opt.flags.allow_multiple_messages=0;
3535             break;
3536
3537           case oAllowWeakDigestAlgos:
3538             opt.flags.allow_weak_digest_algos = 1;
3539             break;
3540
3541           case oFakedSystemTime:
3542             {
3543               size_t len = strlen (pargs.r.ret_str);
3544               int freeze = 0;
3545               time_t faked_time;
3546
3547               if (len > 0 && pargs.r.ret_str[len-1] == '!')
3548                 {
3549                   freeze = 1;
3550                   pargs.r.ret_str[len-1] = '\0';
3551                 }
3552
3553               faked_time = isotime2epoch (pargs.r.ret_str);
3554               if (faked_time == (time_t)(-1))
3555                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
3556               gnupg_set_time (faked_time, freeze);
3557             }
3558             break;
3559
3560           case oNoAutostart: opt.autostart = 0; break;
3561           case oNoSymkeyCache: opt.no_symkey_cache = 1; break;
3562
3563           case oDefaultNewKeyAlgo:
3564             opt.def_new_key_algo = pargs.r.ret_str;
3565             break;
3566
3567           case oNoop: break;
3568
3569           default:
3570             if (configfp)
3571               pargs.err = ARGPARSE_PRINT_WARNING;
3572             else
3573               {
3574                 pargs.err = ARGPARSE_PRINT_ERROR;
3575                 /* The argparse fucntion calls a plain exit and thus
3576                  * we need to print a status here.  */
3577                 write_status_failure ("option-parser",
3578                                       gpg_error(GPG_ERR_GENERAL));
3579               }
3580             break;
3581           }
3582       }
3583
3584     if (configfp)
3585       {
3586         fclose( configfp );
3587         configfp = NULL;
3588         /* Remember the first config file name. */
3589         if (!save_configname)
3590           save_configname = configname;
3591         else
3592           xfree(configname);
3593         configname = NULL;
3594         goto next_pass;
3595       }
3596     xfree(configname); configname = NULL;
3597     if (log_get_errorcount (0))
3598       {
3599         write_status_failure ("option-parser", gpg_error(GPG_ERR_GENERAL));
3600         g10_exit(2);
3601       }
3602
3603     /* The command --gpgconf-list is pretty simple and may be called
3604        directly after the option parsing. */
3605     if (cmd == aGPGConfList)
3606       {
3607         gpgconf_list (save_configname ? save_configname : default_configname);
3608         g10_exit (0);
3609       }
3610     xfree (save_configname);
3611     xfree (default_configname);
3612
3613     if (print_dane_records)
3614       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3615                  "--print-dane-records",
3616                  "--export-options export-dane");
3617     if (print_pka_records)
3618       log_error ("invalid option \"%s\"; use \"%s\" instead\n",
3619                  "--print-pks-records",
3620                  "--export-options export-pka");
3621     if (log_get_errorcount (0))
3622       {
3623         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
3624         g10_exit(2);
3625       }
3626
3627
3628     if( nogreeting )
3629         greeting = 0;
3630
3631     if( greeting )
3632       {
3633         es_fprintf (es_stderr, "%s %s; %s\n",
3634                     strusage(11), strusage(13), strusage(14) );
3635         es_fprintf (es_stderr, "%s\n", strusage(15) );
3636       }
3637 #ifdef IS_DEVELOPMENT_VERSION
3638     if (!opt.batch)
3639       {
3640         const char *s;
3641
3642         if((s=strusage(25)))
3643           log_info("%s\n",s);
3644         if((s=strusage(26)))
3645           log_info("%s\n",s);
3646         if((s=strusage(27)))
3647           log_info("%s\n",s);
3648       }
3649 #endif
3650
3651     /* FIXME: We should use logging to a file only in server mode;
3652        however we have not yet implemetyed that.  Thus we try to get
3653        away with --batch as indication for logging to file
3654        required. */
3655     if (logfile && opt.batch)
3656       {
3657         log_set_file (logfile);
3658         log_set_prefix (NULL, GPGRT_LOG_WITH_PREFIX | GPGRT_LOG_WITH_TIME | GPGRT_LOG_WITH_PID);
3659       }
3660
3661     if (opt.verbose > 2)
3662         log_info ("using character set '%s'\n", get_native_charset ());
3663
3664     if( may_coredump && !opt.quiet )
3665         log_info(_("WARNING: program may create a core file!\n"));
3666
3667     if (opt.flags.rfc4880bis)
3668         log_info ("WARNING: using experimental features from RFC4880bis!\n");
3669     else
3670       {
3671         opt.mimemode = 0; /* This will use text mode instead.  */
3672       }
3673
3674     if (eyes_only) {
3675       if (opt.set_filename)
3676           log_info(_("WARNING: %s overrides %s\n"),
3677                    "--for-your-eyes-only","--set-filename");
3678
3679       opt.set_filename="_CONSOLE";
3680     }
3681
3682     if (opt.no_literal) {
3683         log_info(_("Note: %s is not for normal use!\n"), "--no-literal");
3684         if (opt.textmode)
3685             log_error(_("%s not allowed with %s!\n"),
3686                        "--textmode", "--no-literal" );
3687         if (opt.set_filename)
3688             log_error(_("%s makes no sense with %s!\n"),
3689                         eyes_only?"--for-your-eyes-only":"--set-filename",
3690                         "--no-literal" );
3691     }
3692
3693
3694     if (opt.set_filesize)
3695         log_info(_("Note: %s is not for normal use!\n"), "--set-filesize");
3696     if( opt.batch )
3697         tty_batchmode( 1 );
3698
3699     if (gnupg_faked_time_p ())
3700       {
3701         gnupg_isotime_t tbuf;
3702
3703         log_info (_("WARNING: running with faked system time: "));
3704         gnupg_get_isotime (tbuf);
3705         dump_isotime (tbuf);
3706         log_printf ("\n");
3707       }
3708
3709     /* Print a warning if an argument looks like an option.  */
3710     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3711       {
3712         int i;
3713
3714         for (i=0; i < argc; i++)
3715           if (argv[i][0] == '-' && argv[i][1] == '-')
3716             log_info (_("Note: '%s' is not considered an option\n"), argv[i]);
3717       }
3718
3719
3720     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3721
3722     if(require_secmem && !got_secmem)
3723       {
3724         log_info(_("will not run with insecure memory due to %s\n"),
3725                  "--require-secmem");
3726         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
3727         g10_exit(2);
3728       }
3729
3730     set_debug (debug_level);
3731     if (DBG_CLOCK)
3732       log_clock ("start");
3733
3734     /* Do these after the switch(), so they can override settings. */
3735     if(PGP6)
3736       {
3737         /* That does not anymore work because we have no more support
3738            for v3 signatures.  */
3739         opt.disable_mdc=1;
3740         opt.escape_from=1;
3741         opt.ask_sig_expire=0;
3742       }
3743     else if(PGP7)
3744       {
3745         /* That does not anymore work because we have no more support
3746            for v3 signatures.  */
3747         opt.escape_from=1;
3748         opt.ask_sig_expire=0;
3749       }
3750     else if(PGP8)
3751       {
3752         opt.escape_from=1;
3753       }
3754
3755
3756     if( def_cipher_string ) {
3757         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3758         xfree(def_cipher_string); def_cipher_string = NULL;
3759         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3760             log_error(_("selected cipher algorithm is invalid\n"));
3761     }
3762     if( def_digest_string ) {
3763         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3764         xfree(def_digest_string); def_digest_string = NULL;
3765         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3766             log_error(_("selected digest algorithm is invalid\n"));
3767     }
3768     if( compress_algo_string ) {
3769         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3770         xfree(compress_algo_string); compress_algo_string = NULL;
3771         if( check_compress_algo(opt.compress_algo) )
3772           log_error(_("selected compression algorithm is invalid\n"));
3773     }
3774     if( cert_digest_string ) {
3775         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3776         xfree(cert_digest_string); cert_digest_string = NULL;
3777         if (openpgp_md_test_algo(opt.cert_digest_algo))
3778           log_error(_("selected certification digest algorithm is invalid\n"));
3779     }
3780     if( s2k_cipher_string ) {
3781         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3782         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3783         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3784           log_error(_("selected cipher algorithm is invalid\n"));
3785     }
3786     if( s2k_digest_string ) {
3787         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3788         xfree(s2k_digest_string); s2k_digest_string = NULL;
3789         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3790           log_error(_("selected digest algorithm is invalid\n"));
3791     }
3792     if( opt.completes_needed < 1 )
3793       log_error(_("completes-needed must be greater than 0\n"));
3794     if( opt.marginals_needed < 2 )
3795       log_error(_("marginals-needed must be greater than 1\n"));
3796     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3797       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3798     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3799       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3800     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3801       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3802     switch( opt.s2k_mode ) {
3803       case 0:
3804         log_info(_("Note: simple S2K mode (0) is strongly discouraged\n"));
3805         break;
3806       case 1: case 3: break;
3807       default:
3808         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3809     }
3810
3811     /* This isn't actually needed, but does serve to error out if the
3812        string is invalid. */
3813     if(opt.def_preference_list &&
3814         keygen_set_std_prefs(opt.def_preference_list,0))
3815       log_error(_("invalid default preferences\n"));
3816
3817     if(pers_cipher_list &&
3818        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3819       log_error(_("invalid personal cipher preferences\n"));
3820
3821     if(pers_digest_list &&
3822        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3823       log_error(_("invalid personal digest preferences\n"));
3824
3825     if(pers_compress_list &&
3826        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3827       log_error(_("invalid personal compress preferences\n"));
3828
3829     /* We don't support all possible commands with multifile yet */
3830     if(multifile)
3831       {
3832         char *cmdname;
3833
3834         switch(cmd)
3835           {
3836           case aSign:
3837             cmdname="--sign";
3838             break;
3839           case aSignEncr:
3840             cmdname="--sign --encrypt";
3841             break;
3842           case aClearsign:
3843             cmdname="--clear-sign";
3844             break;
3845           case aDetachedSign:
3846             cmdname="--detach-sign";
3847             break;
3848           case aSym:
3849             cmdname="--symmetric";
3850             break;
3851           case aEncrSym:
3852             cmdname="--symmetric --encrypt";
3853             break;
3854           case aStore:
3855             cmdname="--store";
3856             break;
3857           default:
3858             cmdname=NULL;
3859             break;
3860           }
3861
3862         if(cmdname)
3863           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3864       }
3865
3866     if( log_get_errorcount(0) )
3867       {
3868         write_status_failure ("option-postprocessing",
3869                               gpg_error(GPG_ERR_GENERAL));
3870         g10_exit (2);
3871       }
3872
3873     if(opt.compress_level==0)
3874       opt.compress_algo=COMPRESS_ALGO_NONE;
3875
3876     /* Check our chosen algorithms against the list of legal
3877        algorithms. */
3878
3879     if(!GNUPG)
3880       {
3881         const char *badalg=NULL;
3882         preftype_t badtype=PREFTYPE_NONE;
3883
3884         if(opt.def_cipher_algo
3885            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3886           {
3887             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3888             badtype = PREFTYPE_SYM;
3889           }
3890         else if(opt.def_digest_algo
3891                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3892           {
3893             badalg = gcry_md_algo_name (opt.def_digest_algo);
3894             badtype = PREFTYPE_HASH;
3895           }
3896         else if(opt.cert_digest_algo
3897                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3898           {
3899             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3900             badtype = PREFTYPE_HASH;
3901           }
3902         else if(opt.compress_algo!=-1
3903                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3904           {
3905             badalg = compress_algo_to_string(opt.compress_algo);
3906             badtype = PREFTYPE_ZIP;
3907           }
3908
3909         if(badalg)
3910           {
3911             switch(badtype)
3912               {
3913               case PREFTYPE_SYM:
3914                 log_info (_("cipher algorithm '%s'"
3915                             " may not be used in %s mode\n"),
3916                          badalg,
3917                           gnupg_compliance_option_string (opt.compliance));
3918                 break;
3919               case PREFTYPE_HASH:
3920                 log_info (_("digest algorithm '%s'"
3921                             " may not be used in %s mode\n"),
3922                           badalg,
3923                           gnupg_compliance_option_string (opt.compliance));
3924                 break;
3925               case PREFTYPE_ZIP:
3926                 log_info (_("compression algorithm '%s'"
3927                             " may not be used in %s mode\n"),
3928                           badalg,
3929                           gnupg_compliance_option_string (opt.compliance));
3930                 break;
3931               default:
3932                 BUG();
3933               }
3934
3935             compliance_failure();
3936           }
3937       }
3938
3939     /* Check our chosen algorithms against the list of allowed
3940      * algorithms in the current compliance mode, and fail hard if it
3941      * is not.  This is us being nice to the user informing her early
3942      * that the chosen algorithms are not available.  We also check
3943      * and enforce this right before the actual operation.  */
3944     if (opt.def_cipher_algo
3945         && ! gnupg_cipher_is_allowed (opt.compliance,
3946                                       cmd == aEncr
3947                                       || cmd == aSignEncr
3948                                       || cmd == aEncrSym
3949                                       || cmd == aSym
3950                                       || cmd == aSignSym
3951                                       || cmd == aSignEncrSym,
3952                                       opt.def_cipher_algo,
3953                                       GCRY_CIPHER_MODE_NONE))
3954       log_error (_("cipher algorithm '%s' may not be used in %s mode\n"),
3955                  openpgp_cipher_algo_name (opt.def_cipher_algo),
3956                  gnupg_compliance_option_string (opt.compliance));
3957
3958     if (opt.def_digest_algo
3959         && ! gnupg_digest_is_allowed (opt.compliance,
3960                                       cmd == aSign
3961                                       || cmd == aSignEncr
3962                                       || cmd == aSignEncrSym
3963                                       || cmd == aSignSym
3964                                       || cmd == aClearsign,
3965                                       opt.def_digest_algo))
3966       log_error (_("digest algorithm '%s' may not be used in %s mode\n"),
3967                  gcry_md_algo_name (opt.def_digest_algo),
3968                  gnupg_compliance_option_string (opt.compliance));
3969
3970     /* Fail hard.  */
3971     if (log_get_errorcount (0))
3972       {
3973         write_status_failure ("option-checking", gpg_error(GPG_ERR_GENERAL));
3974         g10_exit (2);
3975       }
3976
3977     /* Set the random seed file. */
3978     if( use_random_seed ) {
3979       char *p = make_filename (gnupg_homedir (), "random_seed", NULL );
3980         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3981         if (!access (p, F_OK))
3982           register_secured_file (p);
3983         xfree(p);
3984     }
3985
3986     /* If there is no command but the --fingerprint is given, default
3987        to the --list-keys command.  */
3988     if (!cmd && fpr_maybe_cmd)
3989       {
3990         set_cmd (&cmd, aListKeys);
3991       }
3992
3993
3994     if( opt.verbose > 1 )
3995         set_packet_list_mode(1);
3996
3997     /* Add the keyrings, but not for some special commands.  We always
3998      * need to add the keyrings if we are running under SELinux, this
3999      * is so that the rings are added to the list of secured files.
4000      * We do not add any keyring if --no-keyring has been used.  */
4001     if (default_keyring >= 0
4002         && (ALWAYS_ADD_KEYRINGS
4003             || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest)))
4004       {
4005         if (!nrings || default_keyring > 0)  /* Add default ring. */
4006             keydb_add_resource ("pubring" EXTSEP_S GPGEXT_GPG,
4007                                 KEYDB_RESOURCE_FLAG_DEFAULT);
4008         for (sl = nrings; sl; sl = sl->next )
4009           keydb_add_resource (sl->d, sl->flags);
4010       }
4011     FREE_STRLIST(nrings);
4012
4013     if (opt.pinentry_mode == PINENTRY_MODE_LOOPBACK)
4014       /* In loopback mode, never ask for the password multiple
4015          times.  */
4016       {
4017         opt.passphrase_repeat = 0;
4018       }
4019
4020     if (cmd == aGPGConfTest)
4021       g10_exit(0);
4022
4023
4024     if (pwfd != -1)  /* Read the passphrase now. */
4025       read_passphrase_from_fd (pwfd);
4026
4027     if (ovrseskeyfd != -1 )  /* Read the sessionkey now. */
4028       read_sessionkey_from_fd (ovrseskeyfd);
4029
4030     fname = argc? *argv : NULL;
4031
4032     if(fname && utf8_strings)
4033       opt.flags.utf8_filename=1;
4034
4035     ctrl = xcalloc (1, sizeof *ctrl);
4036     gpg_init_default_ctrl (ctrl);
4037
4038 #ifndef NO_TRUST_MODELS
4039     switch (cmd)
4040       {
4041       case aPrimegen:
4042       case aPrintMD:
4043       case aPrintMDs:
4044       case aGenRandom:
4045       case aDeArmor:
4046       case aEnArmor:
4047       case aListConfig:
4048       case aListGcryptConfig:
4049         break;
4050       case aFixTrustDB:
4051       case aExportOwnerTrust:
4052         rc = setup_trustdb (0, trustdb_name);
4053         break;
4054       case aListTrustDB:
4055         rc = setup_trustdb (argc? 1:0, trustdb_name);
4056         break;
4057       case aKeygen:
4058       case aFullKeygen:
4059       case aQuickKeygen:
4060         rc = setup_trustdb (1, trustdb_name);
4061         break;
4062       default:
4063         /* If we are using TM_ALWAYS, we do not need to create the
4064            trustdb.  */
4065         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
4066         break;
4067       }
4068     if (rc)
4069       log_error (_("failed to initialize the TrustDB: %s\n"),
4070                  gpg_strerror (rc));
4071 #endif /*!NO_TRUST_MODELS*/
4072
4073     switch (cmd)
4074       {
4075       case aStore:
4076       case aSym:
4077       case aSign:
4078       case aSignSym:
4079       case aClearsign:
4080         if (!opt.quiet && any_explicit_recipient)
4081           log_info (_("WARNING: recipients (-r) given "
4082                       "without using public key encryption\n"));
4083         break;
4084       default:
4085         break;
4086       }
4087
4088
4089     /* Check for certain command whether we need to migrate a
4090        secring.gpg to the gpg-agent. */
4091     switch (cmd)
4092       {
4093       case aListSecretKeys:
4094       case aSign:
4095       case aSignEncr:
4096       case aSignEncrSym:
4097       case aSignSym:
4098       case aClearsign:
4099       case aDecrypt:
4100       case aSignKey:
4101       case aLSignKey:
4102       case aEditKey:
4103       case aPasswd:
4104       case aDeleteSecretKeys:
4105       case aDeleteSecretAndPublicKeys:
4106       case aQuickKeygen:
4107       case aQuickAddUid:
4108       case aQuickAddKey:
4109       case aQuickRevUid:
4110       case aQuickSetPrimaryUid:
4111       case aFullKeygen:
4112       case aKeygen:
4113       case aImport:
4114       case aExportSecret:
4115       case aExportSecretSub:
4116       case aGenRevoke:
4117       case aDesigRevoke:
4118       case aCardEdit:
4119       case aChangePIN:
4120         migrate_secring (ctrl);
4121         break;
4122       case aListKeys:
4123         if (opt.with_secret)
4124           migrate_secring (ctrl);
4125         break;
4126       default:
4127         break;
4128       }
4129
4130     /* The command dispatcher.  */
4131     switch( cmd )
4132       {
4133       case aServer:
4134         gpg_server (ctrl);
4135         break;
4136
4137       case aStore: /* only store the file */
4138         if( argc > 1 )
4139             wrong_args("--store [filename]");
4140         if( (rc = encrypt_store(fname)) )
4141           {
4142             write_status_failure ("store", rc);
4143             log_error ("storing '%s' failed: %s\n",
4144                        print_fname_stdin(fname),gpg_strerror (rc) );
4145           }
4146         break;
4147       case aSym: /* encrypt the given file only with the symmetric cipher */
4148         if( argc > 1 )
4149             wrong_args("--symmetric [filename]");
4150         if( (rc = encrypt_symmetric(fname)) )
4151           {
4152             write_status_failure ("symencrypt", rc);
4153             log_error (_("symmetric encryption of '%s' failed: %s\n"),
4154                         print_fname_stdin(fname),gpg_strerror (rc) );
4155           }
4156         break;
4157
4158       case aEncr: /* encrypt the given file */
4159         if(multifile)
4160           encrypt_crypt_files (ctrl, argc, argv, remusr);
4161         else
4162           {
4163             if( argc > 1 )
4164               wrong_args("--encrypt [filename]");
4165             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
4166               {
4167                 write_status_failure ("encrypt", rc);
4168                 log_error("%s: encryption failed: %s\n",
4169                           print_fname_stdin(fname), gpg_strerror (rc) );
4170               }
4171           }
4172         break;
4173
4174       case aEncrSym:
4175         /* This works with PGP 8 in the sense that it acts just like a
4176            symmetric message.  It doesn't work at all with 2 or 6.  It
4177            might work with 7, but alas, I don't have a copy to test
4178            with right now. */
4179         if( argc > 1 )
4180           wrong_args("--symmetric --encrypt [filename]");
4181         else if(opt.s2k_mode==0)
4182           log_error(_("you cannot use --symmetric --encrypt"
4183                       " with --s2k-mode 0\n"));
4184         else if(PGP6 || PGP7)
4185           log_error(_("you cannot use --symmetric --encrypt"
4186                       " in %s mode\n"),
4187                     gnupg_compliance_option_string (opt.compliance));
4188         else
4189           {
4190             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
4191               {
4192                 write_status_failure ("encrypt", rc);