gpg: Graceful skip reading of corrupt MPIs.
[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     opt.emit_version = 1; /* Limit to the major number.  */
2004
2005
2006     /* Check whether we have a config file on the command line.  */
2007     orig_argc = argc;
2008     orig_argv = argv;
2009     pargs.argc = &argc;
2010     pargs.argv = &argv;
2011     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
2012     while( arg_parse( &pargs, opts) ) {
2013         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2014             parse_debug++;
2015         else if( pargs.r_opt == oOptions ) {
2016             /* yes there is one, so we do not try the default one, but
2017              * read the option file when it is encountered at the commandline
2018              */
2019             default_config = 0;
2020         }
2021         else if( pargs.r_opt == oNoOptions )
2022           {
2023             default_config = 0; /* --no-options */
2024             opt.no_homedir_creation = 1;
2025           }
2026         else if( pargs.r_opt == oHomedir )
2027             set_homedir ( pargs.r.ret_str );
2028         else if( pargs.r_opt == oNoPermissionWarn )
2029             opt.no_perm_warn=1;
2030         else if (pargs.r_opt == oStrict )
2031           {
2032             /* Not used */
2033           }
2034         else if (pargs.r_opt == oNoStrict )
2035           {
2036             /* Not used */
2037           }
2038     }
2039
2040 #ifdef HAVE_DOSISH_SYSTEM
2041     if ( strchr (opt.homedir,'\\') ) {
2042         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2043         const char *s = opt.homedir;
2044         for (d=buf,s=opt.homedir; *s; s++)
2045           {
2046             *d++ = *s == '\\'? '/': *s;
2047 #ifdef HAVE_W32_SYSTEM
2048             if (s[1] && IsDBCSLeadByte (*s))
2049               *d++ = *++s;
2050 #endif
2051           }
2052         *d = 0;
2053         set_homedir (buf);
2054     }
2055 #endif
2056
2057     /* Initialize the secure memory. */
2058     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
2059       got_secmem = 1;
2060 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2061     /* There should be no way to get to this spot while still carrying
2062        setuid privs.  Just in case, bomb out if we are. */
2063     if ( getuid () != geteuid () )
2064       BUG ();
2065 #endif
2066     maybe_setuid = 0;
2067
2068     /* Okay, we are now working under our real uid */
2069
2070     /* malloc hooks go here ... */
2071     malloc_hooks.malloc = gcry_malloc;
2072     malloc_hooks.realloc = gcry_realloc;
2073     malloc_hooks.free = gcry_free;
2074     assuan_set_malloc_hooks (&malloc_hooks);
2075     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2076
2077
2078     /* Try for a version specific config file first */
2079     default_configname = get_default_configname ();
2080     if (default_config)
2081       configname = xstrdup (default_configname);
2082
2083     argc = orig_argc;
2084     argv = orig_argv;
2085     pargs.argc = &argc;
2086     pargs.argv = &argv;
2087     pargs.flags=  1;  /* do not remove the args */
2088
2089     /* By this point we have a homedir, and cannot change it. */
2090     check_permissions(opt.homedir,0);
2091
2092   next_pass:
2093     if( configname ) {
2094       if(check_permissions(configname,1))
2095         {
2096           /* If any options file is unsafe, then disable any external
2097              programs for keyserver calls or photo IDs.  Since the
2098              external program to call is set in the options file, a
2099              unsafe options file can lead to an arbitrary program
2100              being run. */
2101
2102           opt.exec_disable=1;
2103         }
2104
2105         configlineno = 0;
2106         configfp = fopen( configname, "r" );
2107         if (configfp && is_secured_file (fileno (configfp)))
2108           {
2109             fclose (configfp);
2110             configfp = NULL;
2111             errno = EPERM;
2112           }
2113         if( !configfp ) {
2114             if( default_config ) {
2115                 if( parse_debug )
2116                     log_info(_("NOTE: no default option file `%s'\n"),
2117                                                             configname );
2118             }
2119             else {
2120                 log_error(_("option file `%s': %s\n"),
2121                                     configname, strerror(errno) );
2122                 g10_exit(2);
2123             }
2124             xfree(configname); configname = NULL;
2125         }
2126         if( parse_debug && configname )
2127             log_info(_("reading options from `%s'\n"), configname );
2128         default_config = 0;
2129     }
2130
2131     while( optfile_parse( configfp, configname, &configlineno,
2132                                                 &pargs, opts) )
2133       {
2134         switch( pargs.r_opt )
2135           {
2136           case aCheckKeys:
2137           case aListConfig:
2138           case aGPGConfList:
2139           case aGPGConfTest:
2140           case aListPackets:
2141           case aImport:
2142           case aFastImport:
2143           case aSendKeys:
2144           case aRecvKeys:
2145           case aSearchKeys:
2146           case aRefreshKeys:
2147           case aFetchKeys:
2148           case aExport:
2149 #ifdef ENABLE_CARD_SUPPORT
2150           case aCardStatus:
2151           case aCardEdit:
2152           case aChangePIN:
2153 #endif /* ENABLE_CARD_SUPPORT*/
2154           case aListKeys:
2155           case aLocateKeys:
2156           case aListSigs:
2157           case aExportSecret:
2158           case aExportSecretSub:
2159           case aSym:
2160           case aClearsign:
2161           case aGenRevoke:
2162           case aDesigRevoke:
2163           case aPrimegen:
2164           case aGenRandom:
2165           case aPrintMD:
2166           case aPrintMDs:
2167           case aListTrustDB:
2168           case aCheckTrustDB:
2169           case aUpdateTrustDB:
2170           case aFixTrustDB:
2171           case aListTrustPath:
2172           case aDeArmor:
2173           case aEnArmor:
2174           case aSign:
2175           case aSignKey:
2176           case aLSignKey:
2177           case aStore:
2178           case aExportOwnerTrust:
2179           case aImportOwnerTrust:
2180           case aRebuildKeydbCaches:
2181             set_cmd (&cmd, pargs.r_opt);
2182             break;
2183
2184           case aKeygen:
2185           case aEditKey:
2186           case aDeleteSecretKeys:
2187           case aDeleteSecretAndPublicKeys:
2188           case aDeleteKeys:
2189           case aPasswd:
2190             set_cmd (&cmd, pargs.r_opt);
2191             greeting=1;
2192             break;
2193
2194           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2195
2196           case aDecryptFiles: multifile=1; /* fall through */
2197           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2198
2199           case aEncrFiles: multifile=1; /* fall through */
2200           case aEncr: set_cmd( &cmd, aEncr); break;
2201
2202           case aVerifyFiles: multifile=1; /* fall through */
2203           case aVerify: set_cmd( &cmd, aVerify); break;
2204
2205           case aServer:
2206             set_cmd (&cmd, pargs.r_opt);
2207             opt.batch = 1;
2208             break;
2209
2210           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2211           case oOutput: opt.outfile = pargs.r.ret_str; break;
2212           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2213           case oQuiet: opt.quiet = 1; break;
2214           case oNoTTY: tty_no_terminal(1); break;
2215           case oDryRun: opt.dry_run = 1; break;
2216           case oInteractive: opt.interactive = 1; break;
2217           case oVerbose:
2218             opt.verbose++;
2219             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2220             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2221             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2222             break;
2223
2224           case oBatch:
2225             opt.batch = 1;
2226             nogreeting = 1;
2227             break;
2228
2229           case oUseAgent: /* Dummy. */
2230             break;
2231           case oNoUseAgent:
2232             obsolete_option (configname, configlineno, "--no-use-agent");
2233             break;
2234           case oGpgAgentInfo:
2235             obsolete_option (configname, configlineno, "--gpg-agent-info");
2236             break;
2237
2238           case oAnswerYes: opt.answer_yes = 1; break;
2239           case oAnswerNo: opt.answer_no = 1; break;
2240           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2241           case oPrimaryKeyring:
2242             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2243             sl->flags=2;
2244             break;
2245           case oShowKeyring:
2246             deprecated_warning(configname,configlineno,"--show-keyring",
2247                                "--list-options ","show-keyring");
2248             opt.list_options|=LIST_SHOW_KEYRING;
2249             break;
2250
2251           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2252           case oDebugAll: opt.debug = ~0; break;
2253           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2254
2255           case oStatusFD:
2256             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2257             break;
2258           case oStatusFile:
2259             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2260             break;
2261           case oAttributeFD:
2262             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2263             break;
2264           case oAttributeFile:
2265             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2266             break;
2267           case oLoggerFD:
2268             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2269             break;
2270           case oLoggerFile:
2271             logfile = pargs.r.ret_str;
2272             break;
2273
2274           case oWithFingerprint:
2275             opt.with_fingerprint = 1;
2276             opt.fingerprint++;
2277             break;
2278           case oFingerprint:
2279             opt.fingerprint++;
2280             fpr_maybe_cmd = 1;
2281             break;
2282
2283           case oSecretKeyring:
2284             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2285             break;
2286           case oOptions:
2287             /* config files may not be nested (silently ignore them) */
2288             if( !configfp ) {
2289                 xfree(configname);
2290                 configname = xstrdup(pargs.r.ret_str);
2291                 goto next_pass;
2292             }
2293             break;
2294           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2295           case oNoDefKeyring: default_keyring = 0; break;
2296           case oNoGreeting: nogreeting = 1; break;
2297           case oNoVerbose:
2298             opt.verbose = 0;
2299             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2300             opt.list_sigs=0;
2301             break;
2302           case oQuickRandom:
2303             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2304             break;
2305           case oEmitVersion: opt.emit_version++; break;
2306           case oNoEmitVersion: opt.emit_version=0; break;
2307           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2308           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2309           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2310           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2311           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2312           case oDefRecipient:
2313             if( *pargs.r.ret_str )
2314               opt.def_recipient = make_username(pargs.r.ret_str);
2315             break;
2316           case oDefRecipientSelf:
2317             xfree(opt.def_recipient); opt.def_recipient = NULL;
2318             opt.def_recipient_self = 1;
2319             break;
2320           case oNoDefRecipient:
2321             xfree(opt.def_recipient); opt.def_recipient = NULL;
2322             opt.def_recipient_self = 0;
2323             break;
2324           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2325           case oHomedir: break;
2326           case oNoBatch: opt.batch = 0; break;
2327
2328           case oWithKeyData: opt.with_key_data=1; /*FALLTHRU*/
2329           case oWithColons: opt.with_colons=':'; break;
2330
2331           case oWithSigCheck: opt.check_sigs = 1; /*FALLTHRU*/
2332           case oWithSigList: opt.list_sigs = 1; break;
2333
2334           case oSkipVerify: opt.skip_verify=1; break;
2335
2336           case oSkipHiddenRecipients:
2337           case oNoSkipHiddenRecipients:
2338             /* Dummies for options to be used in 2.1.  */
2339             break;
2340
2341           case oCompressKeys: opt.compress_keys = 1; break;
2342           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2343             /* There are many programs (like mutt) that call gpg with
2344                --always-trust so keep this option around for a long
2345                time. */
2346           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2347           case oTrustModel:
2348             parse_trust_model(pargs.r.ret_str);
2349             break;
2350           case oForceOwnertrust:
2351             log_info(_("NOTE: %s is not for normal use!\n"),
2352                      "--force-ownertrust");
2353             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2354             if(opt.force_ownertrust==-1)
2355               {
2356                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2357                 opt.force_ownertrust=0;
2358               }
2359             break;
2360           case oLoadExtension:
2361             /* Dummy so that gpg 1.4 conf files can work. Should
2362                eventually be removed.  */
2363             break;
2364           case oRFC1991:
2365             opt.compliance = CO_RFC1991;
2366             opt.force_v4_certs = 0;
2367             opt.escape_from = 1;
2368             break;
2369           case oOpenPGP:
2370           case oRFC4880:
2371             /* This is effectively the same as RFC2440, but with
2372                "--enable-dsa2 --no-rfc2440-text --escape-from-lines
2373                --require-cross-certification". */
2374             opt.compliance = CO_RFC4880;
2375             opt.flags.dsa2 = 1;
2376             opt.flags.require_cross_cert = 1;
2377             opt.rfc2440_text = 0;
2378             opt.allow_non_selfsigned_uid = 1;
2379             opt.allow_freeform_uid = 1;
2380             opt.pgp2_workarounds = 0;
2381             opt.escape_from = 1;
2382             opt.force_v3_sigs = 0;
2383             opt.compress_keys = 0;          /* not mandated, but we do it */
2384             opt.compress_sigs = 0;          /* ditto. */
2385             opt.not_dash_escaped = 0;
2386             opt.def_cipher_algo = 0;
2387             opt.def_digest_algo = 0;
2388             opt.cert_digest_algo = 0;
2389             opt.compress_algo = -1;
2390             opt.s2k_mode = 3; /* iterated+salted */
2391             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2392             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2393             break;
2394           case oRFC2440:
2395             opt.compliance = CO_RFC2440;
2396             opt.flags.dsa2 = 0;
2397             opt.rfc2440_text = 1;
2398             opt.allow_non_selfsigned_uid = 1;
2399             opt.allow_freeform_uid = 1;
2400             opt.pgp2_workarounds = 0;
2401             opt.escape_from = 0;
2402             opt.force_v3_sigs = 0;
2403             opt.compress_keys = 0;          /* not mandated, but we do it */
2404             opt.compress_sigs = 0;          /* ditto. */
2405             opt.not_dash_escaped = 0;
2406             opt.def_cipher_algo = 0;
2407             opt.def_digest_algo = 0;
2408             opt.cert_digest_algo = 0;
2409             opt.compress_algo = -1;
2410             opt.s2k_mode = 3; /* iterated+salted */
2411             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2412             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2413             break;
2414           case oPGP2:  opt.compliance = CO_PGP2;  break;
2415           case oPGP6:  opt.compliance = CO_PGP6;  break;
2416           case oPGP7:  opt.compliance = CO_PGP7;  break;
2417           case oPGP8:  opt.compliance = CO_PGP8;  break;
2418           case oGnuPG: opt.compliance = CO_GNUPG; break;
2419           case oCompressSigs: opt.compress_sigs = 1; break;
2420           case oRFC2440Text: opt.rfc2440_text=1; break;
2421           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2422           case oSetFilename:
2423             if(utf8_strings)
2424               opt.set_filename = pargs.r.ret_str;
2425             else
2426               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2427             break;
2428           case oForYourEyesOnly: eyes_only = 1; break;
2429           case oNoForYourEyesOnly: eyes_only = 0; break;
2430           case oSetPolicyURL:
2431             add_policy_url(pargs.r.ret_str,0);
2432             add_policy_url(pargs.r.ret_str,1);
2433             break;
2434           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2435           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2436           case oShowPolicyURL:
2437             deprecated_warning(configname,configlineno,"--show-policy-url",
2438                                "--list-options ","show-policy-urls");
2439             deprecated_warning(configname,configlineno,"--show-policy-url",
2440                                "--verify-options ","show-policy-urls");
2441             opt.list_options|=LIST_SHOW_POLICY_URLS;
2442             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2443             break;
2444           case oNoShowPolicyURL:
2445             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2446                                "--list-options ","no-show-policy-urls");
2447             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2448                                "--verify-options ","no-show-policy-urls");
2449             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2450             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2451             break;
2452           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2453           case oUseEmbeddedFilename:
2454             opt.flags.use_embedded_filename=1;
2455             break;
2456           case oNoUseEmbeddedFilename:
2457             opt.flags.use_embedded_filename=0;
2458             break;
2459           case oComment:
2460             if(pargs.r.ret_str[0])
2461               append_to_strlist(&opt.comments,pargs.r.ret_str);
2462             break;
2463           case oDefaultComment:
2464             deprecated_warning(configname,configlineno,
2465                                "--default-comment","--no-comments","");
2466             /* fall through */
2467           case oNoComments:
2468             free_strlist(opt.comments);
2469             opt.comments=NULL;
2470             break;
2471           case oThrowKeyids: opt.throw_keyid = 1; break;
2472           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2473           case oShowPhotos:
2474             deprecated_warning(configname,configlineno,"--show-photos",
2475                                "--list-options ","show-photos");
2476             deprecated_warning(configname,configlineno,"--show-photos",
2477                                "--verify-options ","show-photos");
2478             opt.list_options|=LIST_SHOW_PHOTOS;
2479             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2480             break;
2481           case oNoShowPhotos:
2482             deprecated_warning(configname,configlineno,"--no-show-photos",
2483                                "--list-options ","no-show-photos");
2484             deprecated_warning(configname,configlineno,"--no-show-photos",
2485                                "--verify-options ","no-show-photos");
2486             opt.list_options&=~LIST_SHOW_PHOTOS;
2487             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2488             break;
2489           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2490           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2491           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2492           case oForceV4Certs: opt.force_v4_certs = 1; break;
2493           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2494           case oForceMDC: opt.force_mdc = 1; break;
2495           case oNoForceMDC: opt.force_mdc = 0; break;
2496           case oDisableMDC: opt.disable_mdc = 1; break;
2497           case oNoDisableMDC: opt.disable_mdc = 0; break;
2498           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2499           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2500           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2501           case oS2KCount:
2502             if (pargs.r.ret_int)
2503               opt.s2k_count = encode_s2k_iterations (pargs.r.ret_int);
2504             else
2505               opt.s2k_count = 0;  /* Auto-calibrate when needed.  */
2506             break;
2507           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2508           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2509           case oEncryptTo: /* store the recipient in the second list */
2510             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2511             sl->flags = 1;
2512             break;
2513           case oHiddenEncryptTo: /* store the recipient in the second list */
2514             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2515             sl->flags = 1|2;
2516             break;
2517           case oRecipient: /* store the recipient */
2518             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2519             any_explicit_recipient = 1;
2520             break;
2521           case oHiddenRecipient: /* store the recipient with a flag */
2522             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2523             sl->flags = 2;
2524             any_explicit_recipient = 1;
2525             break;
2526           case oTextmodeShort: opt.textmode = 2; break;
2527           case oTextmode: opt.textmode=1;  break;
2528           case oNoTextmode: opt.textmode=0;  break;
2529           case oExpert: opt.expert = 1; break;
2530           case oNoExpert: opt.expert = 0; break;
2531           case oDefSigExpire:
2532             if(*pargs.r.ret_str!='\0')
2533               {
2534                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2535                   log_error(_("`%s' is not a valid signature expiration\n"),
2536                             pargs.r.ret_str);
2537                 else
2538                   opt.def_sig_expire=pargs.r.ret_str;
2539               }
2540             break;
2541           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2542           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2543           case oDefCertExpire:
2544             if(*pargs.r.ret_str!='\0')
2545               {
2546                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2547                   log_error(_("`%s' is not a valid signature expiration\n"),
2548                             pargs.r.ret_str);
2549                 else
2550                   opt.def_cert_expire=pargs.r.ret_str;
2551               }
2552             break;
2553           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2554           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2555           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2556           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2557           case oAskCertLevel: opt.ask_cert_level = 1; break;
2558           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2559           case oLocalUser: /* store the local users */
2560             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2561             break;
2562           case oCompress:
2563             /* this is the -z command line option */
2564             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2565             break;
2566           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2567           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2568           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2569           case oPassphrase:
2570             set_passphrase_from_string(pargs.r.ret_str);
2571             break;
2572           case oPassphraseFD:
2573             pwfd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2574             break;
2575           case oPassphraseFile:
2576             pwfd = open_info_file (pargs.r.ret_str, 0, 1);
2577             break;
2578           case oPassphraseRepeat: opt.passphrase_repeat=pargs.r.ret_int; break;
2579           case oCommandFD:
2580             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2581             break;
2582           case oCommandFile:
2583             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2584             break;
2585           case oCipherAlgo:
2586             def_cipher_string = xstrdup(pargs.r.ret_str);
2587             break;
2588           case oDigestAlgo:
2589             def_digest_string = xstrdup(pargs.r.ret_str);
2590             break;
2591           case oCompressAlgo:
2592             /* If it is all digits, stick a Z in front of it for
2593                later.  This is for backwards compatibility with
2594                versions that took the compress algorithm number. */
2595             {
2596               char *pt=pargs.r.ret_str;
2597               while(*pt)
2598                 {
2599                   if (!isascii (*pt) || !isdigit (*pt))
2600                     break;
2601
2602                   pt++;
2603                 }
2604
2605               if(*pt=='\0')
2606                 {
2607                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2608                   strcpy(compress_algo_string,"Z");
2609                   strcat(compress_algo_string,pargs.r.ret_str);
2610                 }
2611               else
2612                 compress_algo_string = xstrdup(pargs.r.ret_str);
2613             }
2614             break;
2615           case oCertDigestAlgo:
2616             cert_digest_string = xstrdup(pargs.r.ret_str);
2617             break;
2618
2619           case oNoSecmemWarn:
2620             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2621             break;
2622
2623           case oRequireSecmem: require_secmem=1; break;
2624           case oNoRequireSecmem: require_secmem=0; break;
2625           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2626           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2627           case oDisplayCharset:
2628             if( set_native_charset( pargs.r.ret_str ) )
2629                 log_error(_("`%s' is not a valid character set\n"),
2630                           pargs.r.ret_str);
2631             break;
2632           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2633           case oEscapeFrom: opt.escape_from = 1; break;
2634           case oNoEscapeFrom: opt.escape_from = 0; break;
2635           case oLockOnce: opt.lock_once = 1; break;
2636           case oLockNever:
2637             disable_dotlock ();
2638             break;
2639           case oLockMultiple:
2640 #ifndef __riscos__
2641             opt.lock_once = 0;
2642 #else /* __riscos__ */
2643             riscos_not_implemented("lock-multiple");
2644 #endif /* __riscos__ */
2645             break;
2646           case oKeyServer:
2647             {
2648               struct keyserver_spec *keyserver;
2649               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2650                                             configname,configlineno);
2651               if(!keyserver)
2652                 log_error(_("could not parse keyserver URL\n"));
2653               else
2654                 {
2655                   keyserver->next=opt.keyserver;
2656                   opt.keyserver=keyserver;
2657                 }
2658             }
2659             break;
2660           case oKeyServerOptions:
2661             if(!parse_keyserver_options(pargs.r.ret_str))
2662               {
2663                 if(configname)
2664                   log_error(_("%s:%d: invalid keyserver options\n"),
2665                             configname,configlineno);
2666                 else
2667                   log_error(_("invalid keyserver options\n"));
2668               }
2669             break;
2670           case oImportOptions:
2671             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2672               {
2673                 if(configname)
2674                   log_error(_("%s:%d: invalid import options\n"),
2675                             configname,configlineno);
2676                 else
2677                   log_error(_("invalid import options\n"));
2678               }
2679             break;
2680           case oExportOptions:
2681             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2682               {
2683                 if(configname)
2684                   log_error(_("%s:%d: invalid export options\n"),
2685                             configname,configlineno);
2686                 else
2687                   log_error(_("invalid export options\n"));
2688               }
2689             break;
2690           case oListOptions:
2691             if(!parse_list_options(pargs.r.ret_str))
2692               {
2693                 if(configname)
2694                   log_error(_("%s:%d: invalid list options\n"),
2695                             configname,configlineno);
2696                 else
2697                   log_error(_("invalid list options\n"));
2698               }
2699             break;
2700           case oVerifyOptions:
2701             {
2702               struct parse_options vopts[]=
2703                 {
2704                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2705                    N_("display photo IDs during signature verification")},
2706                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2707                    N_("show policy URLs during signature verification")},
2708                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2709                    N_("show all notations during signature verification")},
2710                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2711                    N_("show IETF standard notations during signature verification")},
2712                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2713                    NULL},
2714                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2715                    N_("show user-supplied notations during signature verification")},
2716                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2717                    N_("show preferred keyserver URLs during signature verification")},
2718                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2719                    N_("show user ID validity during signature verification")},
2720                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2721                    N_("show revoked and expired user IDs in signature verification")},
2722                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2723                    N_("show only the primary user ID in signature verification")},
2724                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2725                    N_("validate signatures with PKA data")},
2726                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2727                    N_("elevate the trust of signatures with valid PKA data")},
2728                   {NULL,0,NULL,NULL}
2729                 };
2730
2731               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2732                 {
2733                   if(configname)
2734                     log_error(_("%s:%d: invalid verify options\n"),
2735                               configname,configlineno);
2736                   else
2737                     log_error(_("invalid verify options\n"));
2738                 }
2739             }
2740             break;
2741           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2742           case oExecPath:
2743             if(set_exec_path(pargs.r.ret_str))
2744               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2745             else
2746               opt.exec_path_set=1;
2747             break;
2748           case oSetNotation:
2749             add_notation_data( pargs.r.ret_str, 0 );
2750             add_notation_data( pargs.r.ret_str, 1 );
2751             break;
2752           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2753           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2754           case oShowNotation:
2755             deprecated_warning(configname,configlineno,"--show-notation",
2756                                "--list-options ","show-notations");
2757             deprecated_warning(configname,configlineno,"--show-notation",
2758                                "--verify-options ","show-notations");
2759             opt.list_options|=LIST_SHOW_NOTATIONS;
2760             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2761             break;
2762           case oNoShowNotation:
2763             deprecated_warning(configname,configlineno,"--no-show-notation",
2764                                "--list-options ","no-show-notations");
2765             deprecated_warning(configname,configlineno,"--no-show-notation",
2766                                "--verify-options ","no-show-notations");
2767             opt.list_options&=~LIST_SHOW_NOTATIONS;
2768             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2769             break;
2770           case oUtf8Strings: utf8_strings = 1; break;
2771           case oNoUtf8Strings: utf8_strings = 0; break;
2772           case oDisableCipherAlgo:
2773             {
2774               int algo = string_to_cipher_algo (pargs.r.ret_str);
2775               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2776             }
2777             break;
2778           case oDisablePubkeyAlgo:
2779             {
2780               int algo = gcry_pk_map_name (pargs.r.ret_str);
2781               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2782             }
2783             break;
2784           case oNoSigCache: opt.no_sig_cache = 1; break;
2785           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2786           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2787           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2788           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2789           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2790           case oNoLiteral: opt.no_literal = 1; break;
2791           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2792           case oHonorHttpProxy:
2793                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2794                 deprecated_warning(configname,configlineno,
2795                                    "--honor-http-proxy",
2796                                    "--keyserver-options ","http-proxy");
2797                 break;
2798           case oFastListMode: opt.fast_list_mode = 1; break;
2799           case oFixedListMode: /* Dummy */ break;
2800           case oListOnly: opt.list_only=1; break;
2801           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2802           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2803           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2804           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2805           case oNoRandomSeedFile: use_random_seed = 0; break;
2806           case oAutoKeyRetrieve:
2807           case oNoAutoKeyRetrieve:
2808                 if(pargs.r_opt==oAutoKeyRetrieve)
2809                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2810                 else
2811                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2812
2813                 deprecated_warning(configname,configlineno,
2814                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2815                                "--no-auto-key-retrieve","--keyserver-options ",
2816                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2817                                "no-auto-key-retrieve");
2818                 break;
2819           case oShowSessionKey: opt.show_session_key = 1; break;
2820           case oOverrideSessionKey:
2821                 opt.override_session_key = pargs.r.ret_str;
2822                 break;
2823           case oMergeOnly:
2824                 deprecated_warning(configname,configlineno,"--merge-only",
2825                                    "--import-options ","merge-only");
2826                 opt.import_options|=IMPORT_MERGE_ONLY;
2827             break;
2828           case oAllowSecretKeyImport: /* obsolete */ break;
2829           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2830           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2831           case oEnableSpecialFilenames:
2832             iobuf_enable_special_filenames (1);
2833             break;
2834           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2835           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2836           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2837           case oPreservePermissions: opt.preserve_permissions=1; break;
2838           case oDefaultPreferenceList:
2839             opt.def_preference_list = pargs.r.ret_str;
2840             break;
2841           case oDefaultKeyserverURL:
2842             {
2843               struct keyserver_spec *keyserver;
2844               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2845                                             configname,configlineno);
2846               if(!keyserver)
2847                 log_error(_("could not parse keyserver URL\n"));
2848               else
2849                 free_keyserver_spec(keyserver);
2850
2851               opt.def_keyserver_url = pargs.r.ret_str;
2852             }
2853             break;
2854           case oPersonalCipherPreferences:
2855             pers_cipher_list=pargs.r.ret_str;
2856             break;
2857           case oPersonalDigestPreferences:
2858             pers_digest_list=pargs.r.ret_str;
2859             break;
2860           case oPersonalCompressPreferences:
2861             pers_compress_list=pargs.r.ret_str;
2862             break;
2863           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2864
2865           case oDisplay:
2866             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
2867             break;
2868           case oTTYname:
2869             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
2870             break;
2871           case oTTYtype:
2872             set_opt_session_env ("TERM", pargs.r.ret_str);
2873             break;
2874           case oXauthority:
2875             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
2876             break;
2877
2878           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2879           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2880
2881           case oGroup: add_group(pargs.r.ret_str); break;
2882           case oUnGroup: rm_group(pargs.r.ret_str); break;
2883           case oNoGroups:
2884             while(opt.grouplist)
2885               {
2886                 struct groupitem *iter=opt.grouplist;
2887                 free_strlist(iter->values);
2888                 opt.grouplist=opt.grouplist->next;
2889                 xfree(iter);
2890               }
2891             break;
2892
2893           case oStrict:
2894           case oNoStrict:
2895             /* Not used */
2896             break;
2897
2898           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2899           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2900           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2901           case oMultifile: multifile=1; break;
2902           case oKeyidFormat:
2903             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2904               opt.keyid_format=KF_SHORT;
2905             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2906               opt.keyid_format=KF_LONG;
2907             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2908               opt.keyid_format=KF_0xSHORT;
2909             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2910               opt.keyid_format=KF_0xLONG;
2911             else
2912               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2913             break;
2914
2915           case oExitOnStatusWriteError:
2916             opt.exit_on_status_write_error = 1;
2917             break;
2918
2919           case oLimitCardInsertTries:
2920             opt.limit_card_insert_tries = pargs.r.ret_int;
2921             break;
2922
2923           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2924           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2925
2926           case oAutoKeyLocate:
2927             if(!parse_auto_key_locate(pargs.r.ret_str))
2928               {
2929                 if(configname)
2930                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2931                             configname,configlineno);
2932                 else
2933                   log_error(_("invalid auto-key-locate list\n"));
2934               }
2935             break;
2936           case oNoAutoKeyLocate:
2937             release_akl();
2938             break;
2939
2940           case oEnableDSA2: opt.flags.dsa2=1; break;
2941           case oDisableDSA2: opt.flags.dsa2=0; break;
2942
2943           case oAllowMultisigVerification:
2944           case oAllowMultipleMessages:
2945             opt.flags.allow_multiple_messages=1;
2946             break;
2947
2948           case oNoAllowMultipleMessages:
2949             opt.flags.allow_multiple_messages=0;
2950             break;
2951
2952           case oNoop: break;
2953
2954           default:
2955             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
2956             break;
2957           }
2958       }
2959
2960
2961     if( configfp ) {
2962         fclose( configfp );
2963         configfp = NULL;
2964         /* Remember the first config file name. */
2965         if (!save_configname)
2966           save_configname = configname;
2967         else
2968           xfree(configname);
2969         configname = NULL;
2970         goto next_pass;
2971     }
2972     xfree( configname ); configname = NULL;
2973     if( log_get_errorcount(0) )
2974         g10_exit(2);
2975
2976     /* The command --gpgconf-list is pretty simple and may be called
2977        directly after the option parsing. */
2978     if (cmd == aGPGConfList)
2979       {
2980         gpgconf_list (save_configname ? save_configname : default_configname);
2981         g10_exit (0);
2982       }
2983     xfree (save_configname);
2984     xfree (default_configname);
2985
2986     if( nogreeting )
2987         greeting = 0;
2988
2989     if( greeting ) {
2990         fprintf(stderr, "%s %s; %s\n",
2991                         strusage(11), strusage(13), strusage(14) );
2992         fprintf(stderr, "%s\n", strusage(15) );
2993     }
2994 #ifdef IS_DEVELOPMENT_VERSION
2995     if (!opt.batch)
2996       {
2997         const char *s;
2998
2999         if((s=strusage(25)))
3000           log_info("%s\n",s);
3001         if((s=strusage(26)))
3002           log_info("%s\n",s);
3003         if((s=strusage(27)))
3004           log_info("%s\n",s);
3005       }
3006 #endif
3007
3008     /* FIXME: We should use logging to a file only in server mode;
3009        however we have not yet implemetyed that.  Thus we try to get
3010        away with --batch as indication for logging to file
3011        required. */
3012     if (logfile && opt.batch)
3013       {
3014         log_set_file (logfile);
3015         log_set_prefix (NULL, 1|2|4);
3016       }
3017
3018     /* Older Libgcrypts fail with an assertion during DSA key
3019        generation.  Better disable DSA2 entirely. */
3020     if (opt.flags.dsa2 && !gcry_check_version ("1.4.0") )
3021       {
3022         log_info ("WARNING: "
3023                   "DSA2 is only available with Libgcrypt 1.4 and later\n");
3024         opt.flags.dsa2 = 0;
3025       }
3026
3027     if (opt.verbose > 2)
3028         log_info ("using character set `%s'\n", get_native_charset ());
3029
3030     if( may_coredump && !opt.quiet )
3031         log_info(_("WARNING: program may create a core file!\n"));
3032
3033     if (eyes_only) {
3034       if (opt.set_filename)
3035           log_info(_("WARNING: %s overrides %s\n"),
3036                    "--for-your-eyes-only","--set-filename");
3037
3038       opt.set_filename="_CONSOLE";
3039     }
3040
3041     if (opt.no_literal) {
3042         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
3043         if (opt.textmode)
3044             log_error(_("%s not allowed with %s!\n"),
3045                        "--textmode", "--no-literal" );
3046         if (opt.set_filename)
3047             log_error(_("%s makes no sense with %s!\n"),
3048                         eyes_only?"--for-your-eyes-only":"--set-filename",
3049                         "--no-literal" );
3050     }
3051
3052
3053     if (opt.set_filesize)
3054         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
3055     if( opt.batch )
3056         tty_batchmode( 1 );
3057
3058     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3059
3060     if(require_secmem && !got_secmem)
3061       {
3062         log_info(_("will not run with insecure memory due to %s\n"),
3063                  "--require-secmem");
3064         g10_exit(2);
3065       }
3066
3067     set_debug (debug_level);
3068
3069     /* Do these after the switch(), so they can override settings. */
3070     if(PGP2)
3071       {
3072         int unusable=0;
3073
3074         if(cmd==aSign && !detached_sig)
3075           {
3076             log_info(_("you can only make detached or clear signatures "
3077                        "while in --pgp2 mode\n"));
3078             unusable=1;
3079           }
3080         else if(cmd==aSignEncr || cmd==aSignSym)
3081           {
3082             log_info(_("you can't sign and encrypt at the "
3083                        "same time while in --pgp2 mode\n"));
3084             unusable=1;
3085           }
3086         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
3087           {
3088             log_info(_("you must use files (and not a pipe) when "
3089                        "working with --pgp2 enabled.\n"));
3090             unusable=1;
3091           }
3092         else if(cmd==aEncr || cmd==aSym)
3093           {
3094             /* Everything else should work without IDEA (except using
3095                a secret key encrypted with IDEA and setting an IDEA
3096                preference, but those have their own error
3097                messages). */
3098
3099             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
3100               {
3101                 log_info(_("encrypting a message in --pgp2 mode requires "
3102                            "the IDEA cipher\n"));
3103                 idea_cipher_warn(1);
3104                 unusable=1;
3105               }
3106             else if(cmd==aSym)
3107               {
3108                 /* This only sets IDEA for symmetric encryption
3109                    since it is set via select_algo_from_prefs for
3110                    pk encryption. */
3111                 xfree(def_cipher_string);
3112                 def_cipher_string = xstrdup("idea");
3113               }
3114
3115             /* PGP2 can't handle the output from the textmode
3116                filter, so we disable it for anything that could
3117                create a literal packet (only encryption and
3118                symmetric encryption, since we disable signing
3119                above). */
3120             if(!unusable)
3121               opt.textmode=0;
3122           }
3123
3124         if(unusable)
3125           compliance_failure();
3126         else
3127           {
3128             opt.force_v4_certs = 0;
3129             opt.escape_from = 1;
3130             opt.force_v3_sigs = 1;
3131             opt.pgp2_workarounds = 1;
3132             opt.ask_sig_expire = 0;
3133             opt.ask_cert_expire = 0;
3134             xfree(def_digest_string);
3135             def_digest_string = xstrdup("md5");
3136             xfree(s2k_digest_string);
3137             s2k_digest_string = xstrdup("md5");
3138             opt.compress_algo = COMPRESS_ALGO_ZIP;
3139           }
3140       }
3141     else if(PGP6)
3142       {
3143         opt.disable_mdc=1;
3144         opt.escape_from=1;
3145         opt.force_v3_sigs=1;
3146         opt.ask_sig_expire=0;
3147       }
3148     else if(PGP7)
3149       {
3150         opt.escape_from=1;
3151         opt.force_v3_sigs=1;
3152         opt.ask_sig_expire=0;
3153       }
3154     else if(PGP8)
3155       {
3156         opt.escape_from=1;
3157       }
3158
3159
3160     if( def_cipher_string ) {
3161         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3162         if(opt.def_cipher_algo==0 &&
3163            (ascii_strcasecmp(def_cipher_string,"idea")==0
3164             || ascii_strcasecmp(def_cipher_string,"s1")==0))
3165           idea_cipher_warn(1);
3166         xfree(def_cipher_string); def_cipher_string = NULL;
3167         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3168             log_error(_("selected cipher algorithm is invalid\n"));
3169     }
3170     if( def_digest_string ) {
3171         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3172         xfree(def_digest_string); def_digest_string = NULL;
3173         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3174             log_error(_("selected digest algorithm is invalid\n"));
3175     }
3176     if( compress_algo_string ) {
3177         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3178         xfree(compress_algo_string); compress_algo_string = NULL;
3179         if( check_compress_algo(opt.compress_algo) )
3180           log_error(_("selected compression algorithm is invalid\n"));
3181     }
3182     if( cert_digest_string ) {
3183         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3184         xfree(cert_digest_string); cert_digest_string = NULL;
3185         if (openpgp_md_test_algo(opt.cert_digest_algo))
3186           log_error(_("selected certification digest algorithm is invalid\n"));
3187     }
3188     if( s2k_cipher_string ) {
3189         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3190         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3191         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3192           log_error(_("selected cipher algorithm is invalid\n"));
3193     }
3194     if( s2k_digest_string ) {
3195         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3196         xfree(s2k_digest_string); s2k_digest_string = NULL;
3197         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3198           log_error(_("selected digest algorithm is invalid\n"));
3199     }
3200     if( opt.completes_needed < 1 )
3201       log_error(_("completes-needed must be greater than 0\n"));
3202     if( opt.marginals_needed < 2 )
3203       log_error(_("marginals-needed must be greater than 1\n"));
3204     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3205       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3206     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3207       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3208     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3209       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3210     switch( opt.s2k_mode ) {
3211       case 0:
3212         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3213         break;
3214       case 1: case 3: break;
3215       default:
3216         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3217     }
3218
3219     /* This isn't actually needed, but does serve to error out if the
3220        string is invalid. */
3221     if(opt.def_preference_list &&
3222         keygen_set_std_prefs(opt.def_preference_list,0))
3223       log_error(_("invalid default preferences\n"));
3224
3225     if(pers_cipher_list &&
3226        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3227       log_error(_("invalid personal cipher preferences\n"));
3228
3229     if(pers_digest_list &&
3230        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3231       log_error(_("invalid personal digest preferences\n"));
3232
3233     if(pers_compress_list &&
3234        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3235       log_error(_("invalid personal compress preferences\n"));
3236
3237     /* We don't support all possible commands with multifile yet */
3238     if(multifile)
3239       {
3240         char *cmdname;
3241
3242         switch(cmd)
3243           {
3244           case aSign:
3245             cmdname="--sign";
3246             break;
3247           case aClearsign:
3248             cmdname="--clearsign";
3249             break;
3250           case aDetachedSign:
3251             cmdname="--detach-sign";
3252             break;
3253           case aSym:
3254             cmdname="--symmetric";
3255             break;
3256           case aEncrSym:
3257             cmdname="--symmetric --encrypt";
3258             break;
3259           case aStore:
3260             cmdname="--store";
3261             break;
3262           default:
3263             cmdname=NULL;
3264             break;
3265           }
3266
3267         if(cmdname)
3268           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3269       }
3270
3271     if( log_get_errorcount(0) )
3272         g10_exit(2);
3273
3274     if(opt.compress_level==0)
3275       opt.compress_algo=COMPRESS_ALGO_NONE;
3276
3277     /* Check our chosen algorithms against the list of legal
3278        algorithms. */
3279
3280     if(!GNUPG)
3281       {
3282         const char *badalg=NULL;
3283         preftype_t badtype=PREFTYPE_NONE;
3284
3285         if(opt.def_cipher_algo
3286            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3287           {
3288             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3289             badtype = PREFTYPE_SYM;
3290           }
3291         else if(opt.def_digest_algo
3292                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3293           {
3294             badalg = gcry_md_algo_name (opt.def_digest_algo);
3295             badtype = PREFTYPE_HASH;
3296           }
3297         else if(opt.cert_digest_algo
3298                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3299           {
3300             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3301             badtype = PREFTYPE_HASH;
3302           }
3303         else if(opt.compress_algo!=-1
3304                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3305           {
3306             badalg = compress_algo_to_string(opt.compress_algo);
3307             badtype = PREFTYPE_ZIP;
3308           }
3309
3310         if(badalg)
3311           {
3312             switch(badtype)
3313               {
3314               case PREFTYPE_SYM:
3315                 log_info(_("you may not use cipher algorithm `%s'"
3316                            " while in %s mode\n"),
3317                          badalg,compliance_option_string());
3318                 break;
3319               case PREFTYPE_HASH:
3320                 log_info(_("you may not use digest algorithm `%s'"
3321                            " while in %s mode\n"),
3322                          badalg,compliance_option_string());
3323                 break;
3324               case PREFTYPE_ZIP:
3325                 log_info(_("you may not use compression algorithm `%s'"
3326                            " while in %s mode\n"),
3327                          badalg,compliance_option_string());
3328                 break;
3329               default:
3330                 BUG();
3331               }
3332
3333             compliance_failure();
3334           }
3335       }
3336
3337     /* Set the random seed file. */
3338     if( use_random_seed ) {
3339         char *p = make_filename(opt.homedir, "random_seed", NULL );
3340         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3341         if (!access (p, F_OK))
3342           register_secured_file (p);
3343         xfree(p);
3344     }
3345
3346     /* If there is no command but the --fingerprint is given, default
3347        to the --list-keys command.  */
3348     if (!cmd && fpr_maybe_cmd)
3349       {
3350         set_cmd (&cmd, aListKeys);
3351       }
3352
3353
3354     if( opt.verbose > 1 )
3355         set_packet_list_mode(1);
3356
3357     /* Add the keyrings, but not for some special commands.  Also
3358        avoid adding the secret keyring for a couple of commands to
3359        avoid unneeded access in case the secrings are stored on a
3360        floppy.
3361
3362        We always need to add the keyrings if we are running under
3363        SELinux, this is so that the rings are added to the list of
3364        secured files. */
3365     if( ALWAYS_ADD_KEYRINGS
3366         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3367       {
3368         if (ALWAYS_ADD_KEYRINGS
3369             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3370                 && cmd != aVerify && cmd != aSym && cmd != aLocateKeys))
3371           {
3372             if (!sec_nrings || default_keyring) /* add default secret rings */
3373               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3374             for (sl = sec_nrings; sl; sl = sl->next)
3375               keydb_add_resource ( sl->d, 0, 1 );
3376           }
3377         if( !nrings || default_keyring )  /* add default ring */
3378             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3379         for(sl = nrings; sl; sl = sl->next )
3380             keydb_add_resource ( sl->d, sl->flags, 0 );
3381       }
3382     FREE_STRLIST(nrings);
3383     FREE_STRLIST(sec_nrings);
3384
3385     if (cmd == aGPGConfTest)
3386       g10_exit(0);
3387
3388
3389     if( pwfd != -1 )  /* Read the passphrase now. */
3390         read_passphrase_from_fd( pwfd );
3391
3392     fname = argc? *argv : NULL;
3393
3394     if(fname && utf8_strings)
3395       opt.flags.utf8_filename=1;
3396
3397     switch (cmd)
3398       {
3399       case aPrimegen:
3400       case aPrintMD:
3401       case aPrintMDs:
3402       case aGenRandom:
3403       case aDeArmor:
3404       case aEnArmor:
3405         break;
3406       case aFixTrustDB:
3407       case aExportOwnerTrust:
3408         rc = setup_trustdb (0, trustdb_name);
3409         break;
3410       case aListTrustDB:
3411         rc = setup_trustdb (argc? 1:0, trustdb_name);
3412         break;
3413       default:
3414         /* If we are using TM_ALWAYS, we do not need to create the
3415            trustdb.  */
3416         rc = setup_trustdb (opt.trust_model != TM_ALWAYS, trustdb_name);
3417         break;
3418       }
3419     if (rc)
3420       log_error (_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3421
3422
3423     switch (cmd)
3424       {
3425       case aStore:
3426       case aSym:
3427       case aSign:
3428       case aSignSym:
3429       case aClearsign:
3430         if (!opt.quiet && any_explicit_recipient)
3431           log_info (_("WARNING: recipients (-r) given "
3432                       "without using public key encryption\n"));
3433         break;
3434       default:
3435         break;
3436       }
3437
3438     switch( cmd )
3439       {
3440       case aServer:
3441         {
3442           ctrl_t ctrl = xtrycalloc (1, sizeof *ctrl);
3443           gpg_init_default_ctrl (ctrl);
3444           gpg_server (ctrl);
3445           gpg_deinit_default_ctrl (ctrl);
3446           xfree (ctrl);
3447         }
3448         break;
3449
3450       case aStore: /* only store the file */
3451         if( argc > 1 )
3452             wrong_args(_("--store [filename]"));
3453         if( (rc = encode_store(fname)) )
3454             log_error ("storing `%s' failed: %s\n",
3455                        print_fname_stdin(fname),g10_errstr(rc) );
3456         break;
3457       case aSym: /* encrypt the given file only with the symmetric cipher */
3458         if( argc > 1 )
3459             wrong_args(_("--symmetric [filename]"));
3460         if( (rc = encode_symmetric(fname)) )
3461             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3462                         print_fname_stdin(fname),g10_errstr(rc) );
3463         break;
3464
3465       case aEncr: /* encrypt the given file */
3466         if(multifile)
3467           encode_crypt_files(argc, argv, remusr);
3468         else
3469           {
3470             if( argc > 1 )
3471               wrong_args(_("--encrypt [filename]"));
3472             if( (rc = encode_crypt(fname,remusr,0)) )
3473               log_error("%s: encryption failed: %s\n",
3474                         print_fname_stdin(fname), g10_errstr(rc) );
3475           }
3476         break;
3477
3478       case aEncrSym:
3479         /* This works with PGP 8 in the sense that it acts just like a
3480            symmetric message.  It doesn't work at all with 2 or 6.  It
3481            might work with 7, but alas, I don't have a copy to test
3482            with right now. */
3483         if( argc > 1 )
3484           wrong_args(_("--symmetric --encrypt [filename]"));
3485         else if(opt.s2k_mode==0)
3486           log_error(_("you cannot use --symmetric --encrypt"
3487                       " with --s2k-mode 0\n"));
3488         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3489           log_error(_("you cannot use --symmetric --encrypt"
3490                       " while in %s mode\n"),compliance_option_string());
3491         else
3492           {
3493             if( (rc = encode_crypt(fname,remusr,1)) )
3494               log_error("%s: encryption failed: %s\n",
3495                         print_fname_stdin(fname), g10_errstr(rc) );
3496           }
3497         break;
3498
3499       case aSign: /* sign the given file */
3500         sl = NULL;
3501         if( detached_sig ) { /* sign all files */
3502             for( ; argc; argc--, argv++ )
3503                 add_to_strlist( &sl, *argv );
3504         }
3505         else {
3506             if( argc > 1 )
3507                 wrong_args(_("--sign [filename]"));
3508             if( argc ) {
3509                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3510                 strcpy(sl->d, fname);
3511             }
3512         }
3513         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3514             log_error("signing failed: %s\n", g10_errstr(rc) );
3515         free_strlist(sl);
3516         break;
3517
3518       case aSignEncr: /* sign and encrypt the given file */
3519         if( argc > 1 )
3520             wrong_args(_("--sign --encrypt [filename]"));
3521         if( argc ) {
3522             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3523             strcpy(sl->d, fname);
3524         }
3525         else
3526             sl = NULL;
3527         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3528             log_error("%s: sign+encrypt failed: %s\n",
3529                       print_fname_stdin(fname), g10_errstr(rc) );
3530         free_strlist(sl);
3531         break;
3532
3533       case aSignEncrSym: /* sign and encrypt the given file */
3534         if( argc > 1 )
3535             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3536         else if(opt.s2k_mode==0)
3537           log_error(_("you cannot use --symmetric --sign --encrypt"
3538                       " with --s2k-mode 0\n"));
3539         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3540           log_error(_("you cannot use --symmetric --sign --encrypt"
3541                       " while in %s mode\n"),compliance_option_string());
3542         else
3543           {
3544             if( argc )
3545               {
3546                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3547                 strcpy(sl->d, fname);
3548               }
3549             else
3550               sl = NULL;
3551             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3552