44ea8048e14b0923fd6e35055ebbe55e8b44c407
[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   char *configfile_esc = percent_escape (configfile, NULL);
1460
1461   /* The following definitions are taken from gnupg/tools/gpgconf-comp.c.  */
1462 #define GC_OPT_FLAG_NONE        0UL
1463 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1464
1465   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1466           GC_OPT_FLAG_DEFAULT, configfile_esc ? configfile_esc : "/dev/null");
1467   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1468   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1469   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1470   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1471
1472   xfree (configfile_esc);
1473 }
1474
1475
1476 static int
1477 parse_subpacket_list(char *list)
1478 {
1479   char *tok;
1480   byte subpackets[128],i;
1481   int count=0;
1482
1483   if(!list)
1484     {
1485       /* No arguments means all subpackets */
1486       memset(subpackets+1,1,sizeof(subpackets)-1);
1487       count=127;
1488     }
1489   else
1490     {
1491       memset(subpackets,0,sizeof(subpackets));
1492
1493       /* Merge with earlier copy */
1494       if(opt.show_subpackets)
1495         {
1496           byte *in;
1497
1498           for(in=opt.show_subpackets;*in;in++)
1499             {
1500               if(*in>127 || *in<1)
1501                 BUG();
1502
1503               if(!subpackets[*in])
1504                 count++;
1505               subpackets[*in]=1;
1506             }
1507         }
1508
1509       while((tok=strsep(&list," ,")))
1510         {
1511           if(!*tok)
1512             continue;
1513
1514           i=atoi(tok);
1515           if(i>127 || i<1)
1516             return 0;
1517
1518           if(!subpackets[i])
1519             count++;
1520           subpackets[i]=1;
1521         }
1522     }
1523
1524   xfree(opt.show_subpackets);
1525   opt.show_subpackets=xmalloc(count+1);
1526   opt.show_subpackets[count--]=0;
1527
1528   for(i=1;i<128 && count>=0;i++)
1529     if(subpackets[i])
1530       opt.show_subpackets[count--]=i;
1531
1532   return 1;
1533 }
1534
1535
1536 static int
1537 parse_list_options(char *str)
1538 {
1539   char *subpackets=""; /* something that isn't NULL */
1540   struct parse_options lopts[]=
1541     {
1542       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1543        N_("display photo IDs during key listings")},
1544       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1545        N_("show policy URLs during signature listings")},
1546       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1547        N_("show all notations during signature listings")},
1548       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1549        N_("show IETF standard notations during signature listings")},
1550       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1551        NULL},
1552       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1553        N_("show user-supplied notations during signature listings")},
1554       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1555        N_("show preferred keyserver URLs during signature listings")},
1556       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1557        N_("show user ID validity during key listings")},
1558       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1559        N_("show revoked and expired user IDs in key listings")},
1560       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1561        N_("show revoked and expired subkeys in key listings")},
1562       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1563        N_("show the keyring name in key listings")},
1564       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1565        N_("show expiration dates during signature listings")},
1566       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1567        NULL},
1568       {NULL,0,NULL,NULL}
1569     };
1570
1571   /* C99 allows for non-constant initializers, but we'd like to
1572      compile everywhere, so fill in the show-sig-subpackets argument
1573      here.  Note that if the parse_options array changes, we'll have
1574      to change the subscript here. */
1575   lopts[12].value=&subpackets;
1576
1577   if(parse_options(str,&opt.list_options,lopts,1))
1578     {
1579       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1580         {
1581           /* Unset so users can pass multiple lists in. */
1582           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1583           if(!parse_subpacket_list(subpackets))
1584             return 0;
1585         }
1586       else if(subpackets==NULL && opt.show_subpackets)
1587         {
1588           /* User did 'no-show-subpackets' */
1589           xfree(opt.show_subpackets);
1590           opt.show_subpackets=NULL;
1591         }
1592
1593       return 1;
1594     }
1595   else
1596     return 0;
1597 }
1598
1599
1600 /* Collapses argc/argv into a single string that must be freed */
1601 static char *
1602 collapse_args(int argc,char *argv[])
1603 {
1604   char *str=NULL;
1605   int i,first=1,len=0;
1606
1607   for(i=0;i<argc;i++)
1608     {
1609       len+=strlen(argv[i])+2;
1610       str=xrealloc(str,len);
1611       if(first)
1612         {
1613           str[0]='\0';
1614           first=0;
1615         }
1616       else
1617         strcat(str," ");
1618
1619       strcat(str,argv[i]);
1620     }
1621
1622   return str;
1623 }
1624
1625 static void
1626 parse_trust_model(const char *model)
1627 {
1628   if(ascii_strcasecmp(model,"pgp")==0)
1629     opt.trust_model=TM_PGP;
1630   else if(ascii_strcasecmp(model,"classic")==0)
1631     opt.trust_model=TM_CLASSIC;
1632   else if(ascii_strcasecmp(model,"always")==0)
1633     opt.trust_model=TM_ALWAYS;
1634   else if(ascii_strcasecmp(model,"direct")==0)
1635     opt.trust_model=TM_DIRECT;
1636   else if(ascii_strcasecmp(model,"auto")==0)
1637     opt.trust_model=TM_AUTO;
1638   else
1639     log_error("unknown trust model `%s'\n",model);
1640 }
1641
1642
1643
1644 /* Make sure that the standard file descriptors are opened. Obviously
1645    some folks close them before an exec and the next file we open will
1646    get one of them assigned and thus any output (i.e. diagnostics) end
1647    up in that file (e.g. the trustdb).  Not actually a gpg problem as
1648    this will hapenn with almost all utilities when called in a wrong
1649    way.  However we try to minimize the damage here and raise
1650    awareness of the problem.
1651
1652    Must be called before we open any files! */
1653 static void
1654 reopen_std(void)
1655 {  
1656 #if defined(HAVE_STAT) && !defined(HAVE_W32_SYSTEM)
1657   struct stat statbuf;
1658   int did_stdin=0,did_stdout=0,did_stderr=0;
1659   FILE *complain;
1660
1661   if(fstat(STDIN_FILENO,&statbuf)==-1 && errno==EBADF)
1662     {
1663       if(open("/dev/null",O_RDONLY)==STDIN_FILENO)
1664         did_stdin=1;
1665       else
1666         did_stdin=2;
1667     }
1668
1669   if(fstat(STDOUT_FILENO,&statbuf)==-1 && errno==EBADF)
1670     {
1671       if(open("/dev/null",O_WRONLY)==STDOUT_FILENO)
1672         did_stdout=1;
1673       else
1674         did_stdout=2;
1675     }
1676
1677   if(fstat(STDERR_FILENO,&statbuf)==-1 && errno==EBADF)
1678     {
1679       if(open("/dev/null",O_WRONLY)==STDERR_FILENO)
1680         did_stderr=1;
1681       else
1682         did_stderr=2;
1683     }
1684
1685   /* It's hard to log this sort of thing since the filehandle we would
1686      complain to may be closed... */
1687   if(did_stderr==0)
1688     complain=stderr;
1689   else if(did_stdout==0)
1690     complain=stdout;
1691   else
1692     complain=NULL;
1693
1694   if(complain)
1695     {
1696       if(did_stdin==1)
1697         fprintf(complain,"gpg: WARNING: standard input reopened\n");
1698       if(did_stdout==1)
1699         fprintf(complain,"gpg: WARNING: standard output reopened\n");
1700       if(did_stderr==1)
1701         fprintf(complain,"gpg: WARNING: standard error reopened\n");
1702
1703       if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1704         fprintf(complain,"gpg: fatal: unable to reopen standard input,"
1705                 " output, or error\n");
1706     }
1707
1708   if(did_stdin==2 || did_stdout==2 || did_stderr==2)
1709     exit(3);
1710 #endif /* HAVE_STAT && !HAVE_W32_SYSTEM */
1711 }
1712
1713 /* Pack an s2k iteration count into the form specified in 2440.  If
1714    we're in between valid values, round up. */
1715 static unsigned char
1716 encode_s2k_iterations(int iterations)
1717 {
1718   unsigned char c=0,result;
1719   unsigned int count;
1720
1721   if(iterations<=1024)
1722     return 0;
1723
1724   if(iterations>=65011712)
1725     return 255;
1726
1727   /* Need count to be in the range 16-31 */
1728   for(count=iterations>>6;count>=32;count>>=1)
1729     c++;
1730
1731   result=(c<<4)|(count-16);
1732
1733   if(S2K_DECODE_COUNT(result)<iterations)
1734     result++;
1735
1736   return result;
1737 }
1738
1739
1740 /* This fucntion called to initialized a new control object.  It is
1741    assumed that this object has been zeroed out before calling this
1742    function. */
1743 static void
1744 gpg_init_default_ctrl (ctrl_t ctrl)
1745 {
1746 }
1747
1748
1749 /* This function is called to deinitialize a control object.  It is
1750    not deallocated. */
1751 static void
1752 gpg_deinit_default_ctrl (ctrl_t ctrl)
1753 {
1754 }
1755
1756
1757
1758 int
1759 main (int argc, char **argv )
1760 {
1761     ARGPARSE_ARGS pargs;
1762     IOBUF a;
1763     int rc=0;
1764     int orig_argc;
1765     char **orig_argv;
1766     const char *fname;
1767     char *username;
1768     int may_coredump;
1769     strlist_t sl, remusr= NULL, locusr=NULL;
1770     strlist_t nrings=NULL, sec_nrings=NULL;
1771     armor_filter_context_t *afx = NULL;
1772     int detached_sig = 0;
1773     FILE *configfp = NULL;
1774     char *configname = NULL;
1775     char *save_configname = NULL;
1776     unsigned configlineno;
1777     int parse_debug = 0;
1778     int default_config = 1;
1779     int default_keyring = 1;
1780     int greeting = 0;
1781     int nogreeting = 0;
1782     char *logfile = NULL;
1783     int use_random_seed = 1;
1784     enum cmd_and_opt_values cmd = 0;
1785     const char *debug_level = NULL;
1786     const char *trustdb_name = NULL;
1787     char *def_cipher_string = NULL;
1788     char *def_digest_string = NULL;
1789     char *compress_algo_string = NULL;
1790     char *cert_digest_string = NULL;
1791     char *s2k_cipher_string = NULL;
1792     char *s2k_digest_string = NULL;
1793     char *pers_cipher_list = NULL;
1794     char *pers_digest_list = NULL;
1795     char *pers_compress_list = NULL;
1796     int eyes_only=0;
1797     int multifile=0;
1798     int pwfd = -1;
1799     int with_fpr = 0; /* make an option out of --fingerprint */
1800     int any_explicit_recipient = 0;
1801     int require_secmem=0,got_secmem=0;
1802
1803 #ifdef __riscos__
1804     opt.lock_once = 1;
1805 #endif /* __riscos__ */
1806
1807
1808     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1809        when adding any stuff between here and the call to
1810        secmem_init() somewhere after the option parsing. */
1811     reopen_std ();
1812     trap_unaligned ();
1813     gnupg_rl_initialize ();
1814     set_strusage (my_strusage);
1815     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1816     /* We don't need any locking in libgcrypt unless we use any kind of
1817        threading. */
1818     gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1819     log_set_prefix ("gpg", 1);
1820
1821     /* Make sure that our subsystems are ready.  */
1822     init_common_subsystems ();
1823
1824     /* Check that the libraries are suitable.  Do it right here because the
1825        option parsing may need services of the library.  */
1826     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1827       {
1828         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1829                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1830       }
1831
1832     /* Put random number into secure memory */
1833     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1834
1835     may_coredump = disable_core_dumps();
1836
1837     gnupg_init_signals (0, emergency_cleanup);
1838
1839     create_dotlock(NULL); /* Register locking cleanup. */
1840
1841     i18n_init();
1842
1843     opt.command_fd = -1; /* no command fd */
1844     opt.compress_level = -1; /* defaults to standard compress level */
1845     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1846     /* note: if you change these lines, look at oOpenPGP */
1847     opt.def_cipher_algo = 0;
1848     opt.def_digest_algo = 0;
1849     opt.cert_digest_algo = 0;
1850     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1851     opt.s2k_mode = 3; /* iterated+salted */
1852     opt.s2k_count = 96; /* 65536 iterations */
1853 #ifdef USE_CAST5
1854     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1855 #else
1856     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1857 #endif
1858     opt.completes_needed = 1;
1859     opt.marginals_needed = 3;
1860     opt.max_cert_depth = 5;
1861     opt.pgp2_workarounds = 1;
1862     opt.force_v3_sigs = 1;
1863     opt.escape_from = 1;
1864     opt.import_options=IMPORT_SK2PK;
1865     opt.export_options=EXPORT_ATTRIBUTES;
1866     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1867     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1868     opt.keyserver_options.options=
1869       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1870     opt.verify_options=
1871       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1872     opt.trust_model=TM_AUTO;
1873     opt.mangle_dos_filenames=0;
1874     opt.min_cert_level=2;
1875     set_screen_dimensions();
1876     opt.keyid_format=KF_SHORT;
1877     opt.rfc2440_text=1;
1878     opt.def_sig_expire="0";
1879     opt.def_cert_expire="0";
1880     set_homedir ( default_homedir () );
1881     opt.passwd_repeat=1;
1882
1883     /* Check whether we have a config file on the command line.  */
1884     orig_argc = argc;
1885     orig_argv = argv;
1886     pargs.argc = &argc;
1887     pargs.argv = &argv;
1888     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1889     while( arg_parse( &pargs, opts) ) {
1890         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1891             parse_debug++;
1892         else if( pargs.r_opt == oOptions ) {
1893             /* yes there is one, so we do not try the default one, but
1894              * read the option file when it is encountered at the commandline
1895              */
1896             default_config = 0;
1897         }
1898         else if( pargs.r_opt == oNoOptions )
1899             default_config = 0; /* --no-options */
1900         else if( pargs.r_opt == oHomedir )
1901             set_homedir ( pargs.r.ret_str );
1902         else if( pargs.r_opt == oNoPermissionWarn )
1903             opt.no_perm_warn=1;
1904         else if (pargs.r_opt == oStrict )
1905           {
1906             /* Not used */
1907           }
1908         else if (pargs.r_opt == oNoStrict )
1909           {
1910             /* Not used */
1911           }
1912     }
1913
1914 #ifdef HAVE_DOSISH_SYSTEM
1915     if ( strchr (opt.homedir,'\\') ) {
1916         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1917         const char *s = opt.homedir;
1918         for (d=buf,s=opt.homedir; *s; s++)
1919           {
1920             *d++ = *s == '\\'? '/': *s;
1921 #ifdef HAVE_W32_SYSTEM
1922             if (s[1] && IsDBCSLeadByte (*s))
1923               *d++ = *++s;
1924 #endif
1925           }
1926         *d = 0;
1927         set_homedir (buf);
1928     }
1929 #endif
1930
1931     /* Initialize the secure memory. */
1932     if (!gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0))
1933       got_secmem = 1; 
1934 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1935     /* There should be no way to get to this spot while still carrying
1936        setuid privs.  Just in case, bomb out if we are. */
1937     if(getuid()!=geteuid())
1938       BUG();
1939 #endif
1940     maybe_setuid = 0;
1941
1942     /* Okay, we are now working under our real uid */
1943
1944     /* malloc hooks go here ... */
1945     assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1946     assuan_set_assuan_err_source (GPG_ERR_SOURCE_DEFAULT);
1947  
1948
1949     /* Try for a version specific config file first */
1950     if( default_config )
1951       {
1952         char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1953         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1954
1955         do
1956           {
1957             if(configname)
1958               {
1959                 char *tok;
1960
1961                 xfree(configname);
1962                 configname=NULL;
1963
1964                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1965                   *tok='\0';
1966                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1967                   *tok='\0';
1968                 else
1969                   break;
1970               }
1971
1972             configname = make_filename(opt.homedir,name,NULL);
1973           }
1974         while(access(configname,R_OK));
1975
1976         xfree(name);
1977
1978         if(!configname)
1979           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1980         if (!access (configname, R_OK))
1981           { /* Print a warning when both config files are present. */
1982             char *p = make_filename(opt.homedir, "options", NULL );
1983             if (!access (p, R_OK))
1984               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1985             xfree (p);
1986           }
1987         else
1988           { /* Keep on using the old default one. */
1989             xfree (configname);
1990             configname = make_filename(opt.homedir, "options", NULL );
1991           }
1992       }
1993     argc = orig_argc;
1994     argv = orig_argv;
1995     pargs.argc = &argc;
1996     pargs.argv = &argv;
1997     pargs.flags=  1;  /* do not remove the args */
1998
1999     /* By this point we have a homedir, and cannot change it. */
2000     check_permissions(opt.homedir,0);
2001
2002   next_pass:
2003     if( configname ) {
2004       if(check_permissions(configname,1))
2005         {
2006           /* If any options file is unsafe, then disable any external
2007              programs for keyserver calls or photo IDs.  Since the
2008              external program to call is set in the options file, a
2009              unsafe options file can lead to an arbitrary program
2010              being run. */
2011
2012           opt.exec_disable=1;
2013         }
2014
2015         configlineno = 0;
2016         configfp = fopen( configname, "r" );
2017         if (configfp && is_secured_file (fileno (configfp)))
2018           {
2019             fclose (configfp);
2020             configfp = NULL;
2021             errno = EPERM;
2022           }
2023         if( !configfp ) {
2024             if( default_config ) {
2025                 if( parse_debug )
2026                     log_info(_("NOTE: no default option file `%s'\n"),
2027                                                             configname );
2028             }
2029             else {
2030                 log_error(_("option file `%s': %s\n"),
2031                                     configname, strerror(errno) );
2032                 g10_exit(2);
2033             }
2034             xfree(configname); configname = NULL;
2035         }
2036         if( parse_debug && configname )
2037             log_info(_("reading options from `%s'\n"), configname );
2038         default_config = 0;
2039     }
2040
2041     while( optfile_parse( configfp, configname, &configlineno,
2042                                                 &pargs, opts) )
2043       {
2044         switch( pargs.r_opt )
2045           {
2046           case aCheckKeys: 
2047           case aListConfig:
2048           case aGPGConfList:
2049           case aGPGConfTest:
2050           case aListPackets:
2051           case aImport: 
2052           case aFastImport: 
2053           case aSendKeys: 
2054           case aRecvKeys: 
2055           case aSearchKeys:
2056           case aRefreshKeys:
2057           case aFetchKeys:
2058           case aExport: 
2059 #ifdef ENABLE_CARD_SUPPORT
2060           case aCardStatus:
2061           case aCardEdit: 
2062           case aChangePIN:
2063 #endif /* ENABLE_CARD_SUPPORT*/
2064           case aListKeys: 
2065           case aListSigs: 
2066           case aExportSecret: 
2067           case aExportSecretSub: 
2068           case aSym:
2069           case aClearsign: 
2070           case aGenRevoke: 
2071           case aDesigRevoke: 
2072           case aPrimegen: 
2073           case aGenRandom:
2074           case aPrintMD:
2075           case aPrintMDs: 
2076           case aListTrustDB: 
2077           case aCheckTrustDB:
2078           case aUpdateTrustDB: 
2079           case aFixTrustDB: 
2080           case aListTrustPath: 
2081           case aDeArmor: 
2082           case aEnArmor: 
2083           case aSign: 
2084           case aSignKey: 
2085           case aLSignKey:
2086           case aStore: 
2087           case aExportOwnerTrust: 
2088           case aImportOwnerTrust: 
2089           case aRebuildKeydbCaches:
2090             set_cmd (&cmd, pargs.r_opt);
2091             break;
2092
2093           case aKeygen: 
2094           case aEditKey:
2095           case aDeleteSecretKeys:
2096           case aDeleteSecretAndPublicKeys:
2097           case aDeleteKeys:
2098             set_cmd (&cmd, pargs.r_opt);
2099             greeting=1;
2100             break;
2101
2102           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
2103
2104           case aDecryptFiles: multifile=1; /* fall through */
2105           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
2106
2107           case aEncrFiles: multifile=1; /* fall through */
2108           case aEncr: set_cmd( &cmd, aEncr); break;
2109
2110           case aVerifyFiles: multifile=1; /* fall through */
2111           case aVerify: set_cmd( &cmd, aVerify); break;
2112
2113           case aServer:
2114             set_cmd (&cmd, pargs.r_opt);
2115             opt.batch = 1;
2116             break;
2117
2118           case oArmor: opt.armor = 1; opt.no_armor=0; break;
2119           case oOutput: opt.outfile = pargs.r.ret_str; break;
2120           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
2121           case oQuiet: opt.quiet = 1; break;
2122           case oNoTTY: tty_no_terminal(1); break;
2123           case oDryRun: opt.dry_run = 1; break;
2124           case oInteractive: opt.interactive = 1; break;
2125           case oVerbose:
2126             opt.verbose++;
2127             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2128             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2129             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2130             break;
2131
2132           case oBatch:
2133             opt.batch = 1;
2134             nogreeting = 1;
2135             break;
2136
2137           case oUseAgent: /* Dummy. */
2138             break;
2139           case oNoUseAgent:
2140             obsolete_option (configname, configlineno, "--no-use-agent");
2141             break;
2142           case oGpgAgentInfo: 
2143             obsolete_option (configname, configlineno, "--gpg-agent-info");
2144             break;
2145
2146           case oAnswerYes: opt.answer_yes = 1; break;
2147           case oAnswerNo: opt.answer_no = 1; break;
2148           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2149           case oPrimaryKeyring:
2150             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2151             sl->flags=2;
2152             break;
2153           case oShowKeyring:
2154             deprecated_warning(configname,configlineno,"--show-keyring",
2155                                "--list-options ","show-keyring");
2156             opt.list_options|=LIST_SHOW_KEYRING;
2157             break;
2158
2159           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2160           case oDebugAll: opt.debug = ~0; break;
2161           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2162
2163           case oStatusFD:
2164             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2165             break;
2166           case oStatusFile:
2167             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2168             break;
2169           case oAttributeFD:
2170             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2171             break;
2172           case oAttributeFile:
2173             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2174             break;
2175           case oLoggerFD:
2176             log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
2177             break;
2178           case oLoggerFile:
2179             logfile = pargs.r.ret_str;
2180             break;
2181
2182           case oWithFingerprint:
2183             opt.with_fingerprint = 1;
2184             with_fpr=1; /*fall thru*/
2185           case oFingerprint: opt.fingerprint++; break;
2186           case oSecretKeyring:
2187             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2188             break;
2189           case oOptions:
2190             /* config files may not be nested (silently ignore them) */
2191             if( !configfp ) {
2192                 xfree(configname);
2193                 configname = xstrdup(pargs.r.ret_str);
2194                 goto next_pass;
2195             }
2196             break;
2197           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2198           case oNoDefKeyring: default_keyring = 0; break;
2199           case oNoGreeting: nogreeting = 1; break;
2200           case oNoVerbose: 
2201             opt.verbose = 0;
2202             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2203             opt.list_sigs=0;
2204             break;
2205           case oQuickRandom: 
2206             gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
2207             break;
2208           case oEmitVersion: opt.no_version=0; break;
2209           case oNoEmitVersion: opt.no_version=1; break;
2210           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2211           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2212           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2213           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2214           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2215           case oDefRecipient:
2216             if( *pargs.r.ret_str )
2217               opt.def_recipient = make_username(pargs.r.ret_str);
2218             break;
2219           case oDefRecipientSelf:
2220             xfree(opt.def_recipient); opt.def_recipient = NULL;
2221             opt.def_recipient_self = 1;
2222             break;
2223           case oNoDefRecipient:
2224             xfree(opt.def_recipient); opt.def_recipient = NULL;
2225             opt.def_recipient_self = 0;
2226             break;
2227           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2228           case oHomedir: break;
2229           case oNoBatch: opt.batch = 0; break;
2230           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2231           case oWithColons: opt.with_colons=':'; break;
2232
2233           case oSkipVerify: opt.skip_verify=1; break;
2234           case oCompressKeys: opt.compress_keys = 1; break;
2235           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2236             /* There are many programs (like mutt) that call gpg with
2237                --always-trust so keep this option around for a long
2238                time. */
2239           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2240           case oTrustModel:
2241             parse_trust_model(pargs.r.ret_str);
2242             break;
2243           case oForceOwnertrust:
2244             log_info(_("NOTE: %s is not for normal use!\n"),
2245                      "--force-ownertrust");
2246             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2247             if(opt.force_ownertrust==-1)
2248               {
2249                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2250                 opt.force_ownertrust=0;
2251               }
2252             break;
2253           case oLoadExtension:
2254             /* Dummy so that gpg 1.4 conf files can work. Should
2255                eventually be removed.  */
2256             break;
2257           case oRFC1991:
2258             opt.compliance = CO_RFC1991;
2259             opt.force_v4_certs = 0;
2260             opt.escape_from = 1;
2261             break;
2262           case oOpenPGP:
2263           case oRFC2440:
2264             /* TODO: When 2440bis becomes a RFC, set new values for
2265                oOpenPGP. */
2266             opt.rfc2440_text=1;
2267             opt.compliance = CO_RFC2440;
2268             opt.allow_non_selfsigned_uid = 1;
2269             opt.allow_freeform_uid = 1;
2270             opt.pgp2_workarounds = 0;
2271             opt.escape_from = 0;
2272             opt.force_v3_sigs = 0;
2273             opt.compress_keys = 0;          /* not mandated, but we do it */
2274             opt.compress_sigs = 0;          /* ditto. */
2275             opt.not_dash_escaped = 0;
2276             opt.def_cipher_algo = 0;
2277             opt.def_digest_algo = 0;
2278             opt.cert_digest_algo = 0;
2279             opt.compress_algo = -1;
2280             opt.s2k_mode = 3; /* iterated+salted */
2281             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2282             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2283             break;
2284           case oPGP2:  opt.compliance = CO_PGP2;  break;
2285           case oPGP6:  opt.compliance = CO_PGP6;  break;
2286           case oPGP7:  opt.compliance = CO_PGP7;  break;
2287           case oPGP8:  opt.compliance = CO_PGP8;  break;
2288           case oGnuPG: opt.compliance = CO_GNUPG; break;
2289           case oCompressSigs: opt.compress_sigs = 1; break;
2290           case oRFC2440Text: opt.rfc2440_text=1; break;
2291           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2292           case oSetFilename:
2293             if(utf8_strings)
2294               opt.set_filename = pargs.r.ret_str;
2295             else
2296               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2297             break;
2298           case oForYourEyesOnly: eyes_only = 1; break;
2299           case oNoForYourEyesOnly: eyes_only = 0; break;
2300           case oSetPolicyURL:
2301             add_policy_url(pargs.r.ret_str,0);
2302             add_policy_url(pargs.r.ret_str,1);
2303             break;
2304           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2305           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2306           case oShowPolicyURL:
2307             deprecated_warning(configname,configlineno,"--show-policy-url",
2308                                "--list-options ","show-policy-urls");
2309             deprecated_warning(configname,configlineno,"--show-policy-url",
2310                                "--verify-options ","show-policy-urls");
2311             opt.list_options|=LIST_SHOW_POLICY_URLS;
2312             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2313             break;
2314           case oNoShowPolicyURL:
2315             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2316                                "--list-options ","no-show-policy-urls");
2317             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2318                                "--verify-options ","no-show-policy-urls");
2319             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2320             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2321             break;
2322           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2323           case oUseEmbeddedFilename:
2324             opt.flags.use_embedded_filename=1;
2325             break;
2326           case oNoUseEmbeddedFilename:
2327             opt.flags.use_embedded_filename=0;
2328             break;
2329           case oComment:
2330             if(pargs.r.ret_str[0])
2331               append_to_strlist(&opt.comments,pargs.r.ret_str);
2332             break;
2333           case oDefaultComment:
2334             deprecated_warning(configname,configlineno,
2335                                "--default-comment","--no-comments","");
2336             /* fall through */
2337           case oNoComments:
2338             free_strlist(opt.comments);
2339             opt.comments=NULL;
2340             break;
2341           case oThrowKeyids: opt.throw_keyid = 1; break;
2342           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2343           case oShowPhotos:
2344             deprecated_warning(configname,configlineno,"--show-photos",
2345                                "--list-options ","show-photos");
2346             deprecated_warning(configname,configlineno,"--show-photos",
2347                                "--verify-options ","show-photos");
2348             opt.list_options|=LIST_SHOW_PHOTOS;
2349             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2350             break;
2351           case oNoShowPhotos:
2352             deprecated_warning(configname,configlineno,"--no-show-photos",
2353                                "--list-options ","no-show-photos");
2354             deprecated_warning(configname,configlineno,"--no-show-photos",
2355                                "--verify-options ","no-show-photos");
2356             opt.list_options&=~LIST_SHOW_PHOTOS;
2357             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2358             break;
2359           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2360           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2361           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2362           case oForceV4Certs: opt.force_v4_certs = 1; break;
2363           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2364           case oForceMDC: opt.force_mdc = 1; break;
2365           case oNoForceMDC: opt.force_mdc = 0; break;
2366           case oDisableMDC: opt.disable_mdc = 1; break;
2367           case oNoDisableMDC: opt.disable_mdc = 0; break;
2368           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2369           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2370           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2371           case oS2KCount:
2372             opt.s2k_count=encode_s2k_iterations(pargs.r.ret_int);
2373             break;
2374           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2375           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2376           case oEncryptTo: /* store the recipient in the second list */
2377             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2378             sl->flags = 1;
2379             break;
2380           case oHiddenEncryptTo: /* store the recipient in the second list */
2381             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2382             sl->flags = 1|2;
2383             break;
2384           case oRecipient: /* store the recipient */
2385             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2386             any_explicit_recipient = 1;
2387             break;
2388           case oHiddenRecipient: /* store the recipient with a flag */
2389             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2390             sl->flags = 2;
2391             any_explicit_recipient = 1;
2392             break;
2393           case oTextmodeShort: opt.textmode = 2; break;
2394           case oTextmode: opt.textmode=1;  break;
2395           case oNoTextmode: opt.textmode=0;  break;
2396           case oExpert: opt.expert = 1; break;
2397           case oNoExpert: opt.expert = 0; break;
2398           case oDefSigExpire:
2399             if(*pargs.r.ret_str!='\0')
2400               {
2401                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2402                   log_error(_("`%s' is not a valid signature expiration\n"),
2403                             pargs.r.ret_str);
2404                 else
2405                   opt.def_sig_expire=pargs.r.ret_str;
2406               }
2407             break;
2408           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2409           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2410           case oDefCertExpire:
2411             if(*pargs.r.ret_str!='\0')
2412               {
2413                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2414                   log_error(_("`%s' is not a valid signature expiration\n"),
2415                             pargs.r.ret_str);
2416                 else
2417                   opt.def_cert_expire=pargs.r.ret_str;
2418               }
2419             break;
2420           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2421           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2422           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2423           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2424           case oAskCertLevel: opt.ask_cert_level = 1; break;
2425           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2426           case oLocalUser: /* store the local users */
2427             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2428             break;
2429           case oCompress:
2430             /* this is the -z command line option */
2431             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2432             break;
2433           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2434           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2435           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2436           case oPasswd:
2437             set_passphrase_from_string(pargs.r.ret_str);
2438             break;
2439           case oPasswdFD:
2440             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2441             break;
2442           case oPasswdFile:
2443             pwfd = open_info_file (pargs.r.ret_str, 0);
2444             break;
2445           case oPasswdRepeat: opt.passwd_repeat=pargs.r.ret_int; break;
2446           case oCommandFD:
2447             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2448             break;
2449           case oCommandFile:
2450             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2451             break;
2452           case oCipherAlgo: 
2453             def_cipher_string = xstrdup(pargs.r.ret_str);
2454             break;
2455           case oDigestAlgo:
2456             def_digest_string = xstrdup(pargs.r.ret_str);
2457             break;
2458           case oCompressAlgo:
2459             /* If it is all digits, stick a Z in front of it for
2460                later.  This is for backwards compatibility with
2461                versions that took the compress algorithm number. */
2462             {
2463               char *pt=pargs.r.ret_str;
2464               while(*pt)
2465                 {
2466                   if (!isascii (*pt) || !isdigit (*pt))
2467                     break;
2468
2469                   pt++;
2470                 }
2471
2472               if(*pt=='\0')
2473                 {
2474                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2475                   strcpy(compress_algo_string,"Z");
2476                   strcat(compress_algo_string,pargs.r.ret_str);
2477                 }
2478               else
2479                 compress_algo_string = xstrdup(pargs.r.ret_str);
2480             }
2481             break;
2482           case oCertDigestAlgo: 
2483             cert_digest_string = xstrdup(pargs.r.ret_str);
2484             break;
2485
2486           case oNoSecmemWarn: 
2487             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
2488             break;
2489
2490           case oRequireSecmem: require_secmem=1; break;
2491           case oNoRequireSecmem: require_secmem=0; break;
2492           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2493           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2494           case oDisplayCharset:
2495             if( set_native_charset( pargs.r.ret_str ) )
2496                 log_error(_("`%s' is not a valid character set\n"),
2497                           pargs.r.ret_str);
2498             break;
2499           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2500           case oEscapeFrom: opt.escape_from = 1; break;
2501           case oNoEscapeFrom: opt.escape_from = 0; break;
2502           case oLockOnce: opt.lock_once = 1; break;
2503           case oLockNever:
2504             disable_dotlock ();
2505             break;
2506           case oLockMultiple:
2507 #ifndef __riscos__
2508             opt.lock_once = 0;
2509 #else /* __riscos__ */
2510             riscos_not_implemented("lock-multiple");
2511 #endif /* __riscos__ */
2512             break;
2513           case oKeyServer:
2514             {
2515               struct keyserver_spec *keyserver;
2516               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2517                                             configname,configlineno);
2518               if(!keyserver)
2519                 log_error(_("could not parse keyserver URL\n"));
2520               else
2521                 {
2522                   keyserver->next=opt.keyserver;
2523                   opt.keyserver=keyserver;
2524                 }
2525             }
2526             break;
2527           case oKeyServerOptions:
2528             if(!parse_keyserver_options(pargs.r.ret_str))
2529               {
2530                 if(configname)
2531                   log_error(_("%s:%d: invalid keyserver options\n"),
2532                             configname,configlineno);
2533                 else
2534                   log_error(_("invalid keyserver options\n"));
2535               }
2536             break;
2537           case oImportOptions:
2538             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2539               {
2540                 if(configname)
2541                   log_error(_("%s:%d: invalid import options\n"),
2542                             configname,configlineno);
2543                 else
2544                   log_error(_("invalid import options\n"));
2545               }
2546             break;
2547           case oExportOptions:
2548             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2549               {
2550                 if(configname)
2551                   log_error(_("%s:%d: invalid export options\n"),
2552                             configname,configlineno);
2553                 else
2554                   log_error(_("invalid export options\n"));
2555               }
2556             break;
2557           case oListOptions:
2558             if(!parse_list_options(pargs.r.ret_str))
2559               {
2560                 if(configname)
2561                   log_error(_("%s:%d: invalid list options\n"),
2562                             configname,configlineno);
2563                 else
2564                   log_error(_("invalid list options\n"));
2565               }
2566             break;
2567           case oVerifyOptions:
2568             {
2569               struct parse_options vopts[]=
2570                 {
2571                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2572                    N_("display photo IDs during signature verification")},
2573                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2574                    N_("show policy URLs during signature verification")},
2575                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2576                    N_("show all notations during signature verification")},
2577                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2578                    N_("show IETF standard notations during signature verification")},
2579                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2580                    NULL},
2581                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2582                    N_("show user-supplied notations during signature verification")},
2583                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2584                    N_("show preferred keyserver URLs during signature verification")},
2585                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2586                    N_("show user ID validity during signature verification")},
2587                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2588                    N_("show revoked and expired user IDs in signature verification")},
2589                   {"show-primary-uid-only",VERIFY_SHOW_PRIMARY_UID_ONLY,NULL,
2590                    N_("show only the primary user ID in signature verification")},
2591                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2592                    N_("validate signatures with PKA data")},
2593                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2594                    N_("elevate the trust of signatures with valid PKA data")},
2595                   {NULL,0,NULL,NULL}
2596                 };
2597
2598               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2599                 {
2600                   if(configname)
2601                     log_error(_("%s:%d: invalid verify options\n"),
2602                               configname,configlineno);
2603                   else
2604                     log_error(_("invalid verify options\n"));
2605                 }
2606             }
2607             break;
2608           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2609           case oExecPath:
2610             if(set_exec_path(pargs.r.ret_str))
2611               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2612             else
2613               opt.exec_path_set=1;
2614             break;
2615           case oSetNotation:
2616             add_notation_data( pargs.r.ret_str, 0 );
2617             add_notation_data( pargs.r.ret_str, 1 );
2618             break;
2619           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2620           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2621           case oShowNotation:
2622             deprecated_warning(configname,configlineno,"--show-notation",
2623                                "--list-options ","show-notations");
2624             deprecated_warning(configname,configlineno,"--show-notation",
2625                                "--verify-options ","show-notations");
2626             opt.list_options|=LIST_SHOW_NOTATIONS;
2627             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2628             break;
2629           case oNoShowNotation:
2630             deprecated_warning(configname,configlineno,"--no-show-notation",
2631                                "--list-options ","no-show-notations");
2632             deprecated_warning(configname,configlineno,"--no-show-notation",
2633                                "--verify-options ","no-show-notations");
2634             opt.list_options&=~LIST_SHOW_NOTATIONS;
2635             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2636             break;
2637           case oUtf8Strings: utf8_strings = 1; break;
2638           case oNoUtf8Strings: utf8_strings = 0; break;
2639           case oDisableCipherAlgo:
2640             {
2641               int algo = string_to_cipher_algo (pargs.r.ret_str);
2642               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2643             }
2644             break;
2645           case oDisablePubkeyAlgo:
2646             {
2647               int algo = gcry_pk_map_name (pargs.r.ret_str);
2648               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2649             }
2650             break;
2651           case oNoSigCache: opt.no_sig_cache = 1; break;
2652           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2653           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2654           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2655           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2656           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2657           case oNoLiteral: opt.no_literal = 1; break;
2658           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2659           case oHonorHttpProxy:
2660                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2661                 deprecated_warning(configname,configlineno,
2662                                    "--honor-http-proxy",
2663                                    "--keyserver-options ","http-proxy");
2664                 break;
2665           case oFastListMode: opt.fast_list_mode = 1; break;
2666           case oFixedListMode: opt.fixed_list_mode = 1; break;
2667           case oListOnly: opt.list_only=1; break;
2668           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2669           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2670           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2671           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2672           case oNoRandomSeedFile: use_random_seed = 0; break;
2673           case oAutoKeyRetrieve:
2674           case oNoAutoKeyRetrieve:
2675                 if(pargs.r_opt==oAutoKeyRetrieve)
2676                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2677                 else
2678                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2679
2680                 deprecated_warning(configname,configlineno,
2681                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2682                                "--no-auto-key-retrieve","--keyserver-options ",
2683                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2684                                "no-auto-key-retrieve");
2685                 break;
2686           case oShowSessionKey: opt.show_session_key = 1; break;
2687           case oOverrideSessionKey:
2688                 opt.override_session_key = pargs.r.ret_str;
2689                 break;
2690           case oMergeOnly:
2691                 deprecated_warning(configname,configlineno,"--merge-only",
2692                                    "--import-options ","merge-only");
2693                 opt.import_options|=IMPORT_MERGE_ONLY;
2694             break;
2695           case oAllowSecretKeyImport: /* obsolete */ break;
2696           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2697           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2698           case oEnableSpecialFilenames:
2699             iobuf_enable_special_filenames (1);
2700             break;
2701           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2702           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2703           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2704           case oPreservePermissions: opt.preserve_permissions=1; break;
2705           case oDefaultPreferenceList:
2706             opt.def_preference_list = pargs.r.ret_str;
2707             break;
2708           case oDefaultKeyserverURL:
2709             {
2710               struct keyserver_spec *keyserver;
2711               keyserver=parse_keyserver_uri(pargs.r.ret_str,1,
2712                                             configname,configlineno);
2713               if(!keyserver)
2714                 log_error(_("could not parse keyserver URL\n"));
2715               else
2716                 free_keyserver_spec(keyserver);
2717
2718               opt.def_keyserver_url = pargs.r.ret_str;
2719             }
2720             break;
2721           case oPersonalCipherPreferences:
2722             pers_cipher_list=pargs.r.ret_str;
2723             break;
2724           case oPersonalDigestPreferences:
2725             pers_digest_list=pargs.r.ret_str;
2726             break;
2727           case oPersonalCompressPreferences:
2728             pers_compress_list=pargs.r.ret_str;
2729             break;
2730           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2731           case oDisplay: opt.display = pargs.r.ret_str; break;
2732           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2733           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2734           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2735           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2736           case oGroup: add_group(pargs.r.ret_str); break;
2737           case oUnGroup: rm_group(pargs.r.ret_str); break;
2738           case oNoGroups:
2739             while(opt.grouplist)
2740               {
2741                 struct groupitem *iter=opt.grouplist;
2742                 free_strlist(iter->values);
2743                 opt.grouplist=opt.grouplist->next;
2744                 xfree(iter);
2745               }
2746             break;
2747
2748           case oStrict: 
2749           case oNoStrict: 
2750             /* Not used */
2751             break;
2752
2753           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2754           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2755           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2756           case oMultifile: multifile=1; break;
2757           case oKeyidFormat:
2758             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2759               opt.keyid_format=KF_SHORT;
2760             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2761               opt.keyid_format=KF_LONG;
2762             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2763               opt.keyid_format=KF_0xSHORT;
2764             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2765               opt.keyid_format=KF_0xLONG;
2766             else
2767               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2768             break;
2769
2770           case oExitOnStatusWriteError:
2771             opt.exit_on_status_write_error = 1;
2772             break;
2773
2774           case oLimitCardInsertTries: 
2775             opt.limit_card_insert_tries = pargs.r.ret_int; 
2776             break;
2777
2778           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2779           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2780
2781           case oAutoKeyLocate:
2782             if(!parse_auto_key_locate(pargs.r.ret_str))
2783               {
2784                 if(configname)
2785                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2786                             configname,configlineno);
2787                 else
2788                   log_error(_("invalid auto-key-locate list\n"));
2789               }
2790             break;
2791           case oNoAutoKeyLocate:
2792             release_akl();
2793             break;
2794
2795           case oEnableDSA2: opt.flags.dsa2=1; break;
2796           case oDisableDSA2: opt.flags.dsa2=0; break;
2797
2798           case oAllowMultisigVerification:
2799           case oAllowMultipleMessages:
2800             opt.flags.allow_multiple_messages=1;
2801             break;
2802
2803           case oNoAllowMultipleMessages:
2804             opt.flags.allow_multiple_messages=0;
2805             break;
2806
2807           case oNoop: break;
2808
2809           default : pargs.err = configfp? 1:2; break;
2810           }
2811       }
2812
2813
2814     if( configfp ) {
2815         fclose( configfp );
2816         configfp = NULL;
2817         /* Remember the first config file name. */
2818         if (!save_configname)
2819           save_configname = configname;
2820         else
2821           xfree(configname);
2822         configname = NULL;
2823         goto next_pass;
2824     }
2825     xfree( configname ); configname = NULL;
2826     if( log_get_errorcount(0) )
2827         g10_exit(2);
2828
2829     /* The command --gpgconf-list is pretty simple and may be called
2830        directly after the option parsing. */
2831     if (cmd == aGPGConfList)
2832       {
2833         gpgconf_list (save_configname);
2834         g10_exit (0);
2835       }
2836     xfree (save_configname);
2837
2838     if( nogreeting )
2839         greeting = 0;
2840
2841     if( greeting ) {
2842         fprintf(stderr, "%s %s; %s\n",
2843                         strusage(11), strusage(13), strusage(14) );
2844         fprintf(stderr, "%s\n", strusage(15) );
2845     }
2846 #ifdef IS_DEVELOPMENT_VERSION
2847     if( !opt.batch )
2848       {
2849         const char *s;
2850
2851         if((s=strusage(20)))
2852           log_info("%s\n",s);
2853         if((s=strusage(21)))
2854           log_info("%s\n",s);
2855         if((s=strusage(22)))
2856           log_info("%s\n",s);
2857       }
2858 #endif
2859
2860     /* FIXME: We should use logging to a file only in server mode;
2861        however we have not yet implemetyed that.  Thus we try to get
2862        away with --batch as indication for logging to file
2863        required. */
2864     if (logfile && opt.batch)
2865       {
2866         log_set_file (logfile);
2867         log_set_prefix (NULL, 1|2|4);
2868       }
2869
2870     if (opt.verbose > 2)
2871         log_info ("using character set `%s'\n", get_native_charset ());
2872
2873     if( may_coredump && !opt.quiet )
2874         log_info(_("WARNING: program may create a core file!\n"));
2875
2876     if (eyes_only) {
2877       if (opt.set_filename)
2878           log_info(_("WARNING: %s overrides %s\n"),
2879                    "--for-your-eyes-only","--set-filename");
2880
2881       opt.set_filename="_CONSOLE";
2882     }
2883
2884     if (opt.no_literal) {
2885         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2886         if (opt.textmode)
2887             log_error(_("%s not allowed with %s!\n"),
2888                        "--textmode", "--no-literal" );
2889         if (opt.set_filename)
2890             log_error(_("%s makes no sense with %s!\n"),
2891                         eyes_only?"--for-your-eyes-only":"--set-filename",
2892                         "--no-literal" );
2893     }
2894
2895
2896     if (opt.set_filesize)
2897         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2898     if( opt.batch )
2899         tty_batchmode( 1 );
2900
2901     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
2902
2903     if(require_secmem && !got_secmem)
2904       {
2905         log_info(_("will not run with insecure memory due to %s\n"),
2906                  "--require-secmem");
2907         g10_exit(2);
2908       }
2909
2910     set_debug (debug_level);
2911
2912     /* Do these after the switch(), so they can override settings. */
2913     if(PGP2)
2914       {
2915         int unusable=0;
2916
2917         if(cmd==aSign && !detached_sig)
2918           {
2919             log_info(_("you can only make detached or clear signatures "
2920                        "while in --pgp2 mode\n"));
2921             unusable=1;
2922           }
2923         else if(cmd==aSignEncr || cmd==aSignSym)
2924           {
2925             log_info(_("you can't sign and encrypt at the "
2926                        "same time while in --pgp2 mode\n"));
2927             unusable=1;
2928           }
2929         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2930           {
2931             log_info(_("you must use files (and not a pipe) when "
2932                        "working with --pgp2 enabled.\n"));
2933             unusable=1;
2934           }
2935         else if(cmd==aEncr || cmd==aSym)
2936           {
2937             /* Everything else should work without IDEA (except using
2938                a secret key encrypted with IDEA and setting an IDEA
2939                preference, but those have their own error
2940                messages). */
2941
2942             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
2943               {
2944                 log_info(_("encrypting a message in --pgp2 mode requires "
2945                            "the IDEA cipher\n"));
2946                 idea_cipher_warn(1);
2947                 unusable=1;
2948               }
2949             else if(cmd==aSym)
2950               {
2951                 /* This only sets IDEA for symmetric encryption
2952                    since it is set via select_algo_from_prefs for
2953                    pk encryption. */
2954                 xfree(def_cipher_string);
2955                 def_cipher_string = xstrdup("idea");
2956               }
2957
2958             /* PGP2 can't handle the output from the textmode
2959                filter, so we disable it for anything that could
2960                create a literal packet (only encryption and
2961                symmetric encryption, since we disable signing
2962                above). */
2963             if(!unusable)
2964               opt.textmode=0;
2965           }
2966
2967         if(unusable)
2968           compliance_failure();
2969         else
2970           {
2971             opt.force_v4_certs = 0;
2972             opt.escape_from = 1;
2973             opt.force_v3_sigs = 1;
2974             opt.pgp2_workarounds = 1;
2975             opt.ask_sig_expire = 0;
2976             opt.ask_cert_expire = 0;
2977             xfree(def_digest_string);
2978             def_digest_string = xstrdup("md5");
2979             xfree(s2k_digest_string);
2980             s2k_digest_string = xstrdup("md5");
2981             opt.compress_algo = COMPRESS_ALGO_ZIP;
2982           }
2983       }
2984     else if(PGP6)
2985       {
2986         opt.escape_from=1;
2987         opt.force_v3_sigs=1;
2988         opt.ask_sig_expire=0;
2989       }
2990     else if(PGP7)
2991       {
2992         opt.escape_from=1;
2993         opt.force_v3_sigs=1;
2994         opt.ask_sig_expire=0;
2995       }
2996     else if(PGP8)
2997       {
2998         opt.escape_from=1;
2999       }
3000
3001
3002     if( def_cipher_string ) {
3003         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
3004         if(opt.def_cipher_algo==0 &&
3005            (ascii_strcasecmp(def_cipher_string,"idea")==0
3006             || ascii_strcasecmp(def_cipher_string,"s1")==0))
3007           idea_cipher_warn(1);
3008         xfree(def_cipher_string); def_cipher_string = NULL;
3009         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
3010             log_error(_("selected cipher algorithm is invalid\n"));
3011     }
3012     if( def_digest_string ) {
3013         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
3014         xfree(def_digest_string); def_digest_string = NULL;
3015         if ( openpgp_md_test_algo (opt.def_digest_algo) )
3016             log_error(_("selected digest algorithm is invalid\n"));
3017     }
3018     if( compress_algo_string ) {
3019         opt.compress_algo = string_to_compress_algo(compress_algo_string);
3020         xfree(compress_algo_string); compress_algo_string = NULL;
3021         if( check_compress_algo(opt.compress_algo) )
3022           log_error(_("selected compression algorithm is invalid\n"));
3023     }
3024     if( cert_digest_string ) {
3025         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
3026         xfree(cert_digest_string); cert_digest_string = NULL;
3027         if (openpgp_md_test_algo(opt.cert_digest_algo))
3028           log_error(_("selected certification digest algorithm is invalid\n"));
3029     }
3030     if( s2k_cipher_string ) {
3031         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
3032         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
3033         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
3034           log_error(_("selected cipher algorithm is invalid\n"));
3035     }
3036     if( s2k_digest_string ) {
3037         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
3038         xfree(s2k_digest_string); s2k_digest_string = NULL;
3039         if (openpgp_md_test_algo(opt.s2k_digest_algo))
3040           log_error(_("selected digest algorithm is invalid\n"));
3041     }
3042     if( opt.completes_needed < 1 )
3043       log_error(_("completes-needed must be greater than 0\n"));
3044     if( opt.marginals_needed < 2 )
3045       log_error(_("marginals-needed must be greater than 1\n"));
3046     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
3047       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
3048     if(opt.def_cert_level<0 || opt.def_cert_level>3)
3049       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
3050     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
3051       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
3052     switch( opt.s2k_mode ) {
3053       case 0:
3054         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
3055         break;
3056       case 1: case 3: break;
3057       default:
3058         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
3059     }
3060
3061     /* This isn't actually needed, but does serve to error out if the
3062        string is invalid. */
3063     if(opt.def_preference_list &&
3064         keygen_set_std_prefs(opt.def_preference_list,0))
3065       log_error(_("invalid default preferences\n"));
3066
3067     /* We provide defaults for the personal digest list.  This is
3068        SHA-1. */
3069     if(!pers_digest_list)
3070       pers_digest_list="h2";
3071
3072     if(pers_cipher_list &&
3073        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
3074       log_error(_("invalid personal cipher preferences\n"));
3075
3076     if(pers_digest_list &&
3077        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
3078       log_error(_("invalid personal digest preferences\n"));
3079
3080     if(pers_compress_list &&
3081        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
3082       log_error(_("invalid personal compress preferences\n"));
3083
3084     /* We don't support all possible commands with multifile yet */
3085     if(multifile)
3086       {
3087         char *cmdname;
3088
3089         switch(cmd)
3090           {
3091           case aSign:
3092             cmdname="--sign";
3093             break;
3094           case aClearsign:
3095             cmdname="--clearsign";
3096             break;
3097           case aDetachedSign:
3098             cmdname="--detach-sign";
3099             break;
3100           case aSym:
3101             cmdname="--symmetric";
3102             break;
3103           case aEncrSym:
3104             cmdname="--symmetric --encrypt";
3105             break;
3106           case aStore:
3107             cmdname="--store";
3108             break;
3109           default:
3110             cmdname=NULL;
3111             break;
3112           }
3113
3114         if(cmdname)
3115           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
3116       }
3117
3118     if( log_get_errorcount(0) )
3119         g10_exit(2);
3120
3121     if(opt.compress_level==0)
3122       opt.compress_algo=COMPRESS_ALGO_NONE;
3123
3124     /* Check our chosen algorithms against the list of legal
3125        algorithms. */
3126
3127     if(!GNUPG)
3128       {
3129         const char *badalg=NULL;
3130         preftype_t badtype=PREFTYPE_NONE;
3131
3132         if(opt.def_cipher_algo
3133            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
3134           {
3135             badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
3136             badtype = PREFTYPE_SYM;
3137           }
3138         else if(opt.def_digest_algo
3139                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
3140           {
3141             badalg = gcry_md_algo_name (opt.def_digest_algo);
3142             badtype = PREFTYPE_HASH;
3143           }
3144         else if(opt.cert_digest_algo
3145                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3146           {
3147             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3148             badtype = PREFTYPE_HASH;
3149           }
3150         else if(opt.compress_algo!=-1
3151                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3152           {
3153             badalg = compress_algo_to_string(opt.compress_algo);
3154             badtype = PREFTYPE_ZIP;
3155           }
3156
3157         if(badalg)
3158           {
3159             switch(badtype)
3160               {
3161               case PREFTYPE_SYM:
3162                 log_info(_("you may not use cipher algorithm `%s'"
3163                            " while in %s mode\n"),
3164                          badalg,compliance_option_string());
3165                 break;
3166               case PREFTYPE_HASH:
3167                 log_info(_("you may not use digest algorithm `%s'"
3168                            " while in %s mode\n"),
3169                          badalg,compliance_option_string());
3170                 break;
3171               case PREFTYPE_ZIP:
3172                 log_info(_("you may not use compression algorithm `%s'"
3173                            " while in %s mode\n"),
3174                          badalg,compliance_option_string());
3175                 break;
3176               default:
3177                 BUG();
3178               }
3179
3180             compliance_failure();
3181           }
3182       }
3183
3184     /* Set the random seed file. */
3185     if( use_random_seed ) {
3186         char *p = make_filename(opt.homedir, "random_seed", NULL );
3187         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3188         if (!access (p, F_OK))
3189           register_secured_file (p);
3190         xfree(p);
3191     }
3192
3193     if( !cmd && opt.fingerprint && !with_fpr ) {
3194         set_cmd( &cmd, aListKeys);
3195     }
3196
3197     /* kludge to let -sat generate a clear text signature */
3198     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3199       {
3200         log_info ("compatibility note:\n");
3201         log_info ("\"-sat\" won't generate clear signed messages in "
3202                   "future versions\n");
3203         log_info ("Use \"--clearsign\" instead of \"-sat\"\n");
3204         cmd = aClearsign;
3205       }
3206
3207     if( opt.verbose > 1 )
3208         set_packet_list_mode(1);
3209
3210     /* Add the keyrings, but not for some special commands.  Also
3211        avoid adding the secret keyring for a couple of commands to
3212        avoid unneeded access in case the secrings are stored on a
3213        floppy.
3214        
3215        We always need to add the keyrings if we are running under
3216        SELinux, this is so that the rings are added to the list of
3217        secured files. */
3218     if( ALWAYS_ADD_KEYRINGS 
3219         || (cmd != aDeArmor && cmd != aEnArmor && cmd != aGPGConfTest) ) 
3220       {
3221         if (ALWAYS_ADD_KEYRINGS
3222             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3223                 && cmd != aVerify && cmd != aSym))
3224           {
3225             if (!sec_nrings || default_keyring) /* add default secret rings */
3226               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3227             for (sl = sec_nrings; sl; sl = sl->next)
3228               keydb_add_resource ( sl->d, 0, 1 );
3229           }
3230         if( !nrings || default_keyring )  /* add default ring */
3231             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3232         for(sl = nrings; sl; sl = sl->next )
3233             keydb_add_resource ( sl->d, sl->flags, 0 );
3234       }
3235     FREE_STRLIST(nrings);
3236     FREE_STRLIST(sec_nrings);
3237
3238     if (cmd == aGPGConfTest)
3239       g10_exit(0);
3240
3241
3242     if( pwfd != -1 )  /* Read the passphrase now. */
3243         read_passphrase_from_fd( pwfd );
3244
3245     fname = argc? *argv : NULL;
3246
3247     if(fname && utf8_strings)
3248       opt.flags.utf8_filename=1;
3249
3250     switch( cmd ) {
3251       case aPrimegen:
3252       case aPrintMD:
3253       case aPrintMDs:
3254       case aGenRandom:
3255       case aDeArmor:
3256       case aEnArmor:
3257       case aFixTrustDB:
3258         break;
3259       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3260       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3261       default: rc = setup_trustdb(1, trustdb_name ); break;
3262     }
3263     if( rc )
3264         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3265
3266
3267     switch (cmd)
3268       {
3269       case aStore: 
3270       case aSym:  
3271       case aSign: 
3272       case aSignSym: 
3273       case aClearsign: 
3274         if (!opt.quiet && any_explicit_recipient)
3275           log_info (_("WARNING: recipients (-r) given "
3276                       "without using public key encryption\n"));
3277         break;
3278       default:
3279         break;
3280       }
3281
3282     switch( cmd )
3283       {
3284       case aServer:
3285         {
3286           ctrl_t ctrl = xtrycalloc (1, sizeof *ctrl);
3287           gpg_init_default_ctrl (ctrl);
3288           gpg_server (ctrl);
3289           gpg_deinit_default_ctrl (ctrl);
3290           xfree (ctrl);
3291         }
3292         break;
3293
3294       case aStore: /* only store the file */
3295         if( argc > 1 )
3296             wrong_args(_("--store [filename]"));
3297         if( (rc = encode_store(fname)) )
3298             log_error ("storing `%s' failed: %s\n",
3299                        print_fname_stdin(fname),g10_errstr(rc) );
3300         break;
3301       case aSym: /* encrypt the given file only with the symmetric cipher */
3302         if( argc > 1 )
3303             wrong_args(_("--symmetric [filename]"));
3304         if( (rc = encode_symmetric(fname)) )
3305             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3306                         print_fname_stdin(fname),g10_errstr(rc) );
3307         break;
3308
3309       case aEncr: /* encrypt the given file */
3310         if(multifile)
3311           encode_crypt_files(argc, argv, remusr);
3312         else
3313           {
3314             if( argc > 1 )
3315               wrong_args(_("--encrypt [filename]"));
3316             if( (rc = encode_crypt(fname,remusr,0)) )
3317               log_error("%s: encryption failed: %s\n",
3318                         print_fname_stdin(fname), g10_errstr(rc) );
3319           }
3320         break;
3321
3322       case aEncrSym:
3323         /* This works with PGP 8 in the sense that it acts just like a
3324            symmetric message.  It doesn't work at all with 2 or 6.  It
3325            might work with 7, but alas, I don't have a copy to test
3326            with right now. */
3327         if( argc > 1 )
3328           wrong_args(_("--symmetric --encrypt [filename]"));
3329         else if(opt.s2k_mode==0)
3330           log_error(_("you cannot use --symmetric --encrypt"
3331                       " with --s2k-mode 0\n"));
3332         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3333           log_error(_("you cannot use --symmetric --encrypt"
3334                       " while in %s mode\n"),compliance_option_string());
3335         else
3336           {
3337             if( (rc = encode_crypt(fname,remusr,1)) )
3338               log_error("%s: encryption failed: %s\n",
3339                         print_fname_stdin(fname), g10_errstr(rc) );
3340           }
3341         break;
3342
3343       case aSign: /* sign the given file */
3344         sl = NULL;
3345         if( detached_sig ) { /* sign all files */
3346             for( ; argc; argc--, argv++ )
3347                 add_to_strlist( &sl, *argv );
3348         }
3349         else {
3350             if( argc > 1 )
3351                 wrong_args(_("--sign [filename]"));
3352             if( argc ) {
3353                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3354                 strcpy(sl->d, fname);
3355             }
3356         }
3357         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3358             log_error("signing failed: %s\n", g10_errstr(rc) );
3359         free_strlist(sl);
3360         break;
3361
3362       case aSignEncr: /* sign and encrypt the given file */
3363         if( argc > 1 )
3364             wrong_args(_("--sign --encrypt [filename]"));
3365         if( argc ) {
3366             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3367             strcpy(sl->d, fname);
3368         }
3369         else
3370             sl = NULL;
3371         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3372             log_error("%s: sign+encrypt failed: %s\n",
3373                       print_fname_stdin(fname), g10_errstr(rc) );
3374         free_strlist(sl);
3375         break;
3376
3377       case aSignEncrSym: /* sign and encrypt the given file */
3378         if( argc > 1 )
3379             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3380         else if(opt.s2k_mode==0)
3381           log_error(_("you cannot use --symmetric --sign --encrypt"
3382                       " with --s2k-mode 0\n"));
3383         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3384           log_error(_("you cannot use --symmetric --sign --encrypt"
3385                       " while in %s mode\n"),compliance_option_string());
3386         else
3387           {
3388             if( argc )
3389               {
3390                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3391                 strcpy(sl->d, fname);
3392               }
3393             else
3394               sl = NULL;
3395             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3396               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3397                         print_fname_stdin(fname), g10_errstr(rc) );
3398             free_strlist(sl);
3399           }
3400         break;
3401
3402       case aSignSym: /* sign and conventionally encrypt the given file */
3403         if (argc > 1)
3404             wrong_args(_("--sign --symmetric [filename]"));
3405         rc = sign_symencrypt_file (fname, locusr);
3406         if (rc)
3407             log_error("%s: sign+symmetric failed: %s\n",
3408                       print_fname_stdin(fname), g10_errstr(rc) );
3409         break;
3410
3411       case aClearsign: /* make a clearsig */
3412         if( argc > 1 )
3413             wrong_args(_("--clearsign [filename]"));
3414         if( (rc = clearsign_file(fname, locusr, NULL)) )
3415             log_error("%s: clearsign failed: %s\n",
3416                       print_fname_stdin(fname), g10_errstr(rc) );
3417         break;
3418
3419       case aVerify:
3420         if(multifile)
3421           {
3422             if( (rc = verify_files( argc, argv ) ))
3423               log_error("verify files failed: %s\n", g10_errstr(rc) );
3424           }
3425         else
3426           {
3427             if( (rc = verify_signatures( argc, argv ) ))
3428               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3429           }
3430         break;
3431
3432       case aDecrypt:
3433         if(multifile)
3434           decrypt_messages(argc, argv);
3435         else
3436           {
3437             if( argc > 1 )
3438               wrong_args(_("--decrypt [filename]"));
3439             if( (rc = decrypt_message( fname ) ))
3440               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3441           }
3442         break;
3443             
3444       case aSignKey:
3445         if( argc != 1 )
3446           wrong_args(_("--sign-key user-id"));
3447         /* fall through */
3448       case aLSignKey:
3449         if( argc != 1 )
3450           wrong_args(_("--lsign-key user-id"));
3451         /* fall through */
3452
3453         sl=NULL;
3454
3455         if(cmd==aSignKey)
3456           append_to_strlist(&sl,"sign");
3457         else if(cmd==aLSignKey)
3458           append_to_strlist(&sl,"lsign");
3459         else
3460           BUG();
3461
3462         append_to_strlist( &sl, "save" );
3463         username = make_username( fname );
3464         keyedit_menu(fname, locusr, sl, 0, 0 );
3465         xfree(username);
3466         free_strlist(sl);
3467         break;
3468
3469       case aEditKey: /* Edit a key signature */
3470         if( !argc )
3471             wrong_args(_("--edit-key user-id [commands]"));
3472         username = make_username( fname );
3473         if( argc > 1 ) {
3474             sl = NULL;
3475             for( argc--, argv++ ; argc; argc--, argv++ )
3476                 append_to_strlist( &sl, *argv );
3477             keyedit_menu( username, locusr, sl, 0, 1 );
3478             free_strlist(sl);
3479         }
3480         else
3481             keyedit_menu(username, locusr, NULL, 0, 1 );
3482         xfree(username);
3483         break;
3484
3485       case aDeleteKeys:
3486       case aDeleteSecretKeys:
3487       case aDeleteSecretAndPublicKeys:
3488         sl = NULL;
3489         /* I'm adding these in reverse order as add_to_strlist2
3490            reverses them again, and it's easier to understand in the
3491            proper order :) */
3492         for( ; argc; argc-- )
3493           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3494         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3495         free_strlist(sl);
3496         break;
3497
3498       case aCheckKeys:
3499         opt.check_sigs = 1;
3500       case aListSigs:
3501         opt.list_sigs = 1;
3502       case aListKeys:
3503         sl = NULL;
3504         for( ; argc; argc--, argv++ )
3505             add_to_strlist2( &sl, *argv, utf8_strings );
3506         public_key_list( sl );
3507         free_strlist(sl);
3508         break;
3509       case aListSecretKeys:
3510         sl = NULL;
3511         for( ; argc; argc--, argv++ )
3512             add_to_strlist2( &sl, *argv, utf8_strings );
3513         secret_key_list( sl );
3514         free_strlist(sl);
3515         break;
3516
3517       case aKeygen: /* generate a key */
3518         if( opt.batch ) {
3519             if( argc > 1 )
3520                 wrong_args("--gen-key [parameterfile]");
3521             generate_keypair( argc? *argv : NULL, NULL, NULL );
3522         }
3523         else {
3524             if( argc )
3525                 wrong_args("--gen-key");
3526             generate_keypair(NULL, NULL, NULL);
3527         }
3528         break;
3529
3530       case aFastImport:
3531         opt.import_options |= IMPORT_FAST;
3532       case aImport:
3533         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3534         break;
3535
3536         /* TODO: There are a number of command that use this same
3537            "make strlist, call function, report error, free strlist"
3538            pattern.  Join them together here and avoid all that
3539            duplicated code. */
3540
3541       case aExport:
3542       case aSendKeys:
3543       case aRecvKeys:
3544         sl = NULL;
3545         for( ; argc; argc--, argv++ )
3546             append_to_strlist2( &sl, *argv, utf8_strings );
3547         if( cmd == aSendKeys )
3548             rc=keyserver_export( sl );
3549         else if( cmd == aRecvKeys )
3550             rc=keyserver_import( sl );
3551         else
3552             rc=export_pubkeys( sl, opt.export_options );
3553         if(rc)
3554           {
3555             if(cmd==aSendKeys)
3556               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3557             else if(cmd==aRecvKeys)
3558               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3559             else
3560               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3561           }
3562         free_strlist(sl);
3563         break;
3564
3565      case aSearchKeys:
3566         sl = NULL;
3567         for( ; argc; argc--, argv++ )
3568           append_to_strlist2( &sl, *argv, utf8_strings );
3569         rc=keyserver_search( sl );
3570         if(rc)
3571           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3572         free_strlist(sl);
3573         break;
3574
3575       case aRefreshKeys:
3576         sl = NULL;
3577         for( ; argc; argc--, argv++ )
3578             append_to_strlist2( &sl, *argv, utf8_strings );
3579         rc=keyserver_refresh(sl);
3580         if(rc)
3581           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3582         free_strlist(sl);
3583         break;
3584
3585       case aFetchKeys:
3586         sl = NULL;
3587         for( ; argc; argc--, argv++ )
3588             append_to_strlist2( &sl, *argv, utf8_strings );
3589         rc=keyserver_fetch(sl);
3590         if(rc)
3591           log_error("key fetch failed: %s\n",g10_errstr(rc));
3592         free_strlist(sl);
3593         break;
3594
3595       case aExportSecret:
3596         sl = NULL;
3597         for( ; argc; argc--, argv++ )
3598             add_to_strlist2( &sl, *argv, utf8_strings );
3599         export_seckeys( sl );
3600         free_strlist(sl);
3601         break;
3602
3603       case aExportSecretSub:
3604         sl = NULL;
3605         for( ; argc; argc--, argv++ )
3606             add_to_strlist2( &sl, *argv, utf8_strings );
3607         export_secsubkeys( sl );
3608         free_strlist(sl);
3609         break;
3610
3611       case aGenRevoke:
3612         if( argc != 1 )
3613             wrong_args("--gen-revoke user-id");
3614         username =  make_username(*argv);
3615         gen_revoke( username );
3616         xfree( username );
3617         break;
3618
3619       case aDesigRevoke:
3620         if( argc != 1 )
3621             wrong_args("--desig-revoke user-id");
3622         username =  make_username(*argv);
3623         gen_desig_revoke( username, locusr );
3624         xfree( username );
3625         break;
3626
3627       case aDeArmor:
3628         if( argc > 1 )
3629             wrong_args("--dearmor [file]");
3630         rc = dearmor_file( argc? *argv: NULL );
3631         if( rc )
3632             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3633         break;
3634
3635       case aEnArmor:
3636         if( argc > 1 )
3637             wrong_args("--enarmor [file]");
3638         rc = enarmor_file( argc? *argv: NULL );
3639         if( rc )
3640             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3641         break;
3642
3643
3644       case aPrimegen:
3645 #if 0 /*FIXME*/
3646         {   int mode = argc < 2 ? 0 : atoi(*argv);
3647
3648             if( mode == 1 && argc == 2 ) {
3649                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3650             }
3651             else if( mode == 2 && argc == 3 ) {
3652                 mpi_print( stdout, generate_elg_prime(
3653                                              0, atoi(argv[1]),
3654                                              atoi(argv[2]), NULL,NULL ), 1);
3655             }
3656             else if( mode == 3 && argc == 3 ) {
3657                 MPI *factors;
3658                 mpi_print( stdout, generate_elg_prime(
3659                                              1, atoi(argv[1]),
3660                                              atoi(argv[2]), NULL,&factors ), 1);
3661                 putchar('\n');
3662                 mpi_print( stdout, factors[0], 1 ); /* print q */
3663             }
3664             else if( mode == 4 && argc == 3 ) {
3665                 MPI g = mpi_alloc(1);
3666                 mpi_print( stdout, generate_elg_prime(
3667                                                  0, atoi(argv[1]),
3668                                                  atoi(argv[2]), g, NULL ), 1);
3669                 putchar('\n');
3670                 mpi_print( stdout, g, 1 );
3671                 mpi_free(g);
3672             }
3673             else
3674                 wrong_args("--gen-prime mode bits [qbits] ");
3675             putchar('\n');
3676         }
3677 #endif
3678         wrong_args("--gen-prime not yet supported ");
3679         break;
3680
3681       case aGenRandom:
3682         {
3683             int level = argc ? atoi(*argv):0;
3684             int count = argc > 1 ? atoi(argv[1]): 0;
3685             int endless = !count;
3686
3687             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3688                 wrong_args("--gen-random 0|1|2 [count]");
3689
3690             while( endless || count ) {
3691                 byte *p;
3692                 /* Wee need a multiple of 3, so that in case of
3693                    armored output we get a correct string.  No
3694                    linefolding is done, as it is best to levae this to
3695                    other tools */
3696                 size_t n = !endless && count < 99? count : 99;
3697
3698                 p = gcry_random_bytes (n, level);
3699 #ifdef HAVE_DOSISH_SYSTEM
3700                 setmode ( fileno(stdout), O_BINARY );
3701 #endif
3702                 if (opt.armor) {
3703                     char *tmp = make_radix64_string (p, n);
3704                     fputs (tmp, stdout);
3705                     xfree (tmp);
3706                     if (n%3 == 1)
3707                       putchar ('=');
3708                     if (n%3)
3709                       putchar ('=');
3710                 } else {
3711                     fwrite( p, n, 1, stdout );
3712                 }
3713                 xfree(p);
3714                 if( !endless )
3715                     count -= n;
3716             }
3717             if (opt.armor)
3718                 putchar ('\n');
3719         }
3720         break;
3721
3722       case aPrintMD:
3723         if( argc < 1)
3724             wrong_args("--print-md algo [files]");
3725         {
3726             int all_algos = (**argv=='*' && !(*argv)[1]);
3727             int algo = all_algos? 0 : gcry_md_map_name (*argv);
3728
3729             if( !algo && !all_algos )
3730                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3731             else {
3732                 argc--; argv++;
3733                 if( !argc )
3734                     print_mds(NULL, algo);
3735                 else {
3736                     for(; argc; argc--, argv++ )
3737                         print_mds(*argv, algo);
3738                 }
3739             }
3740         }
3741         break;
3742
3743       case aPrintMDs: /* old option */
3744         if( !argc )
3745             print_mds(NULL,0);
3746         else {
3747             for(; argc; argc--, argv++ )
3748                 print_mds(*argv,0);
3749         }
3750         break;
3751
3752       case aListTrustDB:
3753         if( !argc )
3754             list_trustdb(NULL);
3755         else {
3756             for( ; argc; argc--, argv++ )
3757                 list_trustdb( *argv );
3758         }
3759         break;
3760
3761       case aUpdateTrustDB:
3762         if( argc )
3763             wrong_args("--update-trustdb");
3764         update_trustdb();
3765         break;
3766
3767       case aCheckTrustDB:
3768         /* Old versions allowed for arguments - ignore them */
3769         check_trustdb();
3770         break;
3771
3772       case aFixTrustDB:
3773         log_error("this command is not yet implemented.\n");
3774         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3775         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3776         break;
3777
3778       case aListTrustPath:
3779         if( !argc )
3780             wrong_args("--list-trust-path <user-ids>");
3781         for( ; argc; argc--, argv++ ) {
3782             username = make_username( *argv );
3783             list_trust_path( username );
3784             xfree(username);
3785         }
3786         break;
3787
3788       case aExportOwnerTrust:
3789         if( argc )
3790             wrong_args("--export-ownertrust");
3791         export_ownertrust();
3792         break;
3793
3794       case aImportOwnerTrust:
3795         if( argc > 1 )
3796             wrong_args("--import-ownertrust [file]");
3797         import_ownertrust( argc? *argv:NULL );
3798         break;
3799       
3800       case aRebuildKeydbCaches:
3801         if (argc)
3802             wrong_args ("--rebuild-keydb-caches");
3803         keydb_rebuild_caches (1);
3804         break;
3805
3806 #ifdef ENABLE_CARD_SUPPORT
3807       case aCardStatus:
3808         if (argc)
3809             wrong_args ("--card-status");
3810         card_status (stdout, NULL, 0);
3811         break;
3812
3813       case aCardEdit:
3814         if (argc) {
3815             sl = NULL;
3816             for (argc--, argv++ ; argc; argc--, argv++)
3817                 append_to_strlist (&sl, *argv);
3818             card_edit (sl);
3819             free_strlist (sl);
3820         }
3821         else
3822             card_edit (NULL);
3823         break;
3824
3825       case aChangePIN:
3826         if (!argc)
3827             change_pin (0,1);
3828         else if (argc == 1)
3829             change_pin (atoi (*argv),1);
3830         else
3831         wrong_args ("--change-pin [no]");
3832         break;
3833 #endif /* ENABLE_CARD_SUPPORT*/
3834
3835       case aListConfig:
3836         {
3837           char *str=collapse_args(argc,argv);
3838           list_config(str);
3839           xfree(str);
3840         }
3841         break;
3842
3843       case aListPackets:
3844         opt.list_packets=2;
3845       default:
3846         if( argc > 1 )
3847             wrong_args(_("[filename]"));
3848         /* Issue some output for the unix newbie */
3849         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3850                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3851             log_info(_("Go ahead and type your message ...\n"));
3852
3853         a = iobuf_open(fname);
3854         if (a && is_secured_file (iobuf_get_fd (a)))
3855           {
3856             iobuf_close (a);
3857             a = NULL;
3858             errno = EPERM;
3859           }
3860         if( !a )
3861             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3862         else {
3863
3864             if( !opt.no_armor ) {
3865                 if( use_armor_filter( a ) ) {
3866                     afx = new_armor_context ();
3867                     push_armor_filter (afx, a);
3868                 }
3869             }
3870             if( cmd == aListPackets ) {
3871                 set_packet_list_mode(1);
3872                 opt.list_packets=1;
3873             }
3874             rc = proc_packets(NULL, a );
3875             if( rc )
3876                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3877             iobuf_close(a);
3878         }
3879         break;
3880       }
3881
3882     /* cleanup */
3883     release_armor_context (afx);
3884     FREE_STRLIST(remusr);
3885     FREE_STRLIST(locusr);
3886     g10_exit(0);
3887     return 8; /*NEVER REACHED*/
3888 }
3889
3890
3891 /* Note: This function is used by signal handlers!. */
3892 static void
3893 emergency_cleanup (void)
3894 {
3895   gcry_control (GCRYCTL_TERM_SECMEM );
3896 }
3897
3898
3899 void
3900 g10_exit( int rc )
3901 {
3902   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
3903   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
3904     {
3905       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
3906       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
3907     }
3908   if (opt.debug)
3909     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
3910
3911   emergency_cleanup ();
3912   
3913   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
3914   exit (rc);
3915 }
3916
3917
3918 /* Pretty-print hex hashes.  This assumes at least an 80-character
3919    display, but there are a few other similar assumptions in the
3920    display code. */
3921 static void
3922 print_hex( gcry_md_hd_t md, int algo, const char *fname )
3923 {
3924   int i,n,count,indent=0;
3925   const byte *p;
3926
3927   if(fname)
3928     indent=printf("%s: ",fname);
3929
3930   if(indent>40)
3931     {
3932       printf("\n");
3933       indent=0;
3934     }
3935
3936   if(algo==DIGEST_ALGO_RMD160)
3937     indent+=printf("RMD160 = ");
3938   else if(algo>0)
3939     indent+=printf("%6s = ", gcry_md_algo_name (algo));
3940   else
3941     algo=abs(algo);
3942
3943   count=indent;
3944
3945   p = gcry_md_read (md, algo);
3946   n = gcry_md_get_algo_dlen (algo);
3947
3948   count += printf ("%02X",*p++);
3949
3950   for(i=1;i<n;i++,p++)
3951     {
3952       if(n==16)
3953         {
3954           if(count+2>79)
3955             {
3956               printf("\n%*s",indent," ");
3957               count=indent;
3958             }
3959           else
3960             count+=printf(" ");
3961
3962           if(!(i%8))
3963             count+=printf(" ");
3964         }
3965       else if (n==20)
3966         {
3967           if(!(i%2))
3968             {
3969               if(count+4>79)
3970                 {
3971                   printf("\n%*s",indent," ");
3972                   count=indent;
3973                 }
3974               else
3975                 count+=printf(" ");
3976             }
3977
3978           if(!(i%10))
3979             count+=printf(" ");
3980         }
3981       else
3982         {
3983           if(!(i%4))
3984             {
3985               if(count+8>79)
3986                 {
3987                   printf("\n%*s",indent," ");
3988                   count=indent;
3989                 }
3990               else
3991                 count+=printf(" ");
3992             }
3993         }
3994
3995       count+=printf("%02X",*p);
3996     }
3997
3998   printf("\n");
3999 }
4000
4001 static void
4002 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
4003 {
4004     int i, n;
4005     const byte *p;
4006     
4007     if ( fname ) {
4008         for (p = fname; *p; p++ ) {
4009             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
4010                 printf("%%%02X", *p );
4011             else 
4012                 putchar( *p );
4013         }
4014     }
4015     putchar(':');
4016     printf("%d:", algo );
4017     p = gcry_md_read (md, algo);
4018     n = gcry_md_get_algo_dlen (algo);
4019     for(i=0; i < n ; i++, p++ ) 
4020         printf("%02X", *p );
4021     putchar(':');
4022     putchar('\n');
4023 }
4024
4025 static void
4026 print_mds( const char *fname, int algo )
4027 {
4028     FILE *fp;
4029     char buf[1024];
4030     size_t n;
4031     gcry_md_hd_t md;
4032
4033     if( !fname ) {
4034         fp = stdin;
4035 #ifdef HAVE_DOSISH_SYSTEM
4036         setmode ( fileno(fp) , O_BINARY );
4037 #endif
4038     }
4039     else {
4040         fp = fopen( fname, "rb" );
4041         if (fp && is_secured_file (fileno (fp)))
4042           {
4043             fclose (fp);
4044             fp = NULL;
4045             errno = EPERM;
4046           }
4047     }
4048     if( !fp ) {
4049         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
4050         return;
4051     }
4052
4053     gcry_md_open (&md, 0, 0);
4054     if( algo )
4055         gcry_md_enable (md, algo);
4056     else {
4057         gcry_md_enable (md, GCRY_MD_MD5);
4058         gcry_md_enable (md, GCRY_MD_SHA1);
4059         gcry_md_enable (md, GCRY_MD_RMD160);
4060         if (!openpgp_md_test_algo (DIGEST_ALGO_SHA224))
4061           gcry_md_enable (md, DIGEST_ALGO_SHA224);
4062         if (!openpgp_md_test_algo (GCRY_MD_SHA256))
4063           gcry_md_enable (md, GCRY_MD_SHA256);
4064         if (!openpgp_md_test_algo (GCRY_MD_SHA384))
4065           gcry_md_enable (md, GCRY_MD_SHA384);
4066         if (!openpgp_md_test_algo (GCRY_MD_SHA512))
4067           gcry_md_enable (md, GCRY_MD_SHA512);
4068     }
4069
4070     while( (n=fread( buf, 1, DIM(buf), fp )) )
4071         gcry_md_write (md, buf, n);
4072     if( ferror(fp) )
4073         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
4074     else {
4075         gcry_md_final (md);
4076         if ( opt.with_colons ) {
4077             if ( algo ) 
4078                 print_hashline( md, algo, fname );
4079             else {
4080                 print_hashline( md, GCRY_MD_MD5, fname );
4081                 print_hashline( md, GCRY_MD_SHA1, fname );
4082                 print_hashline( md, GCRY_MD_RMD160, fname );
4083                 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
4084                     print_hashline (md, DIGEST_ALGO_SHA224, fname);
4085                 if (!gcry_md_test_algo (GCRY_MD_SHA256))
4086                     print_hashline( md, GCRY_MD_SHA256, fname );
4087                 if (!gcry_md_test_algo (GCRY_MD_SHA384))
4088                     print_hashline ( md, GCRY_MD_SHA384, fname );
4089                 if (!gcry_md_test_algo (GCRY_MD_SHA512))
4090                     print_hashline ( md, GCRY_MD_SHA512, fname );
4091             }
4092         }
4093         else {
4094             if( algo )
4095                print_hex(md,-algo,fname);
4096             else {
4097                 print_hex( md, GCRY_MD_MD5, fname );
4098                 print_hex( md, GCRY_MD_SHA1, fname );
4099                 print_hex( md, GCRY_MD_RMD160, fname );
4100                 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224))
4101                     print_hex (md, DIGEST_ALGO_SHA224, fname);
4102                 if (!gcry_md_test_algo (GCRY_MD_SHA256))
4103                     print_hex( md, GCRY_MD_SHA256, fname );
4104                 if (!gcry_md_test_algo (GCRY_MD_SHA384))
4105                     print_hex( md, GCRY_MD_SHA384, fname );
4106                 if (!gcry_md_test_algo (GCRY_MD_SHA512))
4107                     print_hex( md, GCRY_MD_SHA512, fname );
4108             }
4109         }
4110     }
4111     gcry_md_close(md);
4112
4113     if( fp != stdin )
4114         fclose(fp);
4115 }
4116
4117
4118 /****************
4119  * Check the supplied name,value string and add it to the notation
4120  * data to be used for signatures.  which==0 for sig notations, and 1
4121  * for cert notations.
4122 */
4123 static void
4124 add_notation_data( const char *string, int which )
4125 {
4126   struct notation *notation;
4127
4128   notation=string_to_notation(string,utf8_strings);
4129   if(notation)
4130     {
4131       if(which)
4132         {
4133           notation->next=opt.cert_notations;
4134           opt.cert_notations=notation;
4135         }
4136       else
4137         {
4138           notation->next=opt.sig_notations;
4139           opt.sig_notations=notation;
4140         }
4141     }
4142 }
4143
4144 static void
4145 add_policy_url( const char *string, int which )
4146 {
4147   unsigned int i,critical=0;
4148   strlist_t sl;
4149
4150   if(*string=='!')
4151     {
4152       string++;
4153       critical=1;
4154     }
4155
4156   for(i=0;i<strlen(string);i++)
4157     if( !isascii (string[i]) || iscntrl(string[i]))
4158       break;
4159
4160   if(i==0 || i<strlen(string))
4161     {
4162       if(which)
4163         log_error(_("the given certification policy URL is invalid\n"));
4164