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