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