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