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