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