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