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