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