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