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