Use a custom log handler for libassuan.
[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 /*       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 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1432
1433   return 0;
1434 }
1435
1436
1437 /* Print the OpenPGP defined algo numbers.  */
1438 static void
1439 print_algo_numbers(int (*checker)(int))
1440 {
1441   int i,first=1;
1442
1443   for(i=0;i<=110;i++)
1444     {
1445       if(!checker(i))
1446         {
1447           if(first)
1448             first=0;
1449           else
1450             printf(";");
1451           printf("%d",i);
1452         }
1453     }
1454 }
1455
1456
1457 static void
1458 print_algo_names(int (*checker)(int),const char *(*mapper)(int))
1459 {
1460   int i,first=1;
1461
1462   for(i=0;i<=110;i++)
1463     {
1464       if(!checker(i))
1465         {
1466           if(first)
1467             first=0;
1468           else
1469             printf(";");
1470           printf("%s",mapper(i));
1471         }
1472     }
1473 }
1474
1475 /* In the future, we can do all sorts of interesting configuration
1476    output here.  For now, just give "group" as the Enigmail folks need
1477    it, and pubkey, cipher, hash, and compress as they may be useful
1478    for frontends. */
1479 static void
1480 list_config(char *items)
1481 {
1482   int show_all=(items==NULL);
1483   char *name=NULL;
1484
1485   if(!opt.with_colons)
1486     return;
1487
1488   while(show_all || (name=strsep(&items," ")))
1489     {
1490       int any=0;
1491
1492       if(show_all || ascii_strcasecmp(name,"group")==0)
1493         {
1494           struct groupitem *iter;
1495
1496           for(iter=opt.grouplist;iter;iter=iter->next)
1497             {
1498               strlist_t sl;
1499
1500               printf("cfg:group:");
1501               print_string(stdout,iter->name,strlen(iter->name),':');
1502               printf(":");
1503
1504               for(sl=iter->values;sl;sl=sl->next)
1505                 {
1506                   print_sanitized_string2 (stdout, sl->d, ':',';');
1507                   if(sl->next)
1508                     printf(";");
1509                 }
1510
1511               printf("\n");
1512             }
1513
1514           any=1;
1515         }
1516
1517       if(show_all || ascii_strcasecmp(name,"version")==0)
1518         {
1519           printf("cfg:version:");
1520           print_string(stdout,VERSION,strlen(VERSION),':');
1521           printf("\n");
1522           any=1;
1523         }
1524
1525       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1526         {
1527           printf("cfg:pubkey:");
1528           print_algo_numbers (openpgp_pk_test_algo);
1529           printf("\n");
1530           any=1;
1531         }
1532
1533       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1534         {
1535           printf("cfg:cipher:");
1536           print_algo_numbers(openpgp_cipher_test_algo);
1537           printf("\n");
1538           any=1;
1539         }
1540
1541       if (show_all || !ascii_strcasecmp (name,"ciphername"))
1542         {
1543           printf ("cfg:ciphername:");
1544           print_algo_names (openpgp_cipher_test_algo,openpgp_cipher_algo_name);
1545           printf ("\n");
1546           any = 1;
1547         }
1548
1549       if(show_all
1550          || ascii_strcasecmp(name,"digest")==0
1551          || ascii_strcasecmp(name,"hash")==0)
1552         {
1553           printf("cfg:digest:");
1554           print_algo_numbers(openpgp_md_test_algo);
1555           printf("\n");
1556           any=1;
1557         }
1558
1559       if (show_all
1560           || !ascii_strcasecmp(name,"digestname")
1561           || !ascii_strcasecmp(name,"hashname"))
1562         {
1563           printf ("cfg:digestname:");
1564           print_algo_names (openpgp_md_test_algo, gcry_md_algo_name);
1565           printf("\n");
1566           any=1;
1567         }
1568       
1569       if(show_all || ascii_strcasecmp(name,"compress")==0)
1570         {
1571           printf("cfg:compress:");
1572           print_algo_numbers(check_compress_algo);
1573           printf("\n");
1574           any=1;
1575         }
1576
1577       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1578         {
1579 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB) \
1580     && GNUPG_MAJOR_VERSION == 1
1581
1582           char *p, *p2, *list = ccid_get_reader_list ();
1583
1584           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1585             {
1586               *p2 = 0;
1587               printf("cfg:ccid-reader-id:%s\n", p);
1588             }
1589           free (list);
1590 #endif
1591           any=1;
1592         }
1593
1594       if(show_all)
1595         break;
1596
1597       if(!any)
1598         log_error(_("unknown configuration item `%s'\n"),name);
1599     }
1600 }
1601
1602
1603 /* List options and default values in the GPG Conf format.  This is a
1604    new tool distributed with gnupg 1.9.x but we also want some limited
1605    support in older gpg versions.  The output is the name of the
1606    configuration file and a list of options available for editing by
1607    gpgconf.  */
1608 static void
1609 gpgconf_list (const char *configfile)
1610 {
1611   char *configfile_esc = percent_escape (configfile, NULL);
1612
1613   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1614           GC_OPT_FLAG_DEFAULT, configfile_esc ? configfile_esc : "/dev/null");
1615   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1616   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1617   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1618   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1619   printf ("default-key:%lu:\n", GC_OPT_FLAG_NONE);
1620   printf ("encrypt-to:%lu:\n", GC_OPT_FLAG_NONE);
1621   printf ("auto-key-locate:%lu:\n", GC_OPT_FLAG_NONE);
1622   printf ("log-file:%lu:\n", GC_OPT_FLAG_NONE);
1623   printf ("debug-level:%lu:\"none:\n", GC_OPT_FLAG_DEFAULT);
1624   printf ("group:%lu:\n", GC_OPT_FLAG_NONE);
1625
1626   /* The next one is an info only item and should match the macros at
1627      the top of keygen.c  */
1628   printf ("default_pubkey_algo:%lu:\"%s:\n", GC_OPT_FLAG_DEFAULT,
1629           "RSA-2048");
1630
1631   xfree (configfile_esc);
1632 }
1633
1634
1635 static int
1636 parse_subpacket_list(char *list)
1637 {
1638   char *tok;
1639   byte subpackets[128],i;
1640   int count=0;
1641
1642   if(!list)
1643     {
1644       /* No arguments means all subpackets */
1645       memset(subpackets+1,1,sizeof(subpackets)-1);
1646       count=127;
1647     }
1648   else
1649     {
1650       memset(subpackets,0,sizeof(subpackets));
1651
1652       /* Merge with earlier copy */
1653       if(opt.show_subpackets)
1654         {
1655           byte *in;
1656
1657           for(in=opt.show_subpackets;*in;in++)
1658             {
1659               if(*in>127 || *in<1)
1660                 BUG();
1661
1662               if(!subpackets[*in])
1663                 count++;
1664               subpackets[*in]=1;
1665             }
1666         }
1667
1668       while((tok=strsep(&list," ,")))
1669         {
1670           if(!*tok)
1671             continue;
1672
1673           i=atoi(tok);
1674           if(i>127 || i<1)
1675             return 0;
1676
1677           if(!subpackets[i])
1678             count++;
1679           subpackets[i]=1;
1680         }
1681     }
1682
1683   xfree(opt.show_subpackets);
1684   opt.show_subpackets=xmalloc(count+1);
1685   opt.show_subpackets[count--]=0;
1686
1687   for(i=1;i<128 && count>=0;i++)
1688     if(subpackets[i])
1689       opt.show_subpackets[count--]=i;
1690
1691   return 1;
1692 }
1693
1694
1695 static int
1696 parse_list_options(char *str)
1697 {
1698   char *subpackets=""; /* something that isn't NULL */
1699   struct parse_options lopts[]=
1700     {
1701       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1702        N_("display photo IDs during key listings")},
1703       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1704        N_("show policy URLs during signature listings")},
1705       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1706        N_("show all notations during signature listings")},
1707       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1708        N_("show IETF standard notations during signature listings")},
1709       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1710        NULL},
1711       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1712        N_("show user-supplied notations during signature listings")},
1713       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1714        N_("show preferred keyserver URLs during signature listings")},
1715       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1716        N_("show user ID validity during key listings")},
1717       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1718        N_("show revoked and expired user IDs in key listings")},
1719       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1720        N_("show revoked and expired subkeys in key listings")},
1721       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1722        N_("show the keyring name in key listings")},
1723       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1724        N_("show expiration dates during signature listings")},
1725       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1726        NULL},
1727       {NULL,0,NULL,NULL}
1728     };
1729
1730   /* C99 allows for non-constant initializers, but we'd like to
1731      compile everywhere, so fill in the show-sig-subpackets argument
1732      here.  Note that if the parse_options array changes, we'll have
1733      to change the subscript here. */
1734   lopts[12].value=&subpackets;
1735
1736   if(parse_options(str,&opt.list_options,lopts,1))
1737     {
1738       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1739         {
1740           /* Unset so users can pass multiple lists in. */
1741           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1742           if(!parse_subpacket_list(subpackets))
1743             return 0;
1744         }
1745       else if(subpackets==NULL && opt.show_subpackets)
1746         {
1747           /* User did 'no-show-subpackets' */
1748           xfree(opt.show_subpackets);
1749           opt.show_subpackets=NULL;
1750         }
1751
1752       return 1;
1753     }
1754   else
1755     return 0;
1756 }
1757
1758
1759 /* Collapses argc/argv into a single string that must be freed */
1760 static char *
1761 collapse_args(int argc,char *argv[])
1762 {
1763   char *str=NULL;
1764   int i,first=1,len=0;
1765
1766   for(i=0;i<argc;i++)
1767     {
1768       len+=strlen(argv[i])+2;
1769       str=xrealloc(str,len);
1770       if(first)
1771         {
1772           str[0]='\0';
1773           first=0;
1774         }
1775       else
1776         strcat(str," ");
1777
1778       strcat(str,argv[i]);
1779     }
1780
1781   return str;
1782 }
1783
1784 static void
1785 parse_trust_model(const char *model)
1786 {
1787   if(ascii_strcasecmp(model,"pgp")==0)
1788     opt.trust_model=TM_PGP;
1789   else if(ascii_strcasecmp(model,"classic")==0)
1790     opt.trust_model=TM_CLASSIC;
1791   else if(ascii_strcasecmp(model,"always")==0)
1792     opt.trust_model=TM_ALWAYS;
1793   else if(ascii_strcasecmp(model,"direct")==0)
1794     opt.trust_model=TM_DIRECT;
1795   else if(ascii_strcasecmp(model,"auto")==0)
1796     opt.trust_model=TM_AUTO;
1797   else
1798     log_error("unknown trust model `%s'\n",model);
1799 }
1800
1801
1802 /* This fucntion called to initialized a new control object.  It is
1803    assumed that this object has been zeroed out before calling this
1804    function. */
1805 static void
1806 gpg_init_default_ctrl (ctrl_t ctrl)
1807 {
1808   (void)ctrl;
1809 }
1810
1811
1812 /* This function is called to deinitialize a control object.  It is
1813    not deallocated. */
1814 static void
1815 gpg_deinit_default_ctrl (ctrl_t ctrl)
1816 {
1817   (void)ctrl;
1818 }
1819
1820
1821 char *
1822 get_default_configname (void)
1823 {
1824   char *configname = NULL;
1825   char *name = xstrdup ("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1826   char *ver = &name[strlen ("gpg" EXTSEP_S "conf-")];
1827
1828   do
1829     {
1830       if (configname)
1831         {
1832           char *tok;
1833           
1834           xfree (configname);
1835           configname = NULL;
1836
1837           if ((tok = strrchr (ver, SAFE_VERSION_DASH)))
1838             *tok='\0';
1839           else if ((tok = strrchr (ver, SAFE_VERSION_DOT)))
1840             *tok='\0';
1841           else
1842             break;
1843         }
1844       
1845       configname = make_filename (opt.homedir, name, NULL);
1846     }
1847   while (access (configname, R_OK));
1848
1849   xfree(name);
1850   
1851   if (! configname)
1852     configname = make_filename (opt.homedir, "gpg" EXTSEP_S "conf", NULL);
1853   if (! access (configname, R_OK))
1854     {
1855       /* Print a warning when both config files are present.  */
1856       char *p = make_filename (opt.homedir, "options", NULL);
1857       if (! access (p, R_OK))
1858         log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1859       xfree (p);
1860     }
1861   else
1862     {
1863       /* Use the old default only if it exists.  */
1864       char *p = make_filename (opt.homedir, "options", NULL);
1865       if (!access (p, R_OK))
1866         {
1867           xfree (configname);
1868           configname = p;
1869         }
1870       else
1871         xfree (p);
1872     }
1873
1874   return configname;
1875 }
1876
1877
1878 int
1879 main (int argc, char **argv)
1880 {
1881     ARGPARSE_ARGS pargs;
1882     IOBUF a;
1883     int rc=0;
1884     int orig_argc;
1885     char **orig_argv;
1886     const char *fname;
1887     char *username;
1888     int may_coredump;
1889     strlist_t sl, remusr= NULL, locusr=NULL;
1890     strlist_t nrings=NULL, sec_nrings=NULL;
1891     armor_filter_context_t *afx = NULL;
1892     int detached_sig = 0;
1893     FILE *configfp = NULL;
1894     char *configname = NULL;
1895     char *save_configname = NULL;
1896     char *default_configname = NULL;
1897     unsigned configlineno;
1898     int parse_debug = 0;
1899     int default_config = 1;
1900     int default_keyring = 1;
1901     int greeting = 0;
1902     int nogreeting = 0;
1903     char *logfile = NULL;
1904     int use_random_seed = 1;
1905     enum cmd_and_opt_values cmd = 0;
1906     const char *debug_level = NULL;
1907     const char *trustdb_name = NULL;
1908     char *def_cipher_string = NULL;
1909     char *def_digest_string = NULL;
1910     char *compress_algo_string = NULL;
1911     char *cert_digest_string = NULL;
1912     char *s2k_cipher_string = NULL;
1913     char *s2k_digest_string = NULL;
1914     char *pers_cipher_list = NULL;
1915     char *pers_digest_list = NULL;
1916     char *pers_compress_list = NULL;
1917     int eyes_only=0;
1918     int multifile=0;
1919     int pwfd = -1;
1920     int fpr_maybe_cmd = 0; /* --fingerprint maybe a command.  */
1921     int any_explicit_recipient = 0;
1922     int require_secmem=0,got_secmem=0;
1923     struct assuan_malloc_hooks malloc_hooks;
1924
1925 #ifdef __riscos__
1926     opt.lock_once = 1;
1927 #endif /* __riscos__ */
1928
1929
1930     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1931        when adding any stuff between here and the call to
1932        secmem_init() somewhere after the option parsing. */
1933     gnupg_reopen_std ("gpg");
1934     trap_unaligned ();
1935     gnupg_rl_initialize ();
1936     set_strusage (my_strusage);
1937     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1938     log_set_prefix ("gpg", 1);
1939
1940     /* Make sure that our subsystems are ready.  */
1941     i18n_init();
1942     init_common_subsystems ();
1943
1944     /* Check that the libraries are suitable.  Do it right here because the
1945        option parsing may need services of the library.  */
1946     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1947       {
1948         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1949                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1950       }
1951
1952     /* Put random number into secure memory */
1953     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1954
1955     may_coredump = disable_core_dumps();
1956
1957     gnupg_init_signals (0, emergency_cleanup);
1958
1959     create_dotlock(NULL); /* Register locking cleanup. */
1960
1961     opt.session_env = session_env_new ();
1962     if (!opt.session_env)
1963       log_fatal ("error allocating session environment block: %s\n",
1964                  strerror (errno));
1965
1966     opt.command_fd = -1; /* no command fd */
1967     opt.compress_level = -1; /* defaults to standard compress level */
1968     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1969     /* note: if you change these lines, look at oOpenPGP */
1970     opt.def_cipher_algo = 0;
1971     opt.def_digest_algo = 0;
1972     opt.cert_digest_algo = 0;
1973     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1974     opt.s2k_mode = 3; /* iterated+salted */
1975     opt.s2k_count = 0; /* Auto-calibrate when needed.  */
1976 #ifdef USE_CAST5
1977     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1978 #else
1979     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1980 #endif
1981     opt.completes_needed = 1;
1982     opt.marginals_needed = 3;
1983     opt.max_cert_depth = 5;
1984     opt.pgp2_workarounds = 1;
1985     opt.escape_from = 1;
1986     opt.flags.require_cross_cert = 1;
1987     opt.import_options=IMPORT_SK2PK;
1988     opt.export_options=EXPORT_ATTRIBUTES;
1989     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1990     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1991     opt.keyserver_options.options=
1992       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1993     opt.verify_options=
1994       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1995     opt.trust_model=TM_AUTO;
1996     opt.mangle_dos_filenames=0;
1997     opt.min_cert_level=2;
1998     set_screen_dimensions();
1999     opt.keyid_format=KF_SHORT;
2000     opt.def_sig_expire="0";
2001     opt.def_cert_expire="0";
2002     set_homedir ( default_homedir () );
2003     opt.passphrase_repeat=1;
2004
2005     /* Check whether we have a config file on the command line.  */
2006     orig_argc = argc;
2007     orig_argv = argv;
2008     pargs.argc = &argc;
2009     pargs.argv = &argv;
2010     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
2011     while( arg_parse( &pargs, opts) ) {
2012         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
2013             parse_debug++;
2014         else if( pargs.r_opt == oOptions ) {
2015             /* yes there is one, so we do not try the default one, but
2016              * read the option file when it is encountered at the commandline
2017              */
2018             default_config = 0;
2019         }
2020         else if( pargs.r_opt == oNoOptions )
2021           {
2022             default_config = 0; /* --no-options */
2023             opt.no_homedir_creation = 1;
2024           }
2025         else if( pargs.r_opt == oHomedir )
2026             set_homedir ( pargs.r.ret_str );
2027         else if( pargs.r_opt == oNoPermissionWarn )
2028             opt.no_perm_warn=1;
2029         else if (pargs.r_opt == oStrict )
2030           {
2031             /* Not used */
2032           }
2033         else if (pargs.r_opt == oNoStrict )
2034           {
2035             /* Not used */
2036           }
2037     }
2038
2039 #ifdef HAVE_DOSISH_SYSTEM
2040     if ( strchr (opt.homedir,'\\') ) {
2041         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
2042         const char *s = opt.homedir;
2043         for (d=buf,s=opt.homedir; *s; s++)
2044           {
2045             *d++ = *s == '\\'? '/': *s;
2046 #ifdef HAVE_W32_SYSTEM
2047             if (s[1] && IsDBCSLeadByte (*s))
2048               *d++ = *++s;
2049 #endif
2050           }
2051         *d = 0;
2052         set_homedir (buf);
2053     }
2054 #endif
2055
2056     /* Initialize the secure memory. */
2057     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
2058       got_secmem = 1; 
2059 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
2060     /* There should be no way to get to this spot while still carrying
2061        setuid privs.  Just in case, bomb out if we are. */
2062     if ( getuid () != geteuid () )
2063       BUG ();
2064 #endif
2065     maybe_setuid = 0;
2066
2067     /* Okay, we are now working under our real uid */
2068
2069     /* malloc hooks go here ... */
2070     malloc_hooks.malloc = gcry_malloc;
2071     malloc_hooks.realloc = gcry_realloc;
2072     malloc_hooks.free = gcry_free;
2073     assuan_set_malloc_hooks (&malloc_hooks);
2074     assuan_set_gpg_err_source (GPG_ERR_SOURCE_DEFAULT);
2075     setup_libassuan_logging (&opt.debug);
2076  
2077     /* Try for a version specific config file first */
2078     default_configname = get_default_configname ();
2079     if (default_config)
2080       configname = xstrdup (default_configname);
2081
2082     argc = orig_argc;
2083     argv = orig_argv;
2084     pargs.argc = &argc;
2085     pargs.argv = &argv;
2086     pargs.flags=  1;  /* do not remove the args */
2087
2088     /* By this point we have a homedir, and cannot change it. */
2089     check_permissions(opt.homedir,0);
2090
2091   next_pass:
2092     if( configname ) {
2093       if(check_permissions(configname,1))
2094         {
2095           /* If any options file is unsafe, then disable any external
2096              programs for keyserver calls or photo IDs.  Since the
2097              external program to call is set in the options file, a
2098              unsafe options file can lead to an arbitrary program
2099              being run. */
2100
2101           opt.exec_disable=1;
2102         }
2103
2104         configlineno = 0;
2105         configfp = fopen( configname, "r" );
2106         if (configfp && is_secured_file (fileno (configfp)))
2107           {
2108             fclose (configfp);
2109             configfp = NULL;
2110             errno = EPERM;
2111           }
2112         if( !configfp ) {
2113             if( default_config ) {
2114                 if( parse_debug )
2115                     log_info(_("NOTE: no default option file `%s'\n"),
2116                                                             configname );
2117             }
2118             else {
2119                 log_error(_("option file `%s': %s\n"),
2120                                     configname, strerror(errno) );
2121                 g10_exit(2);
2122             }
2123             xfree(configname); configname = NULL;
2124         }
2125         if( parse_debug && configname )
2126             log_info(_("reading options from `%s'\n"), configname );
2127         default_config = 0;
2128     }
2129
2130     while( optfile_parse( configfp, configname, &configlineno,
2131                                                 &pargs, opts) )
2132       {
2133         switch( pargs.r_opt )
2134           {
2135           case aCheckKeys: 
2136           case aListConfig:
2137           case aGPGConfList:
2138           case aGPGConfTest:
2139           case aListPackets:
2140           case aImport: 
2141           case aFastImport: 
2142           case aSendKeys: 
2143           case aRecvKeys: 
2144           case aSearchKeys:
2145           case aRefreshKeys:
2146           case aFetchKeys:
2147           case aExport: 
2148 #ifdef ENABLE_CARD_SUPPORT
2149           case aCardStatus:
2150           case aCardEdit: 
2151           case aChangePIN:
2152 #endif /* ENABLE_CARD_SUPPORT*/
2153           case aListKeys: 
2154           case aLocateKeys:
2155           case aListSigs: 
2156           case aExportSecret: 
2157           case aExportSecretSub: 
2158           case aSym:
2159           case aClearsign: 
2160           case aGenRevoke: 
2161           case aDesigRevoke: 
2162           case aPrimegen: 
2163           case aGenRandom:
2164           case aPrintMD:
2165           case aPrintMDs: 
2166           case aListTrustDB: 
2167           case aCheckTrustDB:
2168           case aUpdateTrustDB: 
2169           case aFixTrustDB: 
2170           case aListTrustPath: 
2171           case aDeArmor: 
2172           case aEnArmor: 
2173           case aSign: 
2174           case aSignKey: 
2175           case aLSignKey:
2176           case aStore: 
2177           case aExportOwnerTrust: 
2178           case aImportOwnerTrust: 
2179           case aRebuildKeydbCaches:
2180             set_cmd (&cmd, pargs.r_opt);
2181             break;
2182
2183           case aKeygen: 
2184           case aEditKey:
2185           case aDeleteSecretKeys:
2186           case aDeleteSecretAndPublicKeys:
2187           case aDeleteKeys:
2188           case aPasswd:
2189             set_cmd (&cmd, pargs.r_opt);
2190             greeting=1;
2191             break;
2192
2193           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2194
2195           case aDecryptFiles: multifile=1; /* fall through */
2196           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2197
2198           case aEncrFiles: multifile=1; /* fall through */
2199           case aEncr: set_cmd( &cmd, aEncr); break;
2200
2201           case aVerifyFiles: multifile=1; /* fall through */
2202           case aVerify: set_cmd( &cmd, aVerify); break;
2203
2204           case aServer:
2205             set_cmd (&cmd, pargs.r_opt);
2206             opt.batch = 1;
2207             break;
2208
2209           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2210           case oOutput: opt.outfile = pargs.r.ret_str; break;
2211           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2212           case oQuiet: opt.quiet = 1; break;
2213           case oNoTTY: tty_no_terminal(1); break;
2214           case oDryRun: opt.dry_run = 1; break;
2215           case oInteractive: opt.interactive = 1; break;
2216           case oVerbose:
2217             opt.verbose++;
2218             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2219             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2220             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2221             break;
2222
2223           case oBatch:
2224             opt.batch = 1;
2225             nogreeting = 1;
2226             break;
2227
2228           case oUseAgent: /* Dummy. */
2229             break;
2230           case oNoUseAgent:
2231             obsolete_option (configname, configlineno, "--no-use-agent");
2232             break;
2233           case oGpgAgentInfo: 
2234             obsolete_option (configname, configlineno, "--gpg-agent-info");
2235             break;
2236
2237           case oAnswerYes: opt.answer_yes = 1; break;
2238           case oAnswerNo: opt.answer_no = 1; break;
2239           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2240           case oPrimaryKeyring:
2241             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2242             sl->flags=2;
2243             break;
2244           case oShowKeyring:
2245             deprecated_warning(configname,configlineno,"--show-keyring",
2246                                "--list-options ","show-keyring");
2247             opt.list_options|=LIST_SHOW_KEYRING;
2248             break;
2249
2250           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2251           case oDebugAll: opt.debug = ~0; break;
2252           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2253
2254           case oStatusFD:
2255             set_status_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2256             break;
2257           case oStatusFile:
2258             set_status_fd ( open_info_file (pargs.r.ret_str, 1, 0) );
2259             break;
2260           case oAttributeFD:
2261             set_attrib_fd ( translate_sys2libc_fd_int (pargs.r.ret_int, 1) );
2262             break;
2263           case oAttributeFile:
2264             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1, 1) );
2265             break;
2266           case oLoggerFD:
2267             log_set_fd (translate_sys2libc_fd_int (pargs.r.ret_int, 1));
2268             break;
2269           case oLoggerFile:
2270             logfile = pargs.r.ret_str;
2271             break;
2272
2273           case oWithFingerprint:
2274             opt.with_fingerprint = 1;
2275             opt.fingerprint++;
2276             break;
2277           case oFingerprint:
2278             opt.fingerprint++;
2279             fpr_maybe_cmd = 1;
2280             break;
2281
2282           case oSecretKeyring:
2283             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2284             break;
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 (ALWAYS_ADD_KEYRINGS
3386             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3387                 && cmd != aVerify && cmd != aSym && cmd != aLocateKeys))
3388           {
3389             if (!sec_nrings || default_keyring) /* add default secret rings */
3390               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3391             for (sl = sec_nrings; sl; sl = sl->next)
3392               keydb_add_resource ( sl->d, 0, 1 );
3393           }
3394         if( !nrings || default_keyring )  /* add default ring */
3395             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3396         for(sl = nrings; sl; sl = sl->next )
3397             keydb_add_resource ( sl->d, sl->flags, 0 );
3398       }
3399     FREE_STRLIST(nrings);
3400     FREE_STRLIST(sec_nrings);
3401
3402     if (cmd == aGPGConfTest)
3403       g10_exit(0);
3404
3405
3406     if( pwfd != -1 )  /* Read the passphrase now. */
3407         read_passphrase_from_fd( pwfd );
3408
3409     fname = argc? *argv : NULL;
3410
3411     if(fname && utf8_strings)
3412       opt.flags.utf8_filename=1;
3413
3414     switch( cmd ) {
3415       case aPrimegen:
3416       case aPrintMD:
3417       case aPrintMDs:
3418       case aGenRandom:
3419       case aDeArmor:
3420       case aEnArmor:
3421         break;
3422       case aFixTrustDB:
3423       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3424       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3425       default: rc = setup_trustdb(1, trustdb_name ); break;
3426     }
3427     if( rc )
3428         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3429
3430
3431     switch (cmd)
3432       {
3433       case aStore: 
3434       case aSym:  
3435       case aSign: 
3436       case aSignSym: 
3437       case aClearsign: 
3438         if (!opt.quiet && any_explicit_recipient)
3439           log_info (_("WARNING: recipients (-r) given "
3440                       "without using public key encryption\n"));
3441         break;
3442       default:
3443         break;
3444       }
3445
3446     switch( cmd )
3447       {
3448       case aServer:
3449         {
3450           ctrl_t ctrl = xtrycalloc (1, sizeof *ctrl);
3451           gpg_init_default_ctrl (ctrl);
3452           gpg_server (ctrl);
3453           gpg_deinit_default_ctrl (ctrl);
3454           xfree (ctrl);
3455         }
3456         break;
3457
3458       case aStore: /* only store the file */
3459         if( argc > 1 )
3460             wrong_args(_("--store [filename]"));
3461         if( (rc = encrypt_store(fname)) )
3462             log_error ("storing `%s' failed: %s\n",
3463                        print_fname_stdin(fname),g10_errstr(rc) );
3464         break;
3465       case aSym: /* encrypt the given file only with the symmetric cipher */
3466         if( argc > 1 )
3467             wrong_args(_("--symmetric [filename]"));
3468         if( (rc = encrypt_symmetric(fname)) )
3469             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3470                         print_fname_stdin(fname),g10_errstr(rc) );
3471         break;
3472
3473       case aEncr: /* encrypt the given file */
3474         if(multifile)
3475           encrypt_crypt_files(argc, argv, remusr);
3476         else
3477           {
3478             if( argc > 1 )
3479               wrong_args(_("--encrypt [filename]"));
3480             if( (rc = encrypt_crypt (-1, fname, remusr, 0, NULL, -1)) )
3481               log_error("%s: encryption failed: %s\n",
3482                         print_fname_stdin(fname), g10_errstr(rc) );
3483           }
3484         break;
3485
3486       case aEncrSym:
3487         /* This works with PGP 8 in the sense that it acts just like a
3488            symmetric message.  It doesn't work at all with 2 or 6.  It
3489            might work with 7, but alas, I don't have a copy to test
3490            with right now. */
3491         if( argc > 1 )
3492           wrong_args(_("--symmetric --encrypt [filename]"));
3493         else if(opt.s2k_mode==0)
3494           log_error(_("you cannot use --symmetric --encrypt"
3495                       " with --s2k-mode 0\n"));
3496         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3497           log_error(_("you cannot use --symmetric --encrypt"
3498                       " while in %s mode\n"),compliance_option_string());
3499         else
3500           {
3501             if( (rc = encrypt_crypt (-1, fname, remusr, 1, NULL, -1)) )
3502               log_error("%s: encryption failed: %s\n",
3503                         print_fname_stdin(fname), g10_errstr(rc) );
3504           }
3505         break;
3506
3507       case aSign: /* sign the given file */
3508         sl = NULL;
3509         if( detached_sig ) { /* sign all files */
3510             for( ; argc; argc--, argv++ )
3511                 add_to_strlist( &sl, *argv );
3512         }
3513         else {
3514             if( argc > 1 )
3515                 wrong_args(_("--sign [filename]"));
3516             if( argc ) {
3517                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3518                 strcpy(sl->d, fname);
3519             }
3520         }
3521         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3522             log_error("signing failed: %s\n", g10_errstr(rc) );
3523         free_strlist(sl);
3524         break;
3525
3526       case aSignEncr: /* sign and encrypt the given file */
3527         if( argc > 1 )
3528             wrong_args(_("--sign --encrypt [filename]"));
3529         if( argc ) {
3530             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3531             strcpy(sl->d, fname);
3532         }
3533         else
3534             sl = NULL;
3535         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3536             log_error("%s: sign+encrypt failed: %s\n",
3537                       print_fname_stdin(fname), g10_errstr(rc) );
3538         free_strlist(sl);
3539         break;
3540
3541       case aSignEncrSym: /* sign and encrypt the given file */
3542         if( argc > 1 )
3543             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3544         else if(opt.s2k_mode==0)
3545           log_error(_("you cannot use --symmetric --sign --encrypt"
3546                       " with --s2k-mode 0\n"));
3547         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3548           log_error(_("you cannot use --symmetric --sign --encrypt"
3549                       " while in %s mode\n"),compliance_option_string());
3550         else
3551           {
3552             if( argc )
3553               {
3554                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3555                 strcpy(sl->d, fname);
3556               }
3557             else
3558               sl = NULL;
3559             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3560               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3561                         print_fname_stdin(fname), g10_errstr(rc) );
3562             free_strlist(sl);
3563           }
3564         break;
3565
3566       case aSignSym: /* sign and conventionally encrypt the given file */
3567         if (argc > 1)
3568             wrong_args(_("--sign --symmetric [filename]"));
3569         rc = sign_symencrypt_file (fname, locusr);
3570         if (rc)
3571             log_error("%s: sign+symmetric failed: %s\n",
3572                       print_fname_stdin(fname), g10_errstr(rc) );
3573         break;
3574
3575       case aClearsign: /* make a clearsig */
3576         if( argc > 1 )
3577             wrong_args(_("--clearsign [filename]"));
3578         if( (rc = clearsign_file(fname, locusr, NULL)) )
3579             log_error("%s: clearsign failed: %s\n",
3580                       print_fname_stdin(fname), g10_errstr(rc) );
3581         break;
3582
3583       case aVerify:
3584         if(multifile)
3585           {
3586             if( (rc = verify_files( argc, argv ) ))
3587               log_error("verify files failed: %s\n", g10_errstr(rc) );
3588           }
3589         else
3590           {
3591             if( (rc = verify_signatures( argc, argv ) ))
3592               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3593           }
3594         break;
3595
3596       case aDecrypt:
3597         if(multifile)
3598           decrypt_messages(argc, argv);
3599         else
3600           {
3601             if( argc > 1 )
3602               wrong_args(_("--decrypt [filename]"));
3603             if( (rc = decrypt_message( fname ) ))
3604               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3605           }
3606         break;
3607             
3608       case aSignKey:
3609         if( argc != 1 )
3610           wrong_args(_("--sign-key user-id"));
3611         /* fall through */
3612       case aLSignKey:
3613         if( argc != 1 )
3614           wrong_args(_("--lsign-key user-id"));
3615         /* fall through */
3616
3617         sl=NULL;
3618
3619         if(cmd==aSignKey)
3620           append_to_strlist(&sl,"sign");
3621         else if(cmd==aLSignKey)
3622           append_to_strlist(&sl,"lsign");
3623         else
3624           BUG();
3625
3626         append_to_strlist( &sl, "save" );
3627         username = make_username( fname );
3628         keyedit_menu (username, locusr, sl, 0, 0 );
3629         xfree(username);
3630         free_strlist(sl);
3631         break;
3632
3633       case aEditKey: /* Edit a key signature */
3634         if( !argc )
3635             wrong_args(_("--edit-key user-id [commands]"));
3636         username = make_username( fname );
3637         if( argc > 1 ) {
3638             sl = NULL;
3639             for( argc--, argv++ ; argc; argc--, argv++ )
3640                 append_to_strlist( &sl, *argv );
3641             keyedit_menu( username, locusr, sl, 0, 1 );
3642             free_strlist(sl);
3643         }
3644         else
3645             keyedit_menu(username, locusr, NULL, 0, 1 );
3646         xfree(username);
3647         break;
3648
3649       case aPasswd:
3650         if (argc != 1)
3651           wrong_args (_("--passwd <user-id>"));
3652         else
3653           {
3654             username = make_username (fname);
3655             keyedit_passwd (username);
3656             xfree (username);
3657           }
3658         break;
3659
3660       case aDeleteKeys:
3661       case aDeleteSecretKeys:
3662       case aDeleteSecretAndPublicKeys:
3663         sl = NULL;
3664         /* I'm adding these in reverse order as add_to_strlist2
3665            reverses them again, and it's easier to understand in the
3666            proper order :) */
3667         for( ; argc; argc-- )
3668           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3669         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3670         free_strlist(sl);
3671         break;
3672
3673       case aCheckKeys:
3674         opt.check_sigs = 1;
3675       case aListSigs:
3676         opt.list_sigs = 1;
3677       case aListKeys:
3678         sl = NULL;
3679         for( ; argc; argc--, argv++ )
3680             add_to_strlist2( &sl, *argv, utf8_strings );
3681         public_key_list( sl, 0 );
3682         free_strlist(sl);
3683         break;
3684       case aListSecretKeys:
3685         sl = NULL;
3686         for( ; argc; argc--, argv++ )
3687             add_to_strlist2( &sl, *argv, utf8_strings );
3688         secret_key_list( sl );
3689         free_strlist(sl);
3690         break;
3691       case aLocateKeys:
3692         sl = NULL;
3693         for (; argc; argc--, argv++)
3694           add_to_strlist2( &sl, *argv, utf8_strings );
3695         public_key_list (sl, 1);
3696         free_strlist (sl);
3697         break;
3698
3699       case aKeygen: /* generate a key */
3700         if( opt.batch ) {
3701             if( argc > 1 )
3702                 wrong_args("--gen-key [parameterfile]");
3703             generate_keypair( argc? *argv : NULL, NULL, NULL );
3704         }
3705         else {
3706             if( argc )
3707                 wrong_args("--gen-key");
3708             generate_keypair(NULL, NULL, NULL);
3709         }
3710         break;
3711
3712       case aFastImport:
3713         opt.import_options |= IMPORT_FAST;
3714       case aImport:
3715         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3716         break;
3717
3718         /* TODO: There are a number of command that use this same
3719            "make strlist, call function, report error, free strlist"
3720            pattern.  Join them together here and avoid all that
3721            duplicated code. */
3722
3723       case aExport:
3724       case aSendKeys:
3725       case aRecvKeys:
3726         sl = NULL;
3727         for( ; argc; argc--, argv++ )
3728             append_to_strlist2( &sl, *argv, utf8_strings );
3729         if( cmd == aSendKeys )
3730             rc=keyserver_export( sl );
3731         else if( cmd == aRecvKeys )
3732             rc=keyserver_import( sl );
3733         else
3734             rc=export_pubkeys( sl, opt.export_options );
3735         if(rc)
3736           {
3737             if(cmd==aSendKeys)
3738               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3739             else if(cmd==aRecvKeys)
3740               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3741             else
3742               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3743           }
3744         free_strlist(sl);
3745         break;
3746
3747      case aSearchKeys:
3748         sl = NULL;
3749         for( ; argc; argc--, argv++ )
3750           append_to_strlist2( &sl, *argv, utf8_strings );
3751         rc=keyserver_search( sl );
3752         if(rc)
3753           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3754         free_strlist(sl);
3755         break;
3756
3757       case aRefreshKeys:
3758         sl = NULL;
3759         for( ; argc; argc--, argv++ )
3760             append_to_strlist2( &sl, *argv, utf8_strings );
3761         rc=keyserver_refresh(sl);
3762         if(rc)
3763           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3764         free_strlist(sl);
3765         break;
3766
3767       case aFetchKeys:
3768         sl = NULL;
3769         for( ; argc; argc--, argv++ )
3770             append_to_strlist2( &sl, *argv, utf8_strings );
3771         rc=keyserver_fetch(sl);
3772         if(rc)
3773           log_error("key fetch failed: %s\n",g10_errstr(rc));
3774         free_strlist(sl);
3775         break;
3776
3777       case aExportSecret:
3778         sl = NULL;
3779         for( ; argc; argc--, argv++ )
3780             add_to_strlist2( &sl, *argv, utf8_strings );
3781         export_seckeys( sl );
3782         free_strlist(sl);
3783         break;
3784
3785       case aExportSecretSub:
3786         sl = NULL;
3787         for( ; argc; argc--, argv++ )
3788             add_to_strlist2( &sl, *argv, utf8_strings );
3789         export_secsubkeys( sl );
3790         free_strlist(sl);
3791         break;
3792
3793       case aGenRevoke:
3794         if( argc != 1 )
3795             wrong_args("--gen-revoke user-id");
3796         username =  make_username(*argv);
3797         gen_revoke( username );
3798         xfree( username );
3799         break;
3800
3801       case aDesigRevoke:
3802         if( argc != 1 )
3803             wrong_args("--desig-revoke user-id");
3804         username =  make_username(*argv);
3805         gen_desig_revoke( username, locusr );
3806         xfree( username );
3807         break;
3808
3809       case aDeArmor:
3810         if( argc > 1 )
3811             wrong_args("--dearmor [file]");
3812         rc = dearmor_file( argc? *argv: NULL );
3813         if( rc )
3814             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3815         break;
3816
3817       case aEnArmor:
3818         if( argc > 1 )
3819             wrong_args("--enarmor [file]");
3820         rc = enarmor_file( argc? *argv: NULL );
3821         if( rc )
3822             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3823         break;
3824
3825
3826       case aPrimegen:
3827 #if 0 /*FIXME*/
3828         {   int mode = argc < 2 ? 0 : atoi(*argv);
3829
3830             if( mode == 1 && argc == 2 ) {
3831                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3832             }
3833             else if( mode == 2 && argc == 3 ) {
3834                 mpi_print( stdout, generate_elg_prime(
3835                                              0, atoi(argv[1]),
3836                                              atoi(argv[2]), NULL,NULL ), 1);
3837             }
3838             else if( mode == 3 && argc == 3 ) {
3839                 MPI *factors;
3840                 mpi_print( stdout, generate_elg_prime(
3841                                              1, atoi(argv[1]),
3842                                              atoi(argv[2]), NULL,&factors ), 1);
3843                 putchar('\n');
3844                 mpi_print( stdout, factors[0], 1 ); /* print q */
3845             }
3846             else if( mode == 4 && argc == 3 ) {
3847                 MPI g = mpi_alloc(1);
3848                 mpi_print( stdout, generate_elg_prime(
3849                                                  0, atoi(argv[1]),
3850                                                  atoi(argv[2]), g, NULL ), 1);
3851                 putchar('\n');
3852                 mpi_print( stdout, g, 1 );
3853                 mpi_free(g);
3854             }
3855             else
3856                 wrong_args("--gen-prime mode bits [qbits] ");
3857             putchar('\n');
3858         }
3859 #endif
3860         wrong_args("--gen-prime not yet supported ");
3861         break;
3862
3863       case aGenRandom:
3864         {
3865             int level = argc ? atoi(*argv):0;
3866             int count = argc > 1 ? atoi(argv[1]): 0;
3867             int endless = !count;
3868
3869             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3870                 wrong_args("--gen-random 0|1|2 [count]");
3871
3872             while( endless || count ) {
3873                 byte *p;
3874                 /* Wee need a multiple of 3, so that in case of
3875                    armored output we get a correct string.  No
3876                    linefolding is done, as it is best to levae this to
3877                    other tools */
3878                 size_t n = !endless && count < 99? count : 99;
3879
3880                 p = gcry_random_bytes (n, level);
3881 #ifdef HAVE_DOSISH_SYSTEM
3882                 setmode ( fileno(stdout), O_BINARY );
3883 #endif
3884                 if (opt.armor) {
3885                     char *tmp = make_radix64_string (p, n);
3886                     fputs (tmp, stdout);
3887                     xfree (tmp);
3888                     if (n%3 == 1)
3889                       putchar ('=');
3890                     if (n%3)
3891                       putchar ('=');
3892                 } else {
3893                     fwrite( p, n, 1, stdout );
3894                 }
3895                 xfree(p);
3896                 if( !endless )
3897                     count -= n;
3898             }
3899             if (opt.armor)
3900                 putchar ('\n');
3901         }
3902         break;
3903
3904       case aPrintMD:
3905         if( argc < 1)
3906             wrong_args("--print-md algo [files]");
3907         {
3908             int all_algos = (**argv=='*' && !(*argv)[1]);
3909             int algo = all_algos? 0 : gcry_md_map_name (*argv);
3910
3911             if( !algo && !all_algos )
3912                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3913             else {
3914                 argc--; argv++;
3915                 if( !argc )
3916                     print_mds(NULL, algo);
3917                 else {
3918                     for(; argc; argc--, argv++ )
3919                         print_mds(*argv, algo);
3920                 }
3921             }
3922         }
3923         break;
3924
3925       case aPrintMDs: /* old option */
3926         if( !argc )
3927             print_mds(NULL,0);
3928         else {
3929             for(; argc; argc--, argv++ )
3930                 print_mds(*argv,0);
3931         }
3932         break;
3933
3934       case aListTrustDB:
3935         if( !argc )
3936             list_trustdb(NULL);
3937         else {
3938             for( ; argc; argc--, argv++ )
3939                 list_trustdb( *argv );
3940         }
3941         break;
3942
3943       case aUpdateTrustDB:
3944         if( argc )
3945             wrong_args("--update-trustdb");
3946         update_trustdb();
3947         break;
3948
3949       case aCheckTrustDB:
3950         /* Old versions allowed for arguments - ignore them */
3951         check_trustdb();
3952         break;
3953
3954       case aFixTrustDB:
3955         how_to_fix_the_trustdb ();
3956         break;
3957
3958       case aListTrustPath:
3959         if( !argc )
3960             wrong_args("--list-trust-path <user-ids>");
3961         for( ; argc; argc--, argv++ ) {
3962             username = make_username( *argv );
3963             list_trust_path( username );
3964             xfree(username);
3965         }
3966         break;
3967
3968       case aExportOwnerTrust:
3969         if( argc )
3970             wrong_args("--export-ownertrust");
3971         export_ownertrust();
3972         break;
3973
3974       case aImportOwnerTrust:
3975         if( argc > 1 )
3976             wrong_args("--import-ownertrust [file]");
3977         import_ownertrust( argc? *argv:NULL );
3978         break;
3979       
3980       case aRebuildKeydbCaches:
3981         if (argc)
3982             wrong_args ("--rebuild-keydb-caches");
3983         keydb_rebuild_caches (1);
3984         break;
3985
3986 #ifdef ENABLE_CARD_SUPPORT
3987       case aCardStatus:
3988         if (argc)
3989             wrong_args ("--card-status");
3990         card_status (stdout, NULL, 0);
3991         break;
3992
3993       case aCardEdit:
3994         if (argc) {
3995             sl = NULL;
3996             for (argc--, argv++ ; argc; argc--, argv++)
3997                 append_to_strlist (&sl, *argv);
3998             card_edit (sl);
3999             free_strlist (sl);
4000         }
4001         else
4002             card_edit (NULL);
4003         break;
4004
4005       case aChangePIN:
4006         if (!argc)
4007             change_pin (0,1);
4008         else if (argc == 1)
4009             change_pin (atoi (*argv),1);
4010         else
4011         wrong_args ("--change-pin [no]");
4012         break;
4013 #endif /* ENABLE_CARD_SUPPORT*/
4014
4015       case aListConfig:
4016         {
4017           char *str=collapse_args(argc,argv);
4018           list_config(str);
4019           xfree(str);
4020         }
4021         break;
4022
4023       case aListPackets:
4024         opt.list_packets=2;
4025       default:
4026         if( argc > 1 )
4027             wrong_args(_("[filename]"));
4028         /* Issue some output for the unix newbie */
4029         if( !fname && !opt.outfile && isatty( fileno(stdin) )
4030                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
4031             log_info(_("Go ahead and type your message ...\n"));
4032
4033         a = iobuf_open(fname);
4034         if (a && is_secured_file (iobuf_get_fd (a)))
4035           {
4036             iobuf_close (a);
4037             a = NULL;
4038             errno = EPERM;
4039           }
4040         if( !a )
4041             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
4042         else {
4043
4044             if( !opt.no_armor ) {
4045                 if( use_armor_filter( a ) ) {
4046                     afx = new_armor_context ();
4047                     push_armor_filter (afx, a);
4048                 }
4049             }
4050             if( cmd == aListPackets ) {
4051                 set_packet_list_mode(1);
4052                 opt.list_packets=1;
4053             }
4054             rc = proc_packets(NULL, a );
4055             if( rc )
4056                 log_error("processing message failed: %s\n", g10_errstr(rc) );
4057             iobuf_close(a);
4058         }
4059         break;
4060       }
4061
4062     /* cleanup */
4063     release_armor_context (afx);
4064     FREE_STRLIST(remusr);
4065     FREE_STRLIST(locusr);
4066     g10_exit(0);
4067     return 8; /*NEVER REACHED*/
4068 }
4069
4070
4071 /* Note: This function is used by signal handlers!. */
4072 static void
4073 emergency_cleanup (void)
4074 {
4075   gcry_control (GCRYCTL_TERM_SECMEM );
4076 }
4077
4078
4079 void
4080 g10_exit( int rc )
4081 {
4082   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
4083   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
4084     {
4085       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
4086       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
4087     }
4088   if (opt.debug)
4089     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
4090
4091   emergency_cleanup ();
4092   
4093   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
4094   exit (rc);
4095 }
4096
4097
4098 /* Pretty-print hex hashes.  This assumes at least an 80-character
4099    display, but there are a few other similar assumptions in the
4100    display code. */
4101 static void
4102 print_hex( gcry_md_hd_t md, int algo, const char *fname )
4103 {
4104   int i,n,count,indent=0;
4105   const byte *p;
4106
4107   if(fname)
4108     indent=printf("%s: ",fname);
4109
4110   if(indent>40)
4111     {
4112       printf("\n");
4113       indent=0;
4114     }
4115
4116   if(algo==DIGEST_ALGO_RMD160)
4117     indent+=printf("RMD160 = ");
4118   else if(algo>0)
4119     indent+=printf("%6s = ", gcry_md_algo_name (algo));
4120   else
4121     algo=abs(algo);
4122
4123   count=indent;
4124
4125   p = gcry_md_read (md, algo);
4126   n = gcry_md_get_algo_dlen (algo);
4127
4128   count += printf ("%02X",*p++);
4129
4130   for(i=1;i<n;i++,p++)
4131     {
4132       if(n==16)
4133         {
4134           if(count+2>79)
4135             {
4136               printf("\n%*s",indent," ");
4137               count=indent;
4138             }
4139           else
4140             count+=printf(" ");
4141
4142           if(!(i%8))
4143             count+=printf(" ");
4144         }
4145       else if (n==20)
4146         {
4147           if(!(i%2))
4148             {
4149               if(count+4>79)
4150                 {
4151                   printf("\n%*s",indent," ");
4152                   count=indent;