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