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