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