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