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