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