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