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