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