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