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