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