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