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