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