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