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