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