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