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