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