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