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