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