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