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