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