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