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