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