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