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