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