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