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