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