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