7e4339b57755357210a70d196aee3154018012cd
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3  *               2008, 2009, 2010, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <assert.h>
29 #ifdef HAVE_STAT
30 #include <sys/stat.h> /* for stat() */
31 #endif
32 #include <fcntl.h>
33 #ifdef HAVE_W32_SYSTEM
34 #include <windows.h>
35 #endif
36
37 #define INCLUDED_BY_MAIN_MODULE 1
38 #include "gpg.h"
39 #include <assuan.h>
40 #include "../common/iobuf.h"
41 #include "util.h"
42 #include "packet.h"
43 #include "main.h"
44 #include "options.h"
45 #include "keydb.h"
46 #include "trustdb.h"
47 #include "cipher.h"
48 #include "filter.h"
49 #include "ttyio.h"
50 #include "i18n.h"
51 #include "sysutils.h"
52 #include "status.h"
53 #include "keyserver-internal.h"
54 #include "exec.h"
55 #include "gc-opt-flags.h"
56 #include "asshelp.h"
57 #include "call-dirmngr.h"
58 #include "../common/init.h"
59
60 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
61 #define MY_O_BINARY  O_BINARY
62 #ifndef S_IRGRP
63 # define S_IRGRP 0
64 # define S_IWGRP 0
65 #endif
66 #else
67 #define MY_O_BINARY  0
68 #endif
69
70
71 enum cmd_and_opt_values
72   {
73     aNull = 0,
74     oArmor        = 'a',
75     aDetachedSign = 'b',
76     aSym          = 'c',
77     aDecrypt      = 'd',
78     aEncr         = 'e',
79     oInteractive  = 'i',
80     aListKeys     = 'k',
81     oDryRun       = 'n',
82     oOutput       = 'o',
83     oQuiet        = 'q',
84     oRecipient    = 'r',
85     oHiddenRecipient = 'R',
86     aSign         = 's',
87     oTextmodeShort= 't',
88     oLocalUser    = 'u',
89     oVerbose      = 'v',
90     oCompress     = 'z',
91     oSetNotation  = 'N',
92     aListSecretKeys = 'K',
93     oBatch        = 500,
94     oMaxOutput,
95     oSigNotation,
96     oCertNotation,
97     oShowNotation,
98     oNoShowNotation,
99     aEncrFiles,
100     aEncrSym,
101     aDecryptFiles,
102     aClearsign,
103     aStore,
104     aKeygen,
105     aSignEncr,
106     aSignEncrSym,
107     aSignSym,
108     aSignKey,
109     aLSignKey,
110     aListConfig,
111     aGPGConfList,
112     aGPGConfTest,
113     aListPackets,
114     aEditKey,
115     aDeleteKeys,
116     aDeleteSecretKeys,
117     aDeleteSecretAndPublicKeys,
118     aImport,
119     aFastImport,
120     aVerify,
121     aVerifyFiles,
122     aListSigs,
123     aSendKeys,
124     aRecvKeys,
125     aLocateKeys,
126     aSearchKeys,
127     aRefreshKeys,
128     aFetchKeys,
129     aExport,
130     aExportSecret,
131     aExportSecretSub,
132     aCheckKeys,
133     aGenRevoke,
134     aDesigRevoke,
135     aPrimegen,
136     aPrintMD,
137     aPrintMDs,
138     aCheckTrustDB,
139     aUpdateTrustDB,
140     aFixTrustDB,
141     aListTrustDB,
142     aListTrustPath,
143     aExportOwnerTrust,
144     aImportOwnerTrust,
145     aDeArmor,
146     aEnArmor,
147     aGenRandom,
148     aRebuildKeydbCaches,
149     aCardStatus,
150     aCardEdit,
151     aChangePIN,
152     aPasswd,
153     aServer,
154
155     oTextmode,
156     oNoTextmode,
157     oExpert,
158     oNoExpert,
159     oDefSigExpire,
160     oAskSigExpire,
161     oNoAskSigExpire,
162     oDefCertExpire,
163     oAskCertExpire,
164     oNoAskCertExpire,
165     oDefCertLevel,
166     oMinCertLevel,
167     oAskCertLevel,
168     oNoAskCertLevel,
169     oFingerprint,
170     oWithFingerprint,
171     oWithKeygrip,
172     oAnswerYes,
173     oAnswerNo,
174     oKeyring,
175     oPrimaryKeyring,
176     oSecretKeyring,
177     oShowKeyring,
178     oDefaultKey,
179     oDefRecipient,
180     oDefRecipientSelf,
181     oNoDefRecipient,
182     oTrySecretKey,
183     oOptions,
184     oDebug,
185     oDebugLevel,
186     oDebugAll,
187     oDebugCCIDDriver,
188     oStatusFD,
189     oStatusFile,
190     oAttributeFD,
191     oAttributeFile,
192     oEmitVersion,
193     oNoEmitVersion,
194     oCompletesNeeded,
195     oMarginalsNeeded,
196     oMaxCertDepth,
197     oLoadExtension,
198     oGnuPG,
199     oRFC1991,
200     oRFC2440,
201     oRFC4880,
202     oOpenPGP,
203     oPGP2,
204     oPGP6,
205     oPGP7,
206     oPGP8,
207     oRFC2440Text,
208     oNoRFC2440Text,
209     oCipherAlgo,
210     oDigestAlgo,
211     oCertDigestAlgo,
212     oCompressAlgo,
213     oCompressLevel,
214     oBZ2CompressLevel,
215     oBZ2DecompressLowmem,
216     oPassphrase,
217     oPassphraseFD,
218     oPassphraseFile,
219     oPassphraseRepeat,
220     oCommandFD,
221     oCommandFile,
222     oQuickRandom,
223     oNoVerbose,
224     oTrustDBName,
225     oNoSecmemWarn,
226     oRequireSecmem,
227     oNoRequireSecmem,
228     oNoPermissionWarn,
229     oNoMDCWarn,
230     oNoArmor,
231     oNoDefKeyring,
232     oNoGreeting,
233     oNoTTY,
234     oNoOptions,
235     oNoBatch,
236     oHomedir,
237     oWithColons,
238     oWithKeyData,
239     oWithSigList,
240     oWithSigCheck,
241     oSkipVerify,
242     oSkipHiddenRecipients,
243     oNoSkipHiddenRecipients,
244     oCompressKeys,
245     oCompressSigs,
246     oAlwaysTrust,
247     oTrustModel,
248     oForceOwnertrust,
249     oSetFilename,
250     oForYourEyesOnly,
251     oNoForYourEyesOnly,
252     oSetPolicyURL,
253     oSigPolicyURL,
254     oCertPolicyURL,
255     oShowPolicyURL,
256     oNoShowPolicyURL,
257     oSigKeyserverURL,
258     oUseEmbeddedFilename,
259     oNoUseEmbeddedFilename,
260     oComment,
261     oDefaultComment,
262     oNoComments,
263     oThrowKeyids,
264     oNoThrowKeyids,
265     oShowPhotos,
266     oNoShowPhotos,
267     oPhotoViewer,
268     oForceV3Sigs,
269     oNoForceV3Sigs,
270     oForceV4Certs,
271     oNoForceV4Certs,
272     oForceMDC,
273     oNoForceMDC,
274     oDisableMDC,
275     oNoDisableMDC,
276     oS2KMode,
277     oS2KDigest,
278     oS2KCipher,
279     oS2KCount,
280     oDisplayCharset,
281     oNotDashEscaped,
282     oEscapeFrom,
283     oNoEscapeFrom,
284     oLockOnce,
285     oLockMultiple,
286     oLockNever,
287     oKeyServer,
288     oKeyServerOptions,
289     oImportOptions,
290     oExportOptions,
291     oListOptions,
292     oVerifyOptions,
293     oTempDir,
294     oExecPath,
295     oEncryptTo,
296     oHiddenEncryptTo,
297     oNoEncryptTo,
298     oLoggerFD,
299     oLoggerFile,
300     oUtf8Strings,
301     oNoUtf8Strings,
302     oDisableCipherAlgo,
303     oDisablePubkeyAlgo,
304     oAllowNonSelfsignedUID,
305     oNoAllowNonSelfsignedUID,
306     oAllowFreeformUID,
307     oNoAllowFreeformUID,
308     oAllowSecretKeyImport,
309     oEnableSpecialFilenames,
310     oNoLiteral,
311     oSetFilesize,
312     oHonorHttpProxy,
313     oFastListMode,
314     oListOnly,
315     oIgnoreTimeConflict,
316     oIgnoreValidFrom,
317     oIgnoreCrcError,
318     oIgnoreMDCError,
319     oShowSessionKey,
320     oOverrideSessionKey,
321     oNoRandomSeedFile,
322     oAutoKeyRetrieve,
323     oNoAutoKeyRetrieve,
324     oUseAgent,
325     oNoUseAgent,
326     oGpgAgentInfo,
327     oMergeOnly,
328     oTryAllSecrets,
329     oTrustedKey,
330     oNoExpensiveTrustChecks,
331     oFixedListMode,
332     oNoSigCache,
333     oNoSigCreateCheck,
334     oAutoCheckTrustDB,
335     oNoAutoCheckTrustDB,
336     oPreservePermissions,
337     oDefaultPreferenceList,
338     oDefaultKeyserverURL,
339     oPersonalCipherPreferences,
340     oPersonalDigestPreferences,
341     oPersonalCompressPreferences,
342     oAgentProgram,
343     oDisplay,
344     oTTYname,
345     oTTYtype,
346     oLCctype,
347     oLCmessages,
348     oXauthority,
349     oGroup,
350     oUnGroup,
351     oNoGroups,
352     oStrict,
353     oNoStrict,
354     oMangleDosFilenames,
355     oNoMangleDosFilenames,
356     oEnableProgressFilter,
357     oMultifile,
358     oKeyidFormat,
359     oExitOnStatusWriteError,
360     oLimitCardInsertTries,
361     oRequireCrossCert,
362     oNoRequireCrossCert,
363     oAutoKeyLocate,
364     oNoAutoKeyLocate,
365     oAllowMultisigVerification,
366     oEnableDSA2,
367     oDisableDSA2,
368     oAllowMultipleMessages,
369     oNoAllowMultipleMessages,
370     oFakedSystemTime,
371
372     oNoop
373   };
374
375
376 static ARGPARSE_OPTS opts[] = {
377
378   ARGPARSE_group (300, N_("@Commands:\n ")),
379
380   ARGPARSE_c (aSign, "sign", N_("make a signature")),
381   ARGPARSE_c (aClearsign, "clearsign", N_("make a clear text signature")),
382   ARGPARSE_c (aDetachedSign, "detach-sign", N_("make a detached signature")),
383   ARGPARSE_c (aEncr, "encrypt",   N_("encrypt data")),
384   ARGPARSE_c (aEncrFiles, "encrypt-files", "@"),
385   ARGPARSE_c (aSym, "symmetric", N_("encryption only with symmetric cipher")),
386   ARGPARSE_c (aStore, "store",     "@"),
387   ARGPARSE_c (aDecrypt, "decrypt",   N_("decrypt data (default)")),
388   ARGPARSE_c (aDecryptFiles, "decrypt-files", "@"),
389   ARGPARSE_c (aVerify, "verify"   , N_("verify a signature")),
390   ARGPARSE_c (aVerifyFiles, "verify-files" , "@" ),
391   ARGPARSE_c (aListKeys, "list-keys", N_("list keys")),
392   ARGPARSE_c (aListKeys, "list-public-keys", "@" ),
393   ARGPARSE_c (aListSigs, "list-sigs", N_("list keys and signatures")),
394   ARGPARSE_c (aCheckKeys, "check-sigs",N_("list and check key signatures")),
395   ARGPARSE_c (oFingerprint, "fingerprint", N_("list keys and fingerprints")),
396   ARGPARSE_c (aListSecretKeys, "list-secret-keys", N_("list secret keys")),
397   ARGPARSE_c (aKeygen,     "gen-key",  N_("generate a new key pair")),
398   ARGPARSE_c (aGenRevoke, "gen-revoke",N_("generate a revocation certificate")),
399   ARGPARSE_c (aDeleteKeys,"delete-keys",
400               N_("remove keys from the public keyring")),
401   ARGPARSE_c (aDeleteSecretKeys, "delete-secret-keys",
402               N_("remove keys from the secret keyring")),
403   ARGPARSE_c (aSignKey,  "sign-key"   ,N_("sign a key")),
404   ARGPARSE_c (aLSignKey, "lsign-key"  ,N_("sign a key locally")),
405   ARGPARSE_c (aEditKey,  "edit-key"   ,N_("sign or edit a key")),
406   ARGPARSE_c (aEditKey,  "key-edit"   ,"@"),
407   ARGPARSE_c (aPasswd,   "passwd",     N_("change a passphrase")),
408   ARGPARSE_c (aDesigRevoke, "desig-revoke","@" ),
409   ARGPARSE_c (aExport, "export"           , N_("export keys") ),
410   ARGPARSE_c (aSendKeys, "send-keys"     , N_("export keys to a key server") ),
411   ARGPARSE_c (aRecvKeys, "recv-keys"     , N_("import keys from a key server") ),
412   ARGPARSE_c (aSearchKeys, "search-keys" ,
413               N_("search for keys on a key server") ),
414   ARGPARSE_c (aRefreshKeys, "refresh-keys",
415               N_("update all keys from a keyserver")),
416   ARGPARSE_c (aLocateKeys, "locate-keys", "@"),
417   ARGPARSE_c (aFetchKeys, "fetch-keys" , "@" ),
418   ARGPARSE_c (aExportSecret, "export-secret-keys" , "@" ),
419   ARGPARSE_c (aExportSecretSub, "export-secret-subkeys" , "@" ),
420   ARGPARSE_c (aImport, "import", N_("import/merge keys")),
421   ARGPARSE_c (aFastImport, "fast-import", "@"),
422 #ifdef ENABLE_CARD_SUPPORT
423   ARGPARSE_c (aCardStatus,  "card-status", N_("print the card status")),
424   ARGPARSE_c (aCardEdit,   "card-edit",  N_("change data on a card")),
425   ARGPARSE_c (aChangePIN,  "change-pin", N_("change a card's PIN")),
426 #endif
427   ARGPARSE_c (aListConfig, "list-config", "@"),
428   ARGPARSE_c (aGPGConfList, "gpgconf-list", "@" ),
429   ARGPARSE_c (aGPGConfTest, "gpgconf-test", "@" ),
430   ARGPARSE_c (aListPackets, "list-packets","@"),
431   ARGPARSE_c (aExportOwnerTrust, "export-ownertrust", "@"),
432   ARGPARSE_c (aImportOwnerTrust, "import-ownertrust", "@"),
433   ARGPARSE_c (aUpdateTrustDB,"update-trustdb",
434               N_("update the trust database")),
435   ARGPARSE_c (aCheckTrustDB, "check-trustdb", "@"),
436   ARGPARSE_c (aFixTrustDB, "fix-trustdb", "@"),
437   ARGPARSE_c (aDeArmor, "dearmor", "@"),
438   ARGPARSE_c (aDeArmor, "dearmour", "@"),
439   ARGPARSE_c (aEnArmor, "enarmor", "@"),
440   ARGPARSE_c (aEnArmor, "enarmour", "@"),
441   ARGPARSE_c (aPrintMD, "print-md", N_("print message digests")),
442   ARGPARSE_c (aPrimegen, "gen-prime", "@" ),
443   ARGPARSE_c (aGenRandom,"gen-random", "@" ),
444   ARGPARSE_c (aServer,   "server",  N_("run in server mode")),
445
446   ARGPARSE_group (301, N_("@\nOptions:\n ")),
447
448   ARGPARSE_s_n (oArmor, "armor", N_("create ascii armored output")),
449   ARGPARSE_s_n (oArmor, "armour", "@"),
450
451   ARGPARSE_s_s (oRecipient, "recipient", N_("|USER-ID|encrypt for USER-ID")),
452   ARGPARSE_s_s (oHiddenRecipient, "hidden-recipient", "@"),
453   ARGPARSE_s_s (oRecipient, "remote-user", "@"),  /* (old option name) */
454   ARGPARSE_s_s (oDefRecipient, "default-recipient", "@"),
455   ARGPARSE_s_n (oDefRecipientSelf,  "default-recipient-self", "@"),
456   ARGPARSE_s_n (oNoDefRecipient, "no-default-recipient", "@"),
457
458   ARGPARSE_s_s (oTempDir,  "temp-directory", "@"),
459   ARGPARSE_s_s (oExecPath, "exec-path", "@"),
460   ARGPARSE_s_s (oEncryptTo,      "encrypt-to", "@"),
461   ARGPARSE_s_n (oNoEncryptTo, "no-encrypt-to", "@"),
462   ARGPARSE_s_s (oHiddenEncryptTo, "hidden-encrypt-to", "@"),
463   ARGPARSE_s_s (oLocalUser, "local-user",
464                 N_("|USER-ID|use USER-ID to sign or decrypt")),
465
466   ARGPARSE_s_s (oTrySecretKey, "try-secret-key", "@"),
467
468   ARGPARSE_s_i (oCompress, NULL,
469                 N_("|N|set compress level to N (0 disables)")),
470   ARGPARSE_s_i (oCompressLevel, "compress-level", "@"),
471   ARGPARSE_s_i (oBZ2CompressLevel, "bzip2-compress-level", "@"),
472   ARGPARSE_s_n (oBZ2DecompressLowmem, "bzip2-decompress-lowmem", "@"),
473
474   ARGPARSE_s_n (oTextmodeShort, NULL, "@"),
475   ARGPARSE_s_n (oTextmode,      "textmode", N_("use canonical text mode")),
476   ARGPARSE_s_n (oNoTextmode, "no-textmode", "@"),
477
478   ARGPARSE_s_n (oExpert,      "expert", "@"),
479   ARGPARSE_s_n (oNoExpert, "no-expert", "@"),
480
481   ARGPARSE_s_s (oDefSigExpire, "default-sig-expire", "@"),
482   ARGPARSE_s_n (oAskSigExpire,      "ask-sig-expire", "@"),
483   ARGPARSE_s_n (oNoAskSigExpire, "no-ask-sig-expire", "@"),
484   ARGPARSE_s_s (oDefCertExpire, "default-cert-expire", "@"),
485   ARGPARSE_s_n (oAskCertExpire,      "ask-cert-expire", "@"),
486   ARGPARSE_s_n (oNoAskCertExpire, "no-ask-cert-expire", "@"),
487   ARGPARSE_s_i (oDefCertLevel, "default-cert-level", "@"),
488   ARGPARSE_s_i (oMinCertLevel, "min-cert-level", "@"),
489   ARGPARSE_s_n (oAskCertLevel,      "ask-cert-level", "@"),
490   ARGPARSE_s_n (oNoAskCertLevel, "no-ask-cert-level", "@"),
491
492   ARGPARSE_s_s (oOutput, "output", N_("|FILE|write output to FILE")),
493   ARGPARSE_p_u (oMaxOutput, "max-output", "@"),
494
495   ARGPARSE_s_n (oVerbose, "verbose", N_("verbose")),
496   ARGPARSE_s_n (oQuiet,   "quiet",   "@"),
497   ARGPARSE_s_n (oNoTTY,   "no-tty",  "@"),
498
499   ARGPARSE_s_n (oForceV3Sigs,      "force-v3-sigs", "@"),
500   ARGPARSE_s_n (oNoForceV3Sigs, "no-force-v3-sigs", "@"),
501   ARGPARSE_s_n (oForceV4Certs,     "force-v4-certs", "@"),
502   ARGPARSE_s_n (oNoForceV4Certs, "no-force-v4-certs", "@"),
503   ARGPARSE_s_n (oForceMDC, "force-mdc", "@"),
504   ARGPARSE_s_n (oNoForceMDC, "no-force-mdc", "@"),
505   ARGPARSE_s_n (oDisableMDC, "disable-mdc", "@"),
506   ARGPARSE_s_n (oNoDisableMDC, "no-disable-mdc", "@"),
507
508   ARGPARSE_s_n (oDryRun, "dry-run", N_("do not make any changes")),
509   ARGPARSE_s_n (oInteractive, "interactive", N_("prompt before overwriting")),
510
511   ARGPARSE_s_n (oUseAgent,      "use-agent", "@"),
512   ARGPARSE_s_n (oNoUseAgent, "no-use-agent", "@"),
513   ARGPARSE_s_s (oGpgAgentInfo, "gpg-agent-info", "@"),
514
515   ARGPARSE_s_n (oBatch, "batch", "@"),
516   ARGPARSE_s_n (oAnswerYes, "yes", "@"),
517   ARGPARSE_s_n (oAnswerNo, "no", "@"),
518   ARGPARSE_s_s (oKeyring, "keyring", "@"),
519   ARGPARSE_s_s (oPrimaryKeyring, "primary-keyring", "@"),
520   ARGPARSE_s_s (oSecretKeyring, "secret-keyring", "@"),
521   ARGPARSE_s_n (oShowKeyring, "show-keyring", "@"),
522   ARGPARSE_s_s (oDefaultKey, "default-key", "@"),
523
524   ARGPARSE_s_s (oKeyServer, "keyserver", "@"),
525   ARGPARSE_s_s (oKeyServerOptions, "keyserver-options", "@"),
526   ARGPARSE_s_s (oImportOptions, "import-options", "@"),
527   ARGPARSE_s_s (oExportOptions, "export-options", "@"),
528   ARGPARSE_s_s (oListOptions,   "list-options", "@"),
529   ARGPARSE_s_s (oVerifyOptions, "verify-options", "@"),
530
531   ARGPARSE_s_s (oDisplayCharset, "display-charset", "@"),
532   ARGPARSE_s_s (oDisplayCharset, "charset", "@"),
533   ARGPARSE_s_s (oOptions, "options", "@"),
534
535   ARGPARSE_p_u (oDebug, "debug", "@"),
536   ARGPARSE_s_s (oDebugLevel, "debug-level", "@"),
537   ARGPARSE_s_n (oDebugAll, "debug-all", "@"),
538   ARGPARSE_s_i (oStatusFD, "status-fd", "@"),
539   ARGPARSE_s_s (oStatusFile, "status-file", "@"),
540   ARGPARSE_s_i (oAttributeFD, "attribute-fd", "@"),
541   ARGPARSE_s_s (oAttributeFile, "attribute-file", "@"),
542
543   ARGPARSE_s_n (oNoop, "sk-comments", "@"),
544   ARGPARSE_s_n (oNoop, "no-sk-comments", "@"),
545
546   ARGPARSE_s_i (oCompletesNeeded, "completes-needed", "@"),
547   ARGPARSE_s_i (oMarginalsNeeded, "marginals-needed", "@"),
548   ARGPARSE_s_i (oMaxCertDepth,  "max-cert-depth", "@" ),
549   ARGPARSE_s_s (oTrustedKey, "trusted-key", "@"),
550
551   ARGPARSE_s_s (oLoadExtension, "load-extension", "@"),  /* Dummy.  */
552
553   ARGPARSE_s_n (oGnuPG, "gnupg",   "@"),
554   ARGPARSE_s_n (oGnuPG, "no-pgp2", "@"),
555   ARGPARSE_s_n (oGnuPG, "no-pgp6", "@"),
556   ARGPARSE_s_n (oGnuPG, "no-pgp7", "@"),
557   ARGPARSE_s_n (oGnuPG, "no-pgp8", "@"),
558   ARGPARSE_s_n (oRFC1991, "rfc1991", "@"),
559   ARGPARSE_s_n (oRFC2440, "rfc2440", "@"),
560   ARGPARSE_s_n (oRFC4880, "rfc4880", "@"),
561   ARGPARSE_s_n (oOpenPGP, "openpgp", N_("use strict OpenPGP behavior")),
562   ARGPARSE_s_n (oPGP2, "pgp2", "@"),
563   ARGPARSE_s_n (oPGP6, "pgp6", "@"),
564   ARGPARSE_s_n (oPGP7, "pgp7", "@"),
565   ARGPARSE_s_n (oPGP8, "pgp8", "@"),
566
567   ARGPARSE_s_n (oRFC2440Text,      "rfc2440-text", "@"),
568   ARGPARSE_s_n (oNoRFC2440Text, "no-rfc2440-text", "@"),
569   ARGPARSE_s_i (oS2KMode, "s2k-mode", "@"),
570   ARGPARSE_s_s (oS2KDigest, "s2k-digest-algo", "@"),
571   ARGPARSE_s_s (oS2KCipher, "s2k-cipher-algo", "@"),
572   ARGPARSE_s_i (oS2KCount, "s2k-count", "@"),
573   ARGPARSE_s_s (oCipherAlgo, "cipher-algo", "@"),
574   ARGPARSE_s_s (oDigestAlgo, "digest-algo", "@"),
575   ARGPARSE_s_s (oCertDigestAlgo, "cert-digest-algo", "@"),
576   ARGPARSE_s_s (oCompressAlgo,"compress-algo", "@"),
577   ARGPARSE_s_s (oCompressAlgo, "compression-algo", "@"), /* Alias */
578   ARGPARSE_s_n (oThrowKeyids, "throw-keyid", "@"),
579   ARGPARSE_s_n (oThrowKeyids, "throw-keyids", "@"),
580   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyid", "@"),
581   ARGPARSE_s_n (oNoThrowKeyids, "no-throw-keyids", "@"),
582   ARGPARSE_s_n (oShowPhotos,   "show-photos", "@"),
583   ARGPARSE_s_n (oNoShowPhotos, "no-show-photos", "@"),
584   ARGPARSE_s_s (oPhotoViewer,  "photo-viewer", "@"),
585   ARGPARSE_s_s (oSetNotation,  "set-notation", "@"),
586   ARGPARSE_s_s (oSetNotation,  "notation-data", "@"), /* Alias */
587   ARGPARSE_s_s (oSigNotation,  "sig-notation", "@"),
588   ARGPARSE_s_s (oCertNotation, "cert-notation", "@"),
589
590   ARGPARSE_group (302, N_(
591   "@\n(See the man page for a complete listing of all commands and options)\n"
592                       )),
593
594   ARGPARSE_group (303, N_("@\nExamples:\n\n"
595     " -se -r Bob [file]          sign and encrypt for user Bob\n"
596     " --clearsign [file]         make a clear text signature\n"
597     " --detach-sign [file]       make a detached signature\n"
598     " --list-keys [names]        show keys\n"
599     " --fingerprint [names]      show fingerprints\n")),
600
601   /* More hidden commands and options. */
602   ARGPARSE_c (aPrintMDs, "print-mds", "@"), /* old */
603   ARGPARSE_c (aListTrustDB, "list-trustdb", "@"),
604   /* Not yet used:
605      ARGPARSE_c (aListTrustPath, "list-trust-path", "@"), */
606   ARGPARSE_c (aDeleteSecretAndPublicKeys,
607               "delete-secret-and-public-keys", "@"),
608   ARGPARSE_c (aRebuildKeydbCaches, "rebuild-keydb-caches", "@"),
609
610   ARGPARSE_s_s (oPassphrase,      "passphrase", "@"),
611   ARGPARSE_s_i (oPassphraseFD,    "passphrase-fd", "@"),
612   ARGPARSE_s_s (oPassphraseFile,  "passphrase-file", "@"),
613   ARGPARSE_s_i (oPassphraseRepeat,"passphrase-repeat", "@"),
614   ARGPARSE_s_i (oCommandFD, "command-fd", "@"),
615   ARGPARSE_s_s (oCommandFile, "command-file", "@"),
616   ARGPARSE_s_n (oQuickRandom, "debug-quick-random", "@"),
617   ARGPARSE_s_n (oNoVerbose, "no-verbose", "@"),
618   ARGPARSE_s_s (oTrustDBName, "trustdb-name", "@"),
619   ARGPARSE_s_n (oNoSecmemWarn, "no-secmem-warning", "@"),
620   ARGPARSE_s_n (oRequireSecmem, "require-secmem", "@"),
621   ARGPARSE_s_n (oNoRequireSecmem, "no-require-secmem", "@"),
622   ARGPARSE_s_n (oNoPermissionWarn, "no-permission-warning", "@"),
623   ARGPARSE_s_n (oNoMDCWarn, "no-mdc-warning", "@"),
624   ARGPARSE_s_n (oNoArmor, "no-armor", "@"),
625   ARGPARSE_s_n (oNoArmor, "no-armour", "@"),
626   ARGPARSE_s_n (oNoDefKeyring, "no-default-keyring", "@"),
627   ARGPARSE_s_n (oNoGreeting, "no-greeting", "@"),
628   ARGPARSE_s_n (oNoOptions, "no-options", "@"),
629   ARGPARSE_s_s (oHomedir, "homedir", "@"),
630   ARGPARSE_s_n (oNoBatch, "no-batch", "@"),
631   ARGPARSE_s_n (oWithColons, "with-colons", "@"),
632   ARGPARSE_s_n (oWithKeyData,"with-key-data", "@"),
633   ARGPARSE_s_n (oWithSigList,"with-sig-list", "@"),
634   ARGPARSE_s_n (oWithSigCheck,"with-sig-check", "@"),
635   ARGPARSE_s_n (aListKeys, "list-key", "@"),   /* alias */
636   ARGPARSE_s_n (aListSigs, "list-sig", "@"),   /* alias */
637   ARGPARSE_s_n (aCheckKeys, "check-sig", "@"), /* alias */
638   ARGPARSE_s_n (oSkipVerify, "skip-verify", "@"),
639   ARGPARSE_s_n (oSkipHiddenRecipients, "skip-hidden-recipients", "@"),
640   ARGPARSE_s_n (oNoSkipHiddenRecipients, "no-skip-hidden-recipients", "@"),
641   ARGPARSE_s_n (oCompressKeys, "compress-keys", "@"),
642   ARGPARSE_s_n (oCompressSigs, "compress-sigs", "@"),
643   ARGPARSE_s_i (oDefCertLevel, "default-cert-check-level", "@"), /* old */
644   ARGPARSE_s_n (oAlwaysTrust, "always-trust", "@"),
645   ARGPARSE_s_s (oTrustModel, "trust-model", "@"),
646   ARGPARSE_s_s (oForceOwnertrust, "force-ownertrust", "@"),
647   ARGPARSE_s_s (oSetFilename, "set-filename", "@"),
648   ARGPARSE_s_n (oForYourEyesOnly, "for-your-eyes-only", "@"),
649   ARGPARSE_s_n (oNoForYourEyesOnly, "no-for-your-eyes-only", "@"),
650   ARGPARSE_s_s (oSetPolicyURL,  "set-policy-url", "@"),
651   ARGPARSE_s_s (oSigPolicyURL,  "sig-policy-url", "@"),
652   ARGPARSE_s_s (oCertPolicyURL, "cert-policy-url", "@"),
653   ARGPARSE_s_n (oShowPolicyURL,      "show-policy-url", "@"),
654   ARGPARSE_s_n (oNoShowPolicyURL, "no-show-policy-url", "@"),
655   ARGPARSE_s_s (oSigKeyserverURL, "sig-keyserver-url", "@"),
656   ARGPARSE_s_n (oShowNotation,      "show-notation", "@"),
657   ARGPARSE_s_n (oNoShowNotation, "no-show-notation", "@"),
658   ARGPARSE_s_s (oComment, "comment", "@"),
659   ARGPARSE_s_n (oDefaultComment, "default-comment", "@"),
660   ARGPARSE_s_n (oNoComments, "no-comments", "@"),
661   ARGPARSE_s_n (oEmitVersion,      "emit-version", "@"),
662   ARGPARSE_s_n (oNoEmitVersion, "no-emit-version", "@"),
663   ARGPARSE_s_n (oNoEmitVersion, "no-version", "@"), /* alias */
664   ARGPARSE_s_n (oNotDashEscaped, "not-dash-escaped", "@"),
665   ARGPARSE_s_n (oEscapeFrom,      "escape-from-lines", "@"),
666   ARGPARSE_s_n (oNoEscapeFrom, "no-escape-from-lines", "@"),
667   ARGPARSE_s_n (oLockOnce,     "lock-once", "@"),
668   ARGPARSE_s_n (oLockMultiple, "lock-multiple", "@"),
669   ARGPARSE_s_n (oLockNever,    "lock-never", "@"),
670   ARGPARSE_s_i (oLoggerFD,   "logger-fd", "@"),
671   ARGPARSE_s_s (oLoggerFile, "log-file", "@"),
672   ARGPARSE_s_s (oLoggerFile, "logger-file", "@"),  /* 1.4 compatibility.  */
673   ARGPARSE_s_n (oUseEmbeddedFilename,      "use-embedded-filename", "@"),
674   ARGPARSE_s_n (oNoUseEmbeddedFilename, "no-use-embedded-filename", "@"),
675   ARGPARSE_s_n (oUtf8Strings,      "utf8-strings", "@"),
676   ARGPARSE_s_n (oNoUtf8Strings, "no-utf8-strings", "@"),
677   ARGPARSE_s_n (oWithFingerprint, "with-fingerprint", "@"),
678   ARGPARSE_s_n (oWithKeygrip,     "with-keygrip", "@"),
679   ARGPARSE_s_s (oDisableCipherAlgo,  "disable-cipher-algo", "@"),
680   ARGPARSE_s_s (oDisablePubkeyAlgo,  "disable-pubkey-algo", "@"),
681   ARGPARSE_s_n (oAllowNonSelfsignedUID,      "allow-non-selfsigned-uid", "@"),
682   ARGPARSE_s_n (oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", "@"),
683   ARGPARSE_s_n (oAllowFreeformUID,      "allow-freeform-uid", "@"),
684   ARGPARSE_s_n (oNoAllowFreeformUID, "no-allow-freeform-uid", "@"),
685   ARGPARSE_s_n (oNoLiteral, "no-literal", "@"),
686   ARGPARSE_p_u (oSetFilesize, "set-filesize", "@"),
687   ARGPARSE_s_n (oHonorHttpProxy, "honor-http-proxy", "@"),
688   ARGPARSE_s_n (oFastListMode, "fast-list-mode", "@"),
689   ARGPARSE_s_n (oFixedListMode, "fixed-list-mode", "@"),
690   ARGPARSE_s_n (oListOnly, "list-only", "@"),
691   ARGPARSE_s_n (oIgnoreTimeConflict, "ignore-time-conflict", "@"),
692   ARGPARSE_s_n (oIgnoreValidFrom,    "ignore-valid-from", "@"),
693   ARGPARSE_s_n (oIgnoreCrcError, "ignore-crc-error", "@"),
694   ARGPARSE_s_n (oIgnoreMDCError, "ignore-mdc-error", "@"),
695   ARGPARSE_s_n (oShowSessionKey, "show-session-key", "@"),
696   ARGPARSE_s_s (oOverrideSessionKey, "override-session-key", "@"),
697   ARGPARSE_s_n (oNoRandomSeedFile,  "no-random-seed-file", "@"),
698   ARGPARSE_s_n (oAutoKeyRetrieve, "auto-key-retrieve", "@"),
699   ARGPARSE_s_n (oNoAutoKeyRetrieve, "no-auto-key-retrieve", "@"),
700   ARGPARSE_s_n (oNoSigCache,         "no-sig-cache", "@"),
701   ARGPARSE_s_n (oNoSigCreateCheck,   "no-sig-create-check", "@"),
702   ARGPARSE_s_n (oAutoCheckTrustDB, "auto-check-trustdb", "@"),
703   ARGPARSE_s_n (oNoAutoCheckTrustDB, "no-auto-check-trustdb", "@"),
704   ARGPARSE_s_n (oMergeOnly,       "merge-only", "@" ),
705   ARGPARSE_s_n (oAllowSecretKeyImport, "allow-secret-key-import", "@"),
706   ARGPARSE_s_n (oTryAllSecrets,  "try-all-secrets", "@"),
707   ARGPARSE_s_n (oEnableSpecialFilenames, "enable-special-filenames", "@"),
708   ARGPARSE_s_n (oNoExpensiveTrustChecks, "no-expensive-trust-checks", "@"),
709   ARGPARSE_s_n (oPreservePermissions, "preserve-permissions", "@"),
710   ARGPARSE_s_s (oDefaultPreferenceList,  "default-preference-list", "@"),
711   ARGPARSE_s_s (oDefaultKeyserverURL,  "default-keyserver-url", "@"),
712   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-preferences","@"),
713   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-preferences","@"),
714   ARGPARSE_s_s (oPersonalCompressPreferences,
715                                          "personal-compress-preferences", "@"),
716   ARGPARSE_s_s (oFakedSystemTime, "faked-system-time", "@"),
717
718   /* Aliases.  I constantly mistype these, and assume other people do
719      as well. */
720   ARGPARSE_s_s (oPersonalCipherPreferences, "personal-cipher-prefs", "@"),
721   ARGPARSE_s_s (oPersonalDigestPreferences, "personal-digest-prefs", "@"),
722   ARGPARSE_s_s (oPersonalCompressPreferences, "personal-compress-prefs", "@"),
723   ARGPARSE_s_s (oAgentProgram, "agent-program", "@"),
724   ARGPARSE_s_s (oDisplay,    "display",    "@"),
725   ARGPARSE_s_s (oTTYname,    "ttyname",    "@"),
726   ARGPARSE_s_s (oTTYtype,    "ttytype",    "@"),
727   ARGPARSE_s_s (oLCctype,    "lc-ctype",   "@"),
728   ARGPARSE_s_s (oLCmessages, "lc-messages","@"),
729   ARGPARSE_s_s (oXauthority, "xauthority", "@"),
730   ARGPARSE_s_s (oGroup,      "group",      "@"),
731   ARGPARSE_s_s (oUnGroup,    "ungroup",    "@"),
732   ARGPARSE_s_n (oNoGroups,   "no-groups",  "@"),
733   ARGPARSE_s_n (oStrict,     "strict",     "@"),
734   ARGPARSE_s_n (oNoStrict,   "no-strict",  "@"),
735   ARGPARSE_s_n (oMangleDosFilenames,      "mangle-dos-filenames", "@"),
736   ARGPARSE_s_n (oNoMangleDosFilenames, "no-mangle-dos-filenames", "@"),
737   ARGPARSE_s_n (oEnableProgressFilter, "enable-progress-filter", "@"),
738   ARGPARSE_s_n (oMultifile, "multifile", "@"),
739   ARGPARSE_s_s (oKeyidFormat, "keyid-format", "@"),
740   ARGPARSE_s_n (oExitOnStatusWriteError, "exit-on-status-write-error", "@"),
741   ARGPARSE_s_i (oLimitCardInsertTries, "limit-card-insert-tries", "@"),
742
743   ARGPARSE_s_n (oAllowMultisigVerification,
744                 "allow-multisig-verification", "@"),
745   ARGPARSE_s_n (oEnableDSA2, "enable-dsa2", "@"),
746   ARGPARSE_s_n (oDisableDSA2, "disable-dsa2", "@"),
747   ARGPARSE_s_n (oAllowMultipleMessages,      "allow-multiple-messages", "@"),
748   ARGPARSE_s_n (oNoAllowMultipleMessages, "no-allow-multiple-messages", "@"),
749
750   /* These two are aliases to help users of the PGP command line
751      product use gpg with minimal pain.  Many commands are common
752      already as they seem to have borrowed commands from us.  Now I'm
753      returning the favor. */
754   ARGPARSE_s_s (oLocalUser, "sign-with", "@"),
755   ARGPARSE_s_s (oRecipient, "user", "@"),
756
757   ARGPARSE_s_n (oRequireCrossCert, "require-backsigs", "@"),
758   ARGPARSE_s_n (oRequireCrossCert, "require-cross-certification", "@"),
759   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-backsigs", "@"),
760   ARGPARSE_s_n (oNoRequireCrossCert, "no-require-cross-certification", "@"),
761
762   /* New options.  Fixme: Should go more to the top.  */
763   ARGPARSE_s_s (oAutoKeyLocate, "auto-key-locate", "@"),
764   ARGPARSE_s_n (oNoAutoKeyLocate, "no-auto-key-locate", "@"),
765
766   ARGPARSE_end ()
767 };
768
769
770 #ifdef ENABLE_SELINUX_HACKS
771 #define ALWAYS_ADD_KEYRINGS 1
772 #else
773 #define ALWAYS_ADD_KEYRINGS 0
774 #endif
775
776
777 int g10_errors_seen = 0;
778
779 static int utf8_strings = 0;
780 static int maybe_setuid = 1;
781
782 static char *build_list( const char *text, char letter,
783                          const char *(*mapf)(int), int (*chkf)(int) );
784 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
785                         enum cmd_and_opt_values new_cmd );
786 static void print_mds( const char *fname, int algo );
787 static void add_notation_data( const char *string, int which );
788 static void add_policy_url( const char *string, int which );
789 static void add_keyserver_url( const char *string, int which );
790 static void emergency_cleanup (void);
791
792
793 static char *
794 make_libversion (const char *libname, const char *(*getfnc)(const char*))
795 {
796   const char *s;
797   char *result;
798
799   if (maybe_setuid)
800     {
801       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
802       maybe_setuid = 0;
803     }
804   s = getfnc (NULL);
805   result = xmalloc (strlen (libname) + 1 + strlen (s) + 1);
806   strcpy (stpcpy (stpcpy (result, libname), " "), s);
807   return result;
808 }
809
810
811 static const char *
812 my_strusage( int level )
813 {
814   static char *digests, *pubkeys, *ciphers, *zips, *ver_gcry;
815   const char *p;
816
817     switch( level ) {
818       case 11: p = "gpg (GnuPG)";
819         break;
820       case 13: p = VERSION; break;
821       case 17: p = PRINTABLE_OS_NAME; break;
822       case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
823
824     case 20:
825       if (!ver_gcry)
826         ver_gcry = make_libversion ("libgcrypt", gcry_check_version);
827       p = ver_gcry;
828       break;
829
830 #ifdef IS_DEVELOPMENT_VERSION
831       case 25:
832         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
833         break;
834       case 26:
835         p="It is only intended for test purposes and should NOT be";
836         break;
837       case 27:
838         p="used in a production environment or with production keys!";
839         break;
840 #endif
841
842       case 1:
843       case 40:  p =
844             _("Usage: gpg [options] [files] (-h for help)");
845         break;
846       case 41:  p =
847             _("Syntax: gpg [options] [files]\n"
848               "Sign, check, encrypt or decrypt\n"
849               "Default operation depends on the input data\n");
850         break;
851
852       case 31: p = "\nHome: "; break;
853 #ifndef __riscos__
854       case 32: p = opt.homedir; break;
855 #else /* __riscos__ */
856       case 32: p = make_filename(opt.homedir, NULL); break;
857 #endif /* __riscos__ */
858       case 33: p = _("\nSupported algorithms:\n"); break;
859       case 34:
860         if (!pubkeys)
861             pubkeys = build_list (_("Pubkey: "), 0,
862                                   openpgp_pk_algo_name,
863                                   openpgp_pk_test_algo );
864         p = pubkeys;
865         break;
866       case 35:
867         if( !ciphers )
868             ciphers = build_list(_("Cipher: "), 'S',
869                                  openpgp_cipher_algo_name,
870                                  openpgp_cipher_test_algo );
871         p = ciphers;
872         break;
873       case 36:
874         if( !digests )
875             digests = build_list(_("Hash: "), 'H',
876                                  gcry_md_algo_name,
877                                  openpgp_md_test_algo );
878         p = digests;
879         break;
880       case 37:
881         if( !zips )
882             zips = build_list(_("Compression: "),'Z',
883                               compress_algo_to_string,
884                               check_compress_algo);
885         p = zips;
886         break;
887
888       default:  p = NULL;
889     }
890     return p;
891 }
892
893
894 static char *
895 build_list( const char *text, char letter,
896             const char * (*mapf)(int), int (*chkf)(int) )
897 {
898     int i;
899     const char *s;
900     size_t n=strlen(text)+2;
901     char *list, *p, *line=NULL;
902
903     if (maybe_setuid)
904       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
905
906     for(i=0; i <= 110; i++ )
907         if( !chkf(i) && (s=mapf(i)) )
908             n += strlen(s) + 7 + 2;
909     list = xmalloc( 21 + n ); *list = 0;
910     for(p=NULL, i=0; i <= 110; i++ ) {
911         if( !chkf(i) && (s=mapf(i)) ) {
912             if( !p ) {
913                 p = stpcpy( list, text );
914                 line=p;
915             }
916             else
917                 p = stpcpy( p, ", ");
918
919             if(strlen(line)>60) {
920               int spaces=strlen(text);
921
922               list=xrealloc(list,n+spaces+1);
923               /* realloc could move the block, so find the end again */
924               p=list;
925               while(*p)
926                 p++;
927
928               p=stpcpy(p, "\n");
929               line=p;
930               for(;spaces;spaces--)
931                 p=stpcpy(p, " ");
932             }
933
934             p = stpcpy(p, s );
935             if(opt.verbose && letter)
936               {
937                 char num[8];
938                 sprintf(num," (%c%d)",letter,i);
939                 p = stpcpy(p,num);
940               }
941         }
942     }
943     if( p )
944         p = stpcpy(p, "\n" );
945     return list;
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: opt.passphrase_repeat=pargs.r.ret_int; break;
2598           case oCommandFD:
2599             opt.command_fd = translate_sys2libc_fd_int (pargs.r.ret_int, 0);
2600             break;
2601           case oCommandFile:
2602             opt.command_fd = open_info_file (pargs.r.ret_str, 0, 1);
2603             break;
2604           case oCipherAlgo:
2605             def_cipher_string = xstrdup(pargs.r.ret_str);
2606             break;
2607           case oDigestAlgo:
2608             def_digest_string = xstrdup(pargs.r.ret_str);
2609             break;
2610           case oCompressAlgo:
2611             /* If it is all digits, stick a Z in front of it for
2612                later.  This is for backwards compatibility with
2613                versions that took the compress algorithm number. */
2614             {
2615               char *pt=pargs.r.ret_str;
2616               while(*pt)
2617                 {
2618                   if (!isascii (*pt) || !isdigit (*pt))
2619                     break;
2620
2621                   pt++;
2622                 }
2623
2624               if(*pt=='\0')
2625                 {
2626                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2627                   strcpy(compress_algo_string,"Z");
2628                   strcat(compress_algo_string,pargs.r.ret_str);
2629                 }
2630               else
2631                 compress_algo_string = xstrdup(pargs.r.ret_str);
2632             }
2633             break;
2634           case oCertDigestAlgo:
2635             cert_digest_string = xstrdup(pargs.r.ret_str);
2636             break;
2637
2638           case oNoSecmemWarn:
2639             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN);
2640             break;
2641
2642           case oRequireSecmem: require_secmem=1; break;
2643           case oNoRequireSecmem: require_secmem=0; break;
2644           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2645           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2646           case oDisplayCharset:
2647             if( set_native_charset( pargs.r.ret_str ) )
2648                 log_error(_("'%s' is not a valid character set\n"),
2649                           pargs.r.ret_str);
2650             break;
2651           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2652           case oEscapeFrom: opt.escape_from = 1; break;
2653           case oNoEscapeFrom: opt.escape_from = 0; break;
2654           case oLockOnce: opt.lock_once = 1; break;
2655           case oLockNever:
2656             dotlock_disable ();
2657             break;
2658           case oLockMultiple:
2659 #ifndef __riscos__
2660             opt.lock_once = 0;
2661 #else /* __riscos__ */
2662             riscos_not_implemented("lock-multiple");
2663 #endif /* __riscos__ */
2664             break;
2665           case oKeyServer:
2666             {
2667               keyserver_spec_t keyserver;
2668               keyserver = parse_keyserver_uri (pargs.r.ret_str,0,
2669                                                configname,configlineno);
2670               if (!keyserver)
2671                 log_error (_("could not parse keyserver URL\n"));
2672               else
2673                 {
2674                   keyserver->next = opt.keyserver;
2675                   opt.keyserver = keyserver;
2676                 }
2677             }
2678             break;
2679           case oKeyServerOptions:
2680             if(!parse_keyserver_options(pargs.r.ret_str))
2681               {
2682                 if(configname)
2683                   log_error(_("%s:%d: invalid keyserver options\n"),
2684                             configname,configlineno);
2685                 else
2686                   log_error(_("invalid keyserver options\n"));
2687               }
2688             break;
2689           case oImportOptions:
2690             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2691               {
2692                 if(configname)
2693                   log_error(_("%s:%d: invalid import options\n"),
2694                             configname,configlineno);
2695                 else
2696                   log_error(_("invalid import options\n"));
2697               }
2698             break;
2699           case oExportOptions:
2700             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2701               {
2702                 if(configname)
2703                   log_error(_("%s:%d: invalid export options\n"),
2704                             configname,configlineno);
2705                 else
2706                   log_error(_("invalid export options\n"));
2707               }
2708             break;
2709           case oListOptions:
2710             if(!parse_list_options(pargs.r.ret_str))
2711               {
2712                 if(configname)
2713                   log_error(_("%s:%d: invalid list options\n"),
2714                             configname,configlineno);
2715                 else
2716                   log_error(_("invalid list options\n"));
2717               }
2718             break;
2719           case oVerifyOptions:
2720             {
2721               struct parse_options vopts[]=
2722                 {
2723                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2724                    N_("display photo IDs during signature verification")},
2725                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2726                    N_("show policy URLs during signature verification")},
2727                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2728                    N_("show all notations during signature verification")},
2729                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2730                    N_("show IETF standard notations during signature verification")},
2731                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2732                    NULL},
2733                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2734                    N_("show user-supplied notations during signature verification")},
2735                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2736                    N_("show preferred keyserver URLs during signature verification")},
2737                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2738                    N_("show user ID validity during signature verification")},
2739                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2740                    N_("show revoked and expired user IDs in signature verification")},
2741                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2742                    N_("show only the primary user ID in signature verification")},
2743                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2744                    N_("validate signatures with PKA data")},
2745                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2746                    N_("elevate the trust of signatures with valid PKA data")},
2747                   {NULL,0,NULL,NULL}
2748                 };
2749
2750               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2751                 {
2752                   if(configname)
2753                     log_error(_("%s:%d: invalid verify options\n"),
2754                               configname,configlineno);
2755                   else
2756                     log_error(_("invalid verify options\n"));
2757                 }
2758             }
2759             break;
2760           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2761           case oExecPath:
2762             if(set_exec_path(pargs.r.ret_str))
2763               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2764             else
2765               opt.exec_path_set=1;
2766             break;
2767           case oSetNotation:
2768             add_notation_data( pargs.r.ret_str, 0 );
2769             add_notation_data( pargs.r.ret_str, 1 );
2770             break;
2771           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2772           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2773           case oShowNotation:
2774             deprecated_warning(configname,configlineno,"--show-notation",
2775                                "--list-options ","show-notations");
2776             deprecated_warning(configname,configlineno,"--show-notation",
2777                                "--verify-options ","show-notations");
2778             opt.list_options|=LIST_SHOW_NOTATIONS;
2779             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2780             break;
2781           case oNoShowNotation:
2782             deprecated_warning(configname,configlineno,"--no-show-notation",
2783                                "--list-options ","no-show-notations");
2784             deprecated_warning(configname,configlineno,"--no-show-notation",
2785                                "--verify-options ","no-show-notations");
2786             opt.list_options&=~LIST_SHOW_NOTATIONS;
2787             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2788             break;
2789           case oUtf8Strings: utf8_strings = 1; break;
2790           case oNoUtf8Strings: utf8_strings = 0; break;
2791           case oDisableCipherAlgo:
2792             {
2793               int algo = string_to_cipher_algo (pargs.r.ret_str);
2794               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2795             }
2796             break;
2797           case oDisablePubkeyAlgo:
2798             {
2799               int algo = gcry_pk_map_name (pargs.r.ret_str);
2800               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2801             }
2802             break;
2803           case oNoSigCache: opt.no_sig_cache = 1; break;
2804           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2805           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2806           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2807           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2808           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2809           case oNoLiteral: opt.no_literal = 1; break;
2810           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2811           case oHonorHttpProxy:
2812                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2813                 deprecated_warning(configname,configlineno,
2814                                    "--honor-http-proxy",
2815                                    "--keyserver-options ","http-proxy");
2816                 break;
2817           case oFastListMode: opt.fast_list_mode = 1; break;
2818           case oFixedListMode: /* Dummy */ break;
2819           case oListOnly: opt.list_only=1; break;
2820           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2821           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2822           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2823           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2824           case oNoRandomSeedFile: use_random_seed = 0; break;
2825           case oAutoKeyRetrieve:
2826           case oNoAutoKeyRetrieve:
2827                 if(pargs.r_opt==oAutoKeyRetrieve)
2828                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2829                 else
2830                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2831
2832                 deprecated_warning(configname,configlineno,
2833                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2834                                "--no-auto-key-retrieve","--keyserver-options ",
2835                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2836                                "no-auto-key-retrieve");
2837                 break;
2838           case oShowSessionKey: opt.show_session_key = 1; break;
2839           case oOverrideSessionKey:
2840                 opt.override_session_key = pargs.r.ret_str;
2841                 break;
2842           case oMergeOnly:
2843                 deprecated_warning(configname,configlineno,"--merge-only",
2844                                    "--import-options ","merge-only");
2845                 opt.import_options|=IMPORT_MERGE_ONLY;
2846             break;
2847           case oAllowSecretKeyImport: /* obsolete */ break;
2848           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2849           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2850           case oEnableSpecialFilenames:
2851             iobuf_enable_special_filenames (1);
2852             break;
2853           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2854           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2855           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2856           case oPreservePermissions: opt.preserve_permissions=1; break;
2857           case oDefaultPreferenceList:
2858             opt.def_preference_list = pargs.r.ret_str;
2859             break;
2860           case oDefaultKeyserverURL:
2861             {
2862               keyserver_spec_t keyserver;
2863               keyserver = parse_keyserver_uri (pargs.r.ret_str,1,
2864                                                configname,configlineno);
2865               if (!keyserver)
2866                 log_error (_("could not parse keyserver URL\n"));
2867               else
2868                 free_keyserver_spec (keyserver);
2869
2870               opt.def_keyserver_url = pargs.r.ret_str;
2871             }
2872             break;
2873           case oPersonalCipherPreferences:
2874             pers_cipher_list=pargs.r.ret_str;
2875             break;
2876           case oPersonalDigestPreferences:
2877             pers_digest_list=pargs.r.ret_str;
2878             break;
2879           case oPersonalCompressPreferences:
2880             pers_compress_list=pargs.r.ret_str;
2881             break;
2882           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2883
2884           case oDisplay:
2885             set_opt_session_env ("DISPLAY", pargs.r.ret_str);
2886             break;
2887           case oTTYname:
2888             set_opt_session_env ("GPG_TTY", pargs.r.ret_str);
2889             break;
2890           case oTTYtype:
2891             set_opt_session_env ("TERM", pargs.r.ret_str);
2892             break;
2893           case oXauthority:
2894             set_opt_session_env ("XAUTHORITY", pargs.r.ret_str);
2895             break;
2896
2897           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2898           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2899
2900           case oGroup: add_group(pargs.r.ret_str); break;
2901           case oUnGroup: rm_group(pargs.r.ret_str); break;
2902           case oNoGroups:
2903             while(opt.grouplist)
2904               {
2905                 struct groupitem *iter=opt.grouplist;
2906                 free_strlist(iter->values);
2907                 opt.grouplist=opt.grouplist->next;
2908                 xfree(iter);
2909               }
2910             break;
2911
2912           case oStrict:
2913           case oNoStrict:
2914             /* Not used */
2915             break;
2916
2917           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2918           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2919           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2920           case oMultifile: multifile=1; break;
2921           case oKeyidFormat:
2922             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2923               opt.keyid_format=KF_SHORT;
2924             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2925               opt.keyid_format=KF_LONG;
2926             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2927               opt.keyid_format=KF_0xSHORT;
2928             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2929               opt.keyid_format=KF_0xLONG;
2930             else
2931               log_error("unknown keyid-format '%s'\n",pargs.r.ret_str);
2932             break;
2933
2934           case oExitOnStatusWriteError:
2935             opt.exit_on_status_write_error = 1;
2936             break;
2937
2938           case oLimitCardInsertTries:
2939             opt.limit_card_insert_tries = pargs.r.ret_int;
2940             break;
2941
2942           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2943           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2944
2945           case oAutoKeyLocate:
2946             if(!parse_auto_key_locate(pargs.r.ret_str))
2947               {
2948                 if(configname)
2949                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2950                             configname,configlineno);
2951                 else
2952                   log_error(_("invalid auto-key-locate list\n"));
2953               }
2954             break;
2955           case oNoAutoKeyLocate:
2956             release_akl();
2957             break;
2958
2959           case oEnableDSA2: opt.flags.dsa2=1; break;
2960           case oDisableDSA2: opt.flags.dsa2=0; break;
2961
2962           case oAllowMultisigVerification:
2963           case oAllowMultipleMessages:
2964             opt.flags.allow_multiple_messages=1;
2965             break;
2966
2967           case oNoAllowMultipleMessages:
2968             opt.flags.allow_multiple_messages=0;
2969             break;
2970
2971           case oFakedSystemTime:
2972             {
2973               time_t faked_time = isotime2epoch (pargs.r.ret_str);
2974               if (faked_time == (time_t)(-1))
2975                 faked_time = (time_t)strtoul (pargs.r.ret_str, NULL, 10);
2976               gnupg_set_time (faked_time, 0);
2977             }
2978             break;
2979
2980           case oNoop: break;
2981
2982           default:
2983             pargs.err = configfp? ARGPARSE_PRINT_WARNING:ARGPARSE_PRINT_ERROR;
2984             break;
2985           }
2986       }
2987
2988     if (configfp)
2989       {
2990         fclose( configfp );
2991         configfp = NULL;
2992         /* Remember the first config file name. */
2993         if (!save_configname)
2994           save_configname = configname;
2995         else
2996           xfree(configname);
2997         configname = NULL;
2998         goto next_pass;
2999       }
3000     xfree(configname); configname = NULL;
3001     if (log_get_errorcount (0))
3002       g10_exit(2);
3003
3004     /* The command --gpgconf-list is pretty simple and may be called
3005        directly after the option parsing. */
3006     if (cmd == aGPGConfList)
3007       {
3008         gpgconf_list (save_configname ? save_configname : default_configname);
3009         g10_exit (0);
3010       }
3011     xfree (save_configname);
3012     xfree (default_configname);
3013
3014     if( nogreeting )
3015         greeting = 0;
3016
3017     if( greeting )
3018       {
3019         es_fprintf (es_stderr, "%s %s; %s\n",
3020                     strusage(11), strusage(13), strusage(14) );
3021         es_fprintf (es_stderr, "%s\n", strusage(15) );
3022       }
3023 #ifdef IS_DEVELOPMENT_VERSION
3024     if (!opt.batch)
3025       {
3026         const char *s;
3027
3028         if((s=strusage(25)))
3029           log_info("%s\n",s);
3030         if((s=strusage(26)))
3031           log_info("%s\n",s);
3032         if((s=strusage(27)))
3033           log_info("%s\n",s);
3034       }
3035 #endif
3036
3037     /* FIXME: We should use logging to a file only in server mode;
3038        however we have not yet implemetyed that.  Thus we try to get
3039        away with --batch as indication for logging to file
3040        required. */
3041     if (logfile && opt.batch)
3042       {
3043         log_set_file (logfile);
3044         log_set_prefix (NULL, 1|2|4);
3045       }
3046
3047     /* Older Libgcrypts fail with an assertion during DSA key
3048        generation.  Better disable DSA2 entirely. */
3049     if (opt.flags.dsa2 && !gcry_check_version ("1.4.0") )
3050       {
3051         log_info ("WARNING: "
3052                   "DSA2 is only available with Libgcrypt 1.4 and later\n");
3053         opt.flags.dsa2 = 0;
3054       }
3055
3056     if (opt.verbose > 2)
3057         log_info ("using character set '%s'\n", get_native_charset ());
3058
3059     if( may_coredump && !opt.quiet )
3060         log_info(_("WARNING: program may create a core file!\n"));
3061
3062     if (eyes_only) {
3063       if (opt.set_filename)
3064           log_info(_("WARNING: %s overrides %s\n"),
3065                    "--for-your-eyes-only","--set-filename");
3066
3067       opt.set_filename="_CONSOLE";
3068     }
3069
3070     if (opt.no_literal) {
3071         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
3072         if (opt.textmode)
3073             log_error(_("%s not allowed with %s!\n"),
3074                        "--textmode", "--no-literal" );
3075         if (opt.set_filename)
3076             log_error(_("%s makes no sense with %s!\n"),
3077                         eyes_only?"--for-your-eyes-only":"--set-filename",
3078                         "--no-literal" );
3079     }
3080
3081
3082     if (opt.set_filesize)
3083         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
3084     if( opt.batch )
3085         tty_batchmode( 1 );
3086
3087     if (gnupg_faked_time_p ())
3088       {
3089         gnupg_isotime_t tbuf;
3090
3091         log_info (_("WARNING: running with faked system time: "));
3092         gnupg_get_isotime (tbuf);
3093         dump_isotime (tbuf);
3094         log_printf ("\n");
3095       }
3096
3097     /* Print a warning if an argument looks like an option.  */
3098     if (!opt.quiet && !(pargs.flags & ARGPARSE_FLAG_STOP_SEEN))
3099       {
3100         int i;
3101
3102         for (i=0; i < argc; i++)
3103           if (argv[i][0] == '-' && argv[i][1] == '-')
3104             log_info (_("NOTE: '%s' is not considered an option\n"), argv[i]);
3105       }
3106
3107
3108     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
3109
3110     if(require_secmem && !got_secmem)
3111       {
3112         log_info(_("will not run with insecure memory due to %s\n"),
3113                  "--require-secmem");
3114         g10_exit(2);
3115       }
3116
3117     set_debug (debug_level);
3118     if (DBG_CLOCK)
3119       log_clock ("start");
3120
3121     /* Do these after the switch(), so they can override settings. */
3122     if(PGP2)
3123       {
3124         int unusable=0;
3125
3126         if(cmd==aSign && !detached_sig)
3127           {
3128             log_info(_("you can only make detached or clear signatures "
3129                        "while in --pgp2 mode\n"));
3130             unusable=1;
3131           }
3132         else if(cmd==aSignEncr || cmd==aSignSym)
3133           {
3134             log_info(_("you can't sign and encrypt at the "
3135                        "same time while in --pgp2 mode\n"));
3136             unusable=1;
3137           }
3138         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
3139           {
3140             log_info(_("you must use files (and not a pipe) when "
3141                        "working with --pgp2 enabled.\n"));
3142             unusable=1;
3143           }
3144         else if(cmd==aEncr || cmd==aSym)
3145           {
3146             /* Everything else should work without IDEA (except using
3147                a secret key encrypted with IDEA and setting an IDEA
3148                preference, but those have their own error
3149                messages). */
3150
3151             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
3152               {
3153                 log_info(_("encrypting a message in --pgp2 mode requires "
3154                            "the IDEA cipher\n"));
3155                 unusable=1;
3156               }
3157             else if(cmd==aSym)
3158               {
3159                 /* This only sets IDEA for symmetric encryption
3160                    since it is set via select_algo_from_prefs for
3161                    pk encryption. */
3162                 xfree(def_cipher_string);
3163                 def_cipher_string = xstrdup("idea");
3164               }
3165
3166             /* PGP2 can't handle the output from the textmode
3167                filter, so we disable it for anything that could
3168                create a literal packet (only encryption and
3169                symmetric encryption, since we disable signing
3170                above). */
3171             if(!unusable)
3172               opt.textmode=0;
3173           }
3174
3175         if(unusable)
3176           compliance_failure();
3177         else
3178           {
3179             opt.force_v4_certs = 0;
3180             opt.escape_from = 1;
3181             opt.force_v3_sigs = 1;
3182             opt.pgp2_workarounds = 1;
3183             opt.ask_sig_expire = 0;
3184             opt.ask_cert_expire = 0;
3185             xfree(def_digest_string);
3186             def_digest_string = xstrdup("md5");
3187             xfree(s2k_digest_string);
3188             s2k_digest_string = xstrdup("md5");
3189             opt.compress_algo = COMPRESS_ALGO_ZIP;
3190           }
3191       }
3192     else if(PGP6)
3193       {
3194         opt.disable_mdc=1;
3195         opt.escape_from=1;
3196         opt.force_v3_sigs=1;
3197         opt.ask_sig_expire=0;
3198       }
3199     else if(PGP7)
3200       {
3201         opt.escape_from=1;
3202         opt.force_v3_sigs=1;
3203         opt.ask_sig_expire=0;
3204       }
3205     else if(PGP8)
3206       {
3207         opt.escape_from=1;
3208       }
3209
3210
3211     if( def_cipher_string ) {
3212         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3213         xfree(def_cipher_string); def_cipher_string = NULL;
3214         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3215             log_error(_("selected cipher algorithm is invalid\n"));
3216     }
3217     if( def_digest_string ) {
3218         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3219         xfree(def_digest_string); def_digest_string = NULL;
3220         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3221             log_error(_("selected digest algorithm is invalid\n"));
3222     }
3223     if( compress_algo_string ) {
3224         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3225         xfree(compress_algo_string); compress_algo_string = NULL;
3226         if( check_compress_algo(opt.compress_algo) )
3227           log_error(_("selected compression algorithm is invalid\n"));
3228     }
3229     if( cert_digest_string ) {
3230         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3231         xfree(cert_digest_string); cert_digest_string = NULL;
3232         if (openpgp_md_test_algo(opt.cert_digest_algo))
3233           log_error(_("selected certification digest algorithm is invalid\n"));
3234     }
3235     if( s2k_cipher_string ) {
3236         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3237         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3238         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3239           log_error(_("selected cipher algorithm is invalid\n"));
3240     }
3241     if( s2k_digest_string ) {
3242         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3243         xfree(s2k_digest_string); s2k_digest_string = NULL;
3244         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3245           log_error(_("selected digest algorithm is invalid\n"));
3246     }
3247     if( opt.completes_needed < 1 )
3248       log_error(_("completes-needed must be greater than 0\n"));
3249     if( opt.marginals_needed < 2 )
3250       log_error(_("marginals-needed must be greater than 1\n"));
3251     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3252       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3253     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3254       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3255     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3256       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3257     switch( opt.s2k_mode ) {
3258       case 0:
3259         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3260         break;
3261       case 1: case 3: break;
3262       default:
3263         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3264     }
3265
3266     /* This isn't actually needed, but does serve to error out if the
3267        string is invalid. */
3268     if(opt.def_preference_list &&
3269         keygen_set_std_prefs(opt.def_preference_list,0))
3270       log_error(_("invalid default preferences\n"));
3271
3272     if(pers_cipher_list &&
3273        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3274       log_error(_("invalid personal cipher preferences\n"));
3275
3276     if(pers_digest_list &&
3277        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3278       log_error(_("invalid personal digest preferences\n"));
3279
3280     if(pers_compress_list &&
3281        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3282       log_error(_("invalid personal compress preferences\n"));
3283
3284     /* We don't support all possible commands with multifile yet */
3285     if(multifile)
3286       {
3287         char *cmdname;
3288
3289         switch(cmd)
3290           {
3291           case aSign:
3292             cmdname="--sign";
3293             break;
3294           case aClearsign:
3295             cmdname="--clearsign";
3296             break;
3297           case aDetachedSign:
3298             cmdname="--detach-sign";
3299             break;
3300           case aSym:
3301             cmdname="--symmetric";
3302             break;
3303           case aEncrSym:
3304             cmdname="--symmetric --encrypt";
3305             break;
3306           case aStore:
3307             cmdname="--store";
3308             break;
3309           default:
3310             cmdname=NULL;
3311             break;
3312           }
3313
3314         if(cmdname)
3315           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3316       }
3317
3318     if( log_get_errorcount(0) )
3319         g10_exit(2);
3320
3321     if(opt.compress_level==0)
3322       opt.compress_algo=COMPRESS_ALGO_NONE;
3323
3324     /* Check our chosen algorithms against the list of legal
3325        algorithms. */
3326
3327     if(!GNUPG)
3328       {
3329         const char *badalg=NULL;
3330         preftype_t badtype=PREFTYPE_NONE;
3331
3332         if(opt.def_cipher_algo
3333            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3334           {
3335             badalg = openpgp_cipher_algo_name (opt.def_cipher_algo);
3336             badtype = PREFTYPE_SYM;
3337           }
3338         else if(opt.def_digest_algo
3339                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3340           {
3341             badalg = gcry_md_algo_name (opt.def_digest_algo);
3342             badtype = PREFTYPE_HASH;
3343           }
3344         else if(opt.cert_digest_algo
3345                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3346           {
3347             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3348             badtype = PREFTYPE_HASH;
3349           }
3350         else if(opt.compress_algo!=-1
3351                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3352           {
3353             badalg = compress_algo_to_string(opt.compress_algo);
3354             badtype = PREFTYPE_ZIP;
3355           }
3356
3357         if(badalg)
3358           {
3359             switch(badtype)
3360               {
3361               case PREFTYPE_SYM:
3362                 log_info(_("you may not use cipher algorithm '%s'"
3363                            " while in %s mode\n"),
3364                          badalg,compliance_option_string());
3365                 break;
3366               case PREFTYPE_HASH:
3367                 log_info(_("you may not use digest algorithm '%s'"
3368                            " while in %s mode\n"),
3369                          badalg,compliance_option_string());
3370                 break;
3371               case PREFTYPE_ZIP:
3372                 log_info(_("you may not use compression algorithm '%s'"
3373                            " while in %s mode\n"),
3374                          badalg,compliance_option_string());
3375                 break;
3376               default:
3377                 BUG();
3378               }
3379
3380             compliance_failure();
3381           }
3382       }
3383
3384     /* Set the random seed file. */
3385     if( use_random_seed ) {
3386         char *p = make_filename(opt.homedir, "random_seed", NULL );
3387         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3388         if (!access (p, F_OK))
3389           register_secured_file (p);
3390         xfree(p);
3391     }
3392
3393     /* If there is no command but the --fingerprint is given, default
3394        to the --list-keys command.  */
3395     if (!cmd && fpr_maybe_cmd)
3396       {
3397         set_cmd (&cmd, aListKeys);
3398       }
3399
3400
3401     if( opt.verbose > 1 )
3402         set_packet_list_mode(1);
3403
3404     /* Add the keyrings, but not for some special commands.
3405        We always need to add the keyrings if we are running under
3406        SELinux, this is so that the rings are added to the list of
3407        secured files. */
3408     if( ALWAYS_ADD_KEYRINGS
3409         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) )
3410       {
3411         if (!nrings || default_keyring)  /* Add default ring. */
3412             keydb_add_resource ("pubring" EXTSEP_S "gpg",
3413                                 KEYDB_RESOURCE_FLAG_DEFAULT);
3414         for (sl = nrings; sl; sl = sl->next )
3415           keydb_add_resource (sl->d, sl->flags);
3416       }
3417     FREE_STRLIST(nrings);
3418
3419     if (cmd == aGPGConfTest)
3420       g10_exit(0);
3421
3422
3423     if( pwfd != -1 )  /* Read the passphrase now. */
3424         read_passphrase_from_fd( pwfd );
3425
3426     fname = argc? *argv : NULL;
3427
3428     if(fname && utf8_strings)
3429       opt.flags.utf8_filename=1;
3430
3431     ctrl = xcalloc (1, sizeof *ctrl);
3432     gpg_init_default_ctrl (ctrl);
3433
3434     switch( cmd ) {
3435       case aPrimegen:
3436       case aPrintMD:
3437       case aPrintMDs:
3438       case aGenRandom:
3439       case aDeArmor:
3440       case aEnArmor:
3441         break;
3442       case aFixTrustDB:
3443       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3444       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3445       default: rc = setup_trustdb(1, trustdb_name ); break;
3446     }
3447     if( rc )
3448         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3449
3450
3451     switch (cmd)
3452       {
3453       case aStore:
3454       case aSym:
3455       case aSign:
3456       case aSignSym:
3457       case aClearsign:
3458         if (!opt.quiet && any_explicit_recipient)
3459           log_info (_("WARNING: recipients (-r) given "
3460                       "without using public key encryption\n"));
3461         break;
3462       default:
3463         break;
3464       }
3465
3466     switch( cmd )
3467       {
3468       case aServer:
3469         gpg_server (ctrl);
3470         break;
3471
3472       case aStore: /* only store the file */
3473         if( argc > 1 )
3474             wrong_args(_("--store [filename]"));
3475         if( (rc = encrypt_store(fname)) )
3476             log_error ("storing '%s' failed: %s\n",
3477                        print_fname_stdin(fname),g10_errstr(rc) );
3478         break;
3479       case aSym: /* encrypt the given file only with the symmetric cipher */
3480         if( argc > 1 )
3481             wrong_args(_("--symmetric [filename]"));
3482         if( (rc = encrypt_symmetric(fname)) )
3483             log_error (_("symmetric encryption of '%s' failed: %s\n"),
3484                         print_fname_stdin(fname),g10_errstr(rc) );
3485         break;
3486
3487       case aEncr: /* encrypt the given file */
3488         if(multifile)
3489           encrypt_crypt_files (ctrl, argc, argv, remusr);
3490         else
3491           {
3492             if( argc > 1 )
3493               wrong_args(_("--encrypt [filename]"));
3494             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 0, NULL, -1)) )
3495               log_error("%s: encryption failed: %s\n",
3496                         print_fname_stdin(fname), g10_errstr(rc) );
3497           }
3498         break;
3499
3500       case aEncrSym:
3501         /* This works with PGP 8 in the sense that it acts just like a
3502            symmetric message.  It doesn't work at all with 2 or 6.  It
3503            might work with 7, but alas, I don't have a copy to test
3504            with right now. */
3505         if( argc > 1 )
3506           wrong_args(_("--symmetric --encrypt [filename]"));
3507         else if(opt.s2k_mode==0)
3508           log_error(_("you cannot use --symmetric --encrypt"
3509                       " with --s2k-mode 0\n"));
3510         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3511           log_error(_("you cannot use --symmetric --encrypt"
3512                       " while in %s mode\n"),compliance_option_string());
3513         else
3514           {
3515             if( (rc = encrypt_crypt (ctrl, -1, fname, remusr, 1, NULL, -1)) )
3516               log_error("%s: encryption failed: %s\n",
3517                         print_fname_stdin(fname), g10_errstr(rc) );
3518           }
3519         break;
3520
3521       case aSign: /* sign the given file */
3522         sl = NULL;
3523         if( detached_sig ) { /* sign all files */
3524             for( ; argc; argc--, argv++ )
3525                 add_to_strlist( &sl, *argv );
3526         }
3527         else {
3528             if( argc > 1 )
3529                 wrong_args(_("--sign [filename]"));
3530             if( argc ) {
3531                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3532                 strcpy(sl->d, fname);
3533             }
3534         }
3535         if( (rc = sign_file (ctrl, sl, detached_sig, locusr, 0, NULL, NULL)) )
3536             log_error("signing failed: %s\n", g10_errstr(rc) );
3537         free_strlist(sl);
3538         break;
3539
3540       case aSignEncr: /* sign and encrypt the given file */
3541         if( argc > 1 )
3542             wrong_args(_("--sign --encrypt [filename]"));
3543         if( argc ) {
3544             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3545             strcpy(sl->d, fname);
3546         }
3547         else
3548             sl = NULL;
3549         if ((rc = sign_file (ctrl, sl, detached_sig, locusr, 1, remusr, NULL)))
3550             log_error("%s: sign+encrypt failed: %s\n",
3551                       print_fname_stdin(fname), g10_errstr(rc) );
3552         free_strlist(sl);
3553         break;
3554
3555