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