* gpgsm.c (main): Add secmem features and set the random seed file.
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <assert.h>
29 #ifdef HAVE_DOSISH_SYSTEM
30 #include <fcntl.h> /* for setmode() */
31 #endif
32 #ifdef HAVE_STAT
33 #include <sys/stat.h> /* for stat() */
34 #endif
35 #include <assuan.h>
36
37 #define INCLUDED_BY_MAIN_MODULE 1
38 #include "gpg.h"
39 #include "packet.h"
40 #include "iobuf.h"
41 #include "memory.h"
42 #include "util.h"
43 #include "main.h"
44 #include "options.h"
45 #include "keydb.h"
46 #include "trustdb.h"
47 #include "mpi.h"
48 #include "cipher.h"
49 #include "filter.h"
50 #include "ttyio.h"
51 #include "i18n.h"
52 #include "status.h"
53 #include "keyserver-internal.h"
54 #include "exec.h"
55
56 enum cmd_and_opt_values { aNull = 0,
57     oArmor        = 'a',
58     aDetachedSign = 'b',
59     aSym          = 'c',
60     aDecrypt      = 'd',
61     aEncr         = 'e',
62     aEncrFiles,
63     oInteractive  = 'i',
64     oKOption      = 'k',
65     oDryRun       = 'n',
66     oOutput       = 'o',
67     oQuiet        = 'q',
68     oRecipient    = 'r',
69     oHiddenRecipient = 'R',
70     aSign         = 's',
71     oTextmodeShort= 't',
72     oUser         = 'u',
73     oVerbose      = 'v',
74     oCompress     = 'z',
75     oNotation     = 'N',
76     oBatch        = 500,
77     oSigNotation,
78     oCertNotation,
79     oShowNotation,
80     oNoShowNotation,
81     aDecryptFiles,                          
82     aClearsign,
83     aStore,
84     aKeygen,
85     aSignEncr,
86     aSignSym,
87     aSignKey,
88     aLSignKey,
89     aNRSignKey,
90     aNRLSignKey,
91     aListPackets,
92     aEditKey,
93     aDeleteKeys,
94     aDeleteSecretKeys,
95     aDeleteSecretAndPublicKeys,
96     aKMode,
97     aKModeC,
98     aImport,
99     aFastImport,
100     aVerify,
101     aVerifyFiles,
102     aListKeys,
103     aListSigs,
104     aListSecretKeys,
105     aSendKeys,
106     aRecvKeys,
107     aSearchKeys,
108     aExport,
109     aExportAll,
110     aExportSecret,
111     aExportSecretSub,
112     aCheckKeys,
113     aGenRevoke,
114     aDesigRevoke,
115     aPrimegen,
116     aPrintMD,
117     aPrintMDs,
118     aCheckTrustDB,
119     aUpdateTrustDB,
120     aFixTrustDB,
121     aListTrustDB,
122     aListTrustPath,
123     aExportOwnerTrust,
124     aListOwnerTrust,
125     aImportOwnerTrust,
126     aDeArmor,
127     aEnArmor,
128     aGenRandom,
129     aPipeMode,
130     aRebuildKeydbCaches,
131     aRefreshKeys,
132     aCardStatus,
133     aChangePIN,
134
135     oTextmode,
136     oNoTextmode,
137     oExpert,
138     oNoExpert,
139     oAskSigExpire,
140     oNoAskSigExpire,
141     oAskCertExpire,
142     oNoAskCertExpire,
143     oFingerprint,
144     oWithFingerprint,
145     oAnswerYes,
146     oAnswerNo,
147     oDefCertCheckLevel,
148     oKeyring,
149     oPrimaryKeyring,
150     oSecretKeyring,
151     oShowKeyring,
152     oDefaultKey,
153     oDefRecipient,
154     oDefRecipientSelf,
155     oNoDefRecipient,
156     oOptions,
157     oDebug,
158     oDebugAll,
159     oStatusFD,
160 #ifdef __riscos__
161     oStatusFile,
162 #endif /* __riscos__ */
163     oAttributeFD,
164 #ifdef __riscos__
165     oAttributeFile,
166 #endif /* __riscos__ */
167     oSKComments,
168     oNoSKComments,
169     oEmitVersion,
170     oNoEmitVersion,
171     oCompletesNeeded,
172     oMarginalsNeeded,
173     oMaxCertDepth,
174     oLoadExtension,
175     oGnuPG,
176     oRFC1991,
177     oOpenPGP,
178     oPGP2,
179     oPGP6,
180     oPGP7,
181     oPGP8,
182     oCipherAlgo,
183     oDigestAlgo,
184     oCertDigestAlgo,
185     oCompressAlgo,
186     oPasswdFD,
187 #ifdef __riscos__
188     oPasswdFile,
189 #endif /* __riscos__ */
190     oCommandFD,
191 #ifdef __riscos__
192     oCommandFile,
193 #endif /* __riscos__ */
194     oQuickRandom,
195     oNoVerbose,
196     oTrustDBName,
197     oNoSecmemWarn,
198     oNoPermissionWarn,
199     oNoMDCWarn,
200     oNoArmor,
201     oNoDefKeyring,
202     oNoGreeting,
203     oNoTTY,
204     oNoOptions,
205     oNoBatch,
206     oHomedir,
207     oWithColons,
208     oWithKeyData,
209     oSkipVerify,
210     oCompressKeys,
211     oCompressSigs,
212     oAlwaysTrust,
213     oTrustModel,
214     oForceOwnertrust,
215     oEmuChecksumBug,
216     oRunAsShmCP,
217     oSetFilename,
218     oForYourEyesOnly,
219     oNoForYourEyesOnly,
220     oSetPolicyURL,
221     oSigPolicyURL,
222     oCertPolicyURL,
223     oShowPolicyURL,
224     oNoShowPolicyURL,
225     oUseEmbeddedFilename,
226     oComment,
227     oDefaultComment,
228     oThrowKeyid,
229     oNoThrowKeyid,
230     oShowPhotos,
231     oNoShowPhotos,
232     oPhotoViewer,
233     oForceV3Sigs,
234     oNoForceV3Sigs,
235     oForceV4Certs,
236     oNoForceV4Certs,
237     oForceMDC,
238     oNoForceMDC,
239     oDisableMDC,
240     oNoDisableMDC,
241     oS2KMode,
242     oS2KDigest,
243     oS2KCipher,
244     oSimpleSKChecksum,                          
245     oCharset,
246     oNotDashEscaped,
247     oEscapeFrom,
248     oNoEscapeFrom,
249     oLockOnce,
250     oLockMultiple,
251     oLockNever,
252     oKeyServer,
253     oKeyServerOptions,
254     oImportOptions,
255     oExportOptions,
256     oListOptions,
257     oVerifyOptions,
258     oTempDir,
259     oExecPath,
260     oEncryptTo,
261     oHiddenEncryptTo,
262     oNoEncryptTo,
263     oLoggerFD,
264 #ifdef __riscos__
265     oLoggerFile,
266 #endif /* __riscos__ */
267     oUtf8Strings,
268     oNoUtf8Strings,
269     oDisableCipherAlgo,
270     oDisablePubkeyAlgo,
271     oAllowNonSelfsignedUID,
272     oNoAllowNonSelfsignedUID,
273     oAllowFreeformUID,
274     oNoAllowFreeformUID,
275     oAllowSecretKeyImport,                      
276     oEnableSpecialFilenames,
277     oNoLiteral,
278     oSetFilesize,
279     oHonorHttpProxy,
280     oFastListMode,
281     oListOnly,
282     oIgnoreTimeConflict,
283     oIgnoreValidFrom,
284     oIgnoreCrcError,
285     oIgnoreMDCError,
286     oShowSessionKey,
287     oOverrideSessionKey,
288     oNoRandomSeedFile,
289     oAutoKeyRetrieve,
290     oNoAutoKeyRetrieve,
291     oUseAgent,
292     oNoUseAgent,
293     oGpgAgentInfo,
294     oMergeOnly,
295     oTryAllSecrets,
296     oTrustedKey,
297     oNoExpensiveTrustChecks,
298     oFixedListMode,
299     oNoSigCache,
300     oNoSigCreateCheck,
301     oAutoCheckTrustDB,
302     oNoAutoCheckTrustDB,
303     oPreservePermissions,
304     oDefaultPreferenceList,
305     oPersonalCipherPreferences,
306     oPersonalDigestPreferences,
307     oPersonalCompressPreferences,
308     oEmuMDEncodeBug,
309     oAgentProgram,
310     oDisplay,
311     oTTYname,
312     oTTYtype,
313     oLCctype,
314     oLCmessages,
315     oGroup,
316     oStrict,
317     oNoStrict,
318     oMangleDosFilenames,
319     oNoMangleDosFilenames,
320     oEnableProgressFilter,                          
321 aTest };
322
323
324 static ARGPARSE_OPTS opts[] = {
325
326     { 300, NULL, 0, N_("@Commands:\n ") },
327
328     { aSign, "sign",      256, N_("|[file]|make a signature")},
329     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
330     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
331     { aEncr, "encrypt",   256, N_("encrypt data")},
332     { aEncrFiles, "encrypt-files", 256, N_("|[files]|encrypt files")},
333     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
334     { aStore, "store",     256, N_("store only")},
335     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
336     { aDecryptFiles, "decrypt-files", 256, N_("|[files]|decrypt files")},
337     { aVerify, "verify"   , 256, N_("verify a signature")},
338     { aVerifyFiles, "verify-files" , 256, "@" },
339     { aListKeys, "list-keys", 256, N_("list keys")},
340     { aListKeys, "list-public-keys", 256, "@" },
341     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
342     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
343     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
344     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
345     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
346     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
347     { aDeleteSecretKeys, "delete-secret-keys",256,
348                                     N_("remove keys from the secret keyring")},
349     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
350     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
351     { aNRSignKey, "nrsign-key"  ,256, N_("sign a key non-revocably")},
352     { aNRLSignKey, "nrlsign-key"  ,256, N_("sign a key locally and non-revocably")},
353     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
354     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
355     { aDesigRevoke, "desig-revoke",256, "@" },
356     { aExport, "export"           , 256, N_("export keys") },
357     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
358     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
359     { aSearchKeys, "search-keys" , 256,
360                                     N_("search for keys on a key server") },
361     { aRefreshKeys, "refresh-keys", 256,
362                                     N_("update all keys from a keyserver")},
363     { aExportAll, "export-all"    , 256, "@" },
364     { aExportSecret, "export-secret-keys" , 256, "@" },
365     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
366     { aImport, "import",      256     , N_("import/merge keys")},
367     { aFastImport, "fast-import",  256 , "@"},
368     { aCardStatus,  "card-status", 256, N_("print the card status")},
369     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
370
371     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
372     { aExportOwnerTrust,
373               "export-ownertrust", 256, N_("export the ownertrust values")},
374     { aImportOwnerTrust,
375               "import-ownertrust", 256, N_("import ownertrust values")},
376     { aUpdateTrustDB,
377               "update-trustdb",0 , N_("update the trust database")},
378     { aCheckTrustDB,
379               "check-trustdb",0 , N_("unattended trust database update")},
380     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
381     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
382     { aDeArmor, "dearmour", 256, "@" },
383     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
384     { aEnArmor, "enarmour", 256, "@" },
385     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
386     { aPrimegen, "gen-prime" , 256, "@" },
387     { aGenRandom, "gen-random" , 256, "@" },
388
389     { 301, NULL, 0, N_("@\nOptions:\n ") },
390
391     { oArmor, "armor",     0, N_("create ascii armored output")},
392     { oArmor, "armour",     0, "@" },
393     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
394     { oHiddenRecipient, "hidden-recipient", 2, "@" },
395     { oRecipient, "remote-user", 2, "@"},  /* old option name */
396     { oDefRecipient, "default-recipient" ,2,
397                                   N_("|NAME|use NAME as default recipient")},
398     { oDefRecipientSelf, "default-recipient-self" ,0,
399                                 N_("use the default key as default recipient")},
400     { oNoDefRecipient, "no-default-recipient", 0, "@" },
401     { oTempDir, "temp-directory", 2, "@" },
402     { oExecPath, "exec-path", 2, "@" },
403     { oEncryptTo, "encrypt-to", 2, "@" },
404     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
405     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
406     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
407     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
408     { oTextmodeShort, NULL,   0, "@"},
409     { oTextmode, "textmode",  0, N_("use canonical text mode")},
410     { oNoTextmode, "no-textmode",  0, "@"},
411     { oExpert, "expert",   0, "@"},
412     { oNoExpert, "no-expert",   0, "@"},
413     { oAskSigExpire, "ask-sig-expire",   0, "@"},
414     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
415     { oAskCertExpire, "ask-cert-expire",   0, "@"},
416     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
417     { oOutput, "output",    2, N_("use as output file")},
418     { oVerbose, "verbose",   0, N_("verbose") },
419     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
420     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
421     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
422     { oNoForceV3Sigs, "no-force-v3-sigs", 0, N_("do not force v3 signatures") },
423     { oForceV4Certs, "force-v4-certs", 0, N_("force v4 key signatures") },
424     { oNoForceV4Certs, "no-force-v4-certs", 0, N_("do not force v4 key signatures") },
425     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
426     { oNoForceMDC, "no-force-mdc", 0, "@" },
427     { oDisableMDC, "disable-mdc", 0, N_("never use a MDC for encryption") },
428     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
429     { oDryRun, "dry-run",   0, N_("do not make any changes") },
430     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
431     { oUseAgent, "use-agent",0, N_("use the gpg-agent")},
432     { oNoUseAgent, "no-use-agent",0, "@"},
433     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
434     { oBatch, "batch",     0, N_("batch mode: never ask")},
435     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
436     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
437     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
438     { oPrimaryKeyring, "primary-keyring",2, "@" },
439     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
440     { oShowKeyring, "show-keyring", 0, N_("show which keyring a listed key is on")},
441     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
442     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
443     { oKeyServerOptions, "keyserver-options",2,"@"},
444     { oImportOptions, "import-options",2,"@"},
445     { oExportOptions, "export-options",2,"@"},
446     { oListOptions, "list-options",2,"@"},
447     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
448     { oOptions, "options"   , 2, N_("read options from file")},
449
450     { oDebug, "debug"     ,4|16, "@"},
451     { oDebugAll, "debug-all" ,0, "@"},
452     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
453 #ifdef __riscos__
454     { oStatusFile, "status-file" ,2, N_("|[file]|write status info to file") },
455 #endif /* __riscos__ */
456     { oAttributeFD, "attribute-fd" ,1, "@" },
457 #ifdef __riscos__
458     { oAttributeFile, "attribute-file" ,2, "@" },
459 #endif /* __riscos__ */
460     { oNoSKComments, "no-comment", 0,   "@"},
461     { oNoSKComments, "no-sk-comments", 0,   "@"},
462     { oSKComments, "sk-comments", 0,   "@"},
463     { oCompletesNeeded, "completes-needed", 1, "@"},
464     { oMarginalsNeeded, "marginals-needed", 1, "@"},
465     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
466     { oTrustedKey, "trusted-key", 2, N_("|KEYID|ultimately trust this key")},
467     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
468     { oGnuPG, "gnupg",   0, "@"},
469     { oGnuPG, "no-pgp2", 0, "@"},
470     { oGnuPG, "no-pgp6", 0, "@"},
471     { oGnuPG, "no-pgp7", 0, "@"},
472     { oGnuPG, "no-pgp8", 0, "@"},
473     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
474     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
475     { oPGP2, "pgp2", 0, N_("set all packet, cipher and digest options to PGP 2.x behavior")},
476     { oPGP6, "pgp6", 0, "@"},
477     { oPGP7, "pgp7", 0, "@"},
478     { oPGP8, "pgp8", 0, "@"},
479     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
480     { oS2KDigest, "s2k-digest-algo",2,
481                 N_("|NAME|use message digest algorithm NAME for passphrases")},
482     { oS2KCipher, "s2k-cipher-algo",2,
483                 N_("|NAME|use cipher algorithm NAME for passphrases")},
484     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
485     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
486     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
487     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
488     { oCompressAlgo,"compress-algo",2,N_("|NAME|use compression algorithm NAME")},
489     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
490     { oNoThrowKeyid, "no-throw-keyid", 0, "@" },
491     { oShowPhotos,   "show-photos", 0, "@" },
492     { oNoShowPhotos, "no-show-photos", 0, "@" },
493     { oPhotoViewer,  "photo-viewer", 2, "@" },
494     { oNotation,   "notation-data", 2, "@" },
495     { oSigNotation,   "sig-notation", 2, "@" },
496     { oCertNotation,  "cert-notation", 2, "@" },
497
498     { 302, NULL, 0, N_(
499   "@\n(See the man page for a complete listing of all commands and options)\n"
500                       )},
501
502     { 303, NULL, 0, N_("@\nExamples:\n\n"
503     " -se -r Bob [file]          sign and encrypt for user Bob\n"
504     " --clearsign [file]         make a clear text signature\n"
505     " --detach-sign [file]       make a detached signature\n"
506     " --list-keys [names]        show keys\n"
507     " --fingerprint [names]      show fingerprints\n"  ) },
508
509   /* hidden options */
510     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
511     { oCompressAlgo, "compression-algo", 1, "@"}, /* alias */
512     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
513     { aListTrustDB, "list-trustdb",0 , "@"},
514     /* Not yet used */
515     /* { aListTrustPath, "list-trust-path",0, "@"}, */
516     { aPipeMode,  "pipemode", 0, "@" },
517     { oKOption, NULL,    0, "@"},
518     { oPasswdFD, "passphrase-fd",1, "@" },
519 #ifdef __riscos__
520     { oPasswdFile, "passphrase-file",2, "@" },
521 #endif /* __riscos__ */
522     { oCommandFD, "command-fd",1, "@" },
523 #ifdef __riscos__
524     { oCommandFile, "command-file",2, "@" },
525 #endif /* __riscos__ */
526     { oQuickRandom, "quick-random", 0, "@"},
527     { oNoVerbose, "no-verbose", 0, "@"},
528     { oTrustDBName, "trustdb-name", 2, "@" },
529     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
530     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
531     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
532     { oNoArmor, "no-armor",   0, "@"},
533     { oNoArmor, "no-armour",   0, "@"},
534     { oNoDefKeyring, "no-default-keyring", 0, "@" },
535     { oNoGreeting, "no-greeting", 0, "@" },
536     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
537     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
538     { oNoBatch, "no-batch", 0, "@" },
539     { oWithColons, "with-colons", 0, "@"},
540     { oWithKeyData,"with-key-data", 0, "@"},
541     { aListKeys, "list-key", 0, "@" }, /* alias */
542     { aListSigs, "list-sig", 0, "@" }, /* alias */
543     { aCheckKeys, "check-sig",0, "@" }, /* alias */
544     { oSkipVerify, "skip-verify",0, "@" },
545     { oCompressKeys, "compress-keys",0, "@"},
546     { oCompressSigs, "compress-sigs",0, "@"},
547     { oDefCertCheckLevel, "default-cert-check-level", 1, "@"},
548     { oAlwaysTrust, "always-trust", 0, "@"},
549     { oTrustModel, "trust-model", 2, "@"},
550     { oForceOwnertrust, "force-ownertrust", 2, "@"},
551     { oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
552     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
553     { oSetFilename, "set-filename", 2, "@" },
554     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
555     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
556     { oSetPolicyURL, "set-policy-url", 2, "@" },
557     { oSigPolicyURL, "sig-policy-url", 2, "@" },
558     { oCertPolicyURL, "cert-policy-url", 2, "@" },
559     { oShowPolicyURL, "show-policy-url", 0, "@" },
560     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
561     { oShowNotation, "show-notation", 0, "@" },
562     { oNoShowNotation, "no-show-notation", 0, "@" },
563     { oComment, "comment", 2, "@" },
564     { oDefaultComment, "default-comment", 0, "@" },
565     { oEmitVersion, "emit-version", 0, "@"},
566     { oNoEmitVersion, "no-emit-version", 0, "@"},
567     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
568     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
569     { oEscapeFrom, "escape-from-lines", 0, "@" },
570     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
571     { oLockOnce, "lock-once", 0, "@" },
572     { oLockMultiple, "lock-multiple", 0, "@" },
573     { oLockNever, "lock-never", 0, "@" },
574     { oLoggerFD, "logger-fd",1, "@" },
575 #ifdef __riscos__
576     { oLoggerFile, "logger-file",2, "@" },
577 #endif /* __riscos__ */
578     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
579     { oUtf8Strings, "utf8-strings", 0, "@" },
580     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
581     { oWithFingerprint, "with-fingerprint", 0, "@" },
582     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
583     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
584     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
585     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
586     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
587     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
588     { oNoLiteral, "no-literal", 0, "@" },
589     { oSetFilesize, "set-filesize", 20, "@" },
590     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
591     { oFastListMode,"fast-list-mode", 0, "@" },
592     { oFixedListMode,"fixed-list-mode", 0, "@" },
593     { oListOnly, "list-only", 0, "@"},
594     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
595     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
596     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
597     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
598     { oShowSessionKey, "show-session-key", 0, "@" },
599     { oOverrideSessionKey, "override-session-key", 2, "@" },
600     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
601     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
602     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
603     { oNoSigCache,         "no-sig-cache", 0, "@" },
604     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
605     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
606     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
607     { oMergeOnly,         "merge-only", 0, "@" },
608     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
609     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
610     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
611     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
612     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
613     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
614     { oPreservePermissions, "preserve-permissions", 0, "@"},
615     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
616     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
617     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
618     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
619     { oEmuMDEncodeBug,  "emulate-md-encode-bug", 0, "@"},
620     { oAgentProgram, "agent-program", 2 , "@" },
621     { oDisplay,    "display",     2, "@" },
622     { oTTYname,    "ttyname",     2, "@" },
623     { oTTYtype,    "ttytype",     2, "@" },
624     { oLCctype,    "lc-ctype",    2, "@" },
625     { oLCmessages, "lc-messages", 2, "@" },
626     { oGroup,      "group",       2, "@" },
627     { oStrict,     "strict",      0, "@" },
628     { oNoStrict,   "no-strict",   0, "@" },
629     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
630     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
631     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
632 {0} };
633
634
635
636 int g10_errors_seen = 0;
637
638 static int utf8_strings = 0;
639 static int maybe_setuid = 1;
640
641 static char *build_list( const char *text, char letter,
642                          const char *(*mapf)(int), int (*chkf)(int) );
643 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
644                         enum cmd_and_opt_values new_cmd );
645 static void print_mds( const char *fname, int algo );
646 static void add_notation_data( const char *string, int which );
647 static void add_policy_url( const char *string, int which );
648 static void emergency_cleanup (void);
649
650 #ifdef __riscos__
651 RISCOS_GLOBAL_STATICS("GnuPG Heap")
652 #endif /* __riscos__ */
653
654 static int
655 pk_test_algo (int algo)
656 {
657   return openpgp_pk_test_algo (algo, 0);
658 }
659
660
661 static const char *
662 my_strusage( int level )
663 {
664   static char *digests, *pubkeys, *ciphers, *zips;
665     const char *p;
666     switch( level ) {
667       case 11: p = "gpg (GnuPG)";
668         break;
669       case 13: p = VERSION; break;
670       case 17: p = PRINTABLE_OS_NAME; break;
671       case 19: p =
672             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
673         break;
674       case 1:
675       case 40:  p =
676             _("Usage: gpg [options] [files] (-h for help)");
677         break;
678       case 41:  p =
679             _("Syntax: gpg [options] [files]\n"
680               "sign, check, encrypt or decrypt\n"
681               "default operation depends on the input data\n");
682         break;
683
684       case 31: p = "\nHome: "; break;
685 #ifndef __riscos__
686       case 32: p = opt.homedir; break;
687 #else /* __riscos__ */
688       case 32: p = make_filename(opt.homedir, NULL); break;
689 #endif /* __riscos__ */
690       case 33: p = _("\nSupported algorithms:\n"); break;
691       case 34:
692         if( !pubkeys )
693             pubkeys = build_list(_("Pubkey: "), 0, gcry_pk_algo_name,
694                                  pk_test_algo );
695         p = pubkeys;
696         break;
697       case 35:
698         if( !ciphers )
699             ciphers = build_list(_("Cipher: "), 'S', gcry_cipher_algo_name,
700                                  openpgp_cipher_test_algo );
701         p = ciphers;
702         break;
703       case 36:
704         if( !digests )
705             digests = build_list(_("Hash: "), 'H', gcry_md_algo_name,
706                                         openpgp_md_test_algo );
707         p = digests;
708         break;
709       case 37:
710         if( !zips )
711             zips = build_list(_("Compression: "),'Z',compress_algo_to_string,
712                                                         check_compress_algo);
713         p = zips;
714         break;
715
716       default:  p = NULL;
717     }
718     return p;
719 }
720
721
722 static char *
723 build_list( const char *text, char letter,
724             const char * (*mapf)(int), int (*chkf)(int) )
725 {
726     int i;
727     const char *s;
728     size_t n=strlen(text)+2;
729     char *list, *p, *line=NULL;
730
731     if( maybe_setuid )
732         gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* drop setuid */
733
734     for(i=0; i <= 110; i++ )
735         if( !chkf(i) && (s=mapf(i)) )
736             n += strlen(s) + 7 + 2;
737     list = xmalloc ( 21 + n ); *list = 0;
738     for(p=NULL, i=0; i <= 110; i++ ) {
739         if( !chkf(i) && (s=mapf(i)) ) {
740             if( !p ) {
741                 p = stpcpy( list, text );
742                 line=p;
743             }
744             else
745                 p = stpcpy( p, ", ");
746
747             if(strlen(line)>60) {
748               int spaces=strlen(text);
749
750               list = xrealloc(list,n+spaces+1);
751               /* realloc could move the block, so find the end again */
752               p=list;
753               while(*p)
754                 p++;
755
756               p=stpcpy(p, "\n");
757               line=p;
758               for(;spaces;spaces--)
759                 p=stpcpy(p, " ");
760             }
761
762             p = stpcpy(p, s );
763             if(opt.verbose && letter)
764               {
765                 char num[8];
766                 sprintf(num," (%c%d)",letter,i);
767                 p = stpcpy(p,num);
768               }
769         }
770     }
771     if( p )
772         p = stpcpy(p, "\n" );
773     return list;
774 }
775
776
777 static void
778 i18n_init(void)
779 {
780 #ifdef USE_SIMPLE_GETTEXT
781     set_gettext_file( PACKAGE );
782 #else
783 #ifdef ENABLE_NLS
784     setlocale( LC_ALL, "" );
785     bindtextdomain( PACKAGE, LOCALEDIR );
786     textdomain( PACKAGE );
787 #endif
788 #endif
789 }
790
791 static void
792 wrong_args( const char *text)
793 {
794     fputs(_("usage: gpg [options] "),stderr);
795     fputs(text,stderr);
796     putc('\n',stderr);
797     g10_exit(2);
798 }
799
800
801 static void
802 log_set_strict (int yesno)
803 {
804   /* FIXME-XXX*/
805 }
806
807 static char *
808 make_username( const char *string )
809 {
810     char *p;
811     if( utf8_strings )
812         p = xstrdup (string);
813     else
814         p = native_to_utf8( string );
815     return p;
816 }
817
818
819 /*
820  * same as add_to_strlist() but if is_utf8 is *not* set a conversion
821  * to UTF8 is done  
822  */
823 static STRLIST
824 add_to_strlist2 ( STRLIST *list, const char *string, int is_utf8)
825 {
826   STRLIST sl;
827   
828   if (is_utf8)
829     sl = add_to_strlist( list, string );
830   else 
831     {
832       char *p = native_to_utf8( string );
833       sl = add_to_strlist( list, p );
834       xfree( p );
835     }
836   return sl;
837 }
838
839
840 static void
841 set_debug(void)
842 {
843   if (opt.debug & DBG_MEMORY_VALUE )
844     memory_debug_mode = 1;
845   if (opt.debug & DBG_MEMSTAT_VALUE )
846     memory_stat_debug_mode = 1;
847   if (opt.debug & DBG_MPI_VALUE)
848     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
849   if (opt.debug & DBG_CIPHER_VALUE )
850     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
851   if (opt.debug & DBG_IOBUF_VALUE )
852     iobuf_debug_mode = 1;
853 }
854
855
856 /* We need the home directory also in some other directories, so make
857    sure that both variables are always in sync. */
858 static void
859 set_homedir (char *dir)
860 {
861   if (!dir)
862     dir = "";
863   g10_opt_homedir = opt.homedir = dir;
864 }
865
866
867 static void
868 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
869 {
870     enum cmd_and_opt_values cmd = *ret_cmd;
871
872     if( !cmd || cmd == new_cmd )
873         cmd = new_cmd;
874     else if( cmd == aSign && new_cmd == aEncr )
875         cmd = aSignEncr;
876     else if( cmd == aEncr && new_cmd == aSign )
877         cmd = aSignEncr;
878     else if( cmd == aSign && new_cmd == aSym )
879         cmd = aSignSym;
880     else if( cmd == aSym && new_cmd == aSign )
881         cmd = aSignSym;
882     else if( cmd == aKMode && new_cmd == aSym )
883         cmd = aKModeC;
884     else if(    ( cmd == aSign     && new_cmd == aClearsign )
885              || ( cmd == aClearsign && new_cmd == aSign )  )
886         cmd = aClearsign;
887     else {
888         log_error(_("conflicting commands\n"));
889         g10_exit(2);
890     }
891
892     *ret_cmd = cmd;
893 }
894
895
896 static void add_group(char *string)
897 {
898   char *name,*value;
899   struct groupitem *item;
900   STRLIST values=NULL;
901
902   /* Break off the group name */
903   name=strsep(&string,"=");
904   if(string==NULL)
905     {
906       log_error(_("no = sign found in group definition \"%s\"\n"),name);
907       return;
908     }
909
910   trim_trailing_ws(name,strlen(name));
911
912   /* Break apart the values */
913   while ((value= strsep(&string," \t")))
914     {
915       if (*value)
916         add_to_strlist2 (&values,value,utf8_strings);
917     }
918
919   item=xmalloc (sizeof(struct groupitem));
920   item->name=name;
921   item->values=values;
922   item->next=opt.grouplist;
923
924   opt.grouplist=item;
925 }
926
927 /* We need to check three things.
928
929    0) The homedir.  It must be x00, a directory, and owned by the
930    user.
931
932    1) The options file.  Okay unless it or its containing directory is
933    group or other writable or not owned by us.  disable exec in this
934    case.
935
936    2) Extensions.  Same as #2.
937
938    Returns true if the item is unsafe. */
939 static int
940 check_permissions(const char *path,int item)
941 {
942 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
943   static int homedir_cache=-1;
944   char *tmppath,*dir;
945   struct stat statbuf,dirbuf;
946   int homedir=0,ret=0,checkonly=0;
947   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
948
949   if(opt.no_perm_warn)
950     return 0;
951
952   assert(item==0 || item==1 || item==2);
953
954   /* extensions may attach a path */
955   if(item==2 && path[0]!=DIRSEP_C)
956     {
957       if(strchr(path,DIRSEP_C))
958         tmppath=make_filename(path,NULL);
959       else
960         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
961     }
962   else
963     tmppath=xstrdup (path);
964
965   /* If the item is located in the homedir, but isn't the homedir,
966      don't continue if we already checked the homedir itself.  This is
967      to avoid user confusion with an extra options file warning which
968      could be rectified if the homedir itself had proper
969      permissions. */
970   if(item!=0 && homedir_cache>-1
971      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
972     {
973       ret=homedir_cache;
974       goto end;
975     }
976
977   /* It's okay if the file or directory doesn't exist */
978   if(stat(tmppath,&statbuf)!=0)
979     {
980       ret=0;
981       goto end;
982     }
983
984   /* Now check the enclosing directory.  Theoretically, we could walk
985      this test up to the root directory /, but for the sake of sanity,
986      I'm stopping at one level down. */
987   dir=make_dirname(tmppath);
988
989   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
990     {
991       /* Weird error */
992       ret=1;
993       goto end;
994     }
995
996   xfree (dir);
997
998   /* Assume failure */
999   ret=1;
1000
1001   if(item==0)
1002     {
1003       /* The homedir must be x00, a directory, and owned by the user. */
1004
1005       if(S_ISDIR(statbuf.st_mode))
1006         {
1007           if(statbuf.st_uid==getuid())
1008             {
1009               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1010                 ret=0;
1011               else
1012                 perm=1;
1013             }
1014           else
1015             own=1;
1016
1017           homedir_cache=ret;
1018         }
1019     }
1020   else if(item==1 || item==2)
1021     {
1022       /* The options or extension file.  Okay unless it or its
1023          containing directory is group or other writable or not owned
1024          by us or root. */
1025
1026       if(S_ISREG(statbuf.st_mode))
1027         {
1028           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1029             {
1030               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1031                 {
1032                   /* it's not writable, so make sure the enclosing
1033                      directory is also not writable */
1034                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1035                     {
1036                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1037                         ret=0;
1038                       else
1039                         enc_dir_perm=1;
1040                     }
1041                   else
1042                     enc_dir_own=1;
1043                 }
1044               else
1045                 {
1046                   /* it's writable, so the enclosing directory had
1047                      better not let people get to it. */
1048                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1049                     {
1050                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1051                         ret=0;
1052                       else
1053                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1054                     }
1055                   else
1056                     enc_dir_own=1;
1057                 }
1058             }
1059           else
1060             own=1;
1061         }
1062     }
1063   else
1064     BUG();
1065
1066   if(!checkonly)
1067     {
1068       if(own)
1069         {
1070           if(item==0)
1071             log_info(_("WARNING: unsafe ownership on "
1072                        "homedir \"%s\"\n"),tmppath);
1073           else if(item==1)
1074             log_info(_("WARNING: unsafe ownership on "
1075                        "configuration file \"%s\"\n"),tmppath);
1076           else
1077             log_info(_("WARNING: unsafe ownership on "
1078                        "extension \"%s\"\n"),tmppath);
1079         }
1080       if(perm)
1081         {
1082           if(item==0)
1083             log_info(_("WARNING: unsafe permissions on "
1084                        "homedir \"%s\"\n"),tmppath);
1085           else if(item==1)
1086             log_info(_("WARNING: unsafe permissions on "
1087                        "configuration file \"%s\"\n"),tmppath);
1088           else
1089             log_info(_("WARNING: unsafe permissions on "
1090                        "extension \"%s\"\n"),tmppath);
1091         }
1092       if(enc_dir_own)
1093         {
1094           if(item==0)
1095             log_info(_("WARNING: unsafe enclosing directory ownership on "
1096                        "homedir \"%s\"\n"),tmppath);
1097           else if(item==1)
1098             log_info(_("WARNING: unsafe enclosing directory ownership on "
1099                        "configuration file \"%s\"\n"),tmppath);
1100           else
1101             log_info(_("WARNING: unsafe enclosing directory ownership on "
1102                        "extension \"%s\"\n"),tmppath);
1103         }
1104       if(enc_dir_perm)
1105         {
1106           if(item==0)
1107             log_info(_("WARNING: unsafe enclosing directory permissions on "
1108                        "homedir \"%s\"\n"),tmppath);
1109           else if(item==1)
1110             log_info(_("WARNING: unsafe enclosing directory permissions on "
1111                        "configuration file \"%s\"\n"),tmppath);
1112           else
1113             log_info(_("WARNING: unsafe enclosing directory permissions on "
1114                        "extension \"%s\"\n"),tmppath);
1115         }
1116     }
1117
1118  end:
1119   xfree (tmppath);
1120
1121   if(homedir)
1122     homedir_cache=ret;
1123
1124   return ret;
1125
1126 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1127
1128   return 0;
1129 }
1130
1131 int
1132 main( int argc, char **argv )
1133 {
1134     ARGPARSE_ARGS pargs;
1135     iobuf_t a;
1136     int rc=0;
1137     int orig_argc;
1138     char **orig_argv;
1139     const char *fname;
1140     char *username;
1141     int may_coredump;
1142     STRLIST sl, remusr= NULL, locusr=NULL;
1143     STRLIST nrings=NULL, sec_nrings=NULL;
1144     armor_filter_context_t afx;
1145     int detached_sig = 0;
1146     FILE *configfp = NULL;
1147     char *configname = NULL;
1148     unsigned configlineno;
1149     int parse_debug = 0;
1150     int default_config = 1;
1151     int default_keyring = 1;
1152     int greeting = 0;
1153     int nogreeting = 0;
1154     int use_random_seed = 1;
1155     enum cmd_and_opt_values cmd = 0;
1156     const char *trustdb_name = NULL;
1157     char *def_cipher_string = NULL;
1158     char *def_digest_string = NULL;
1159     char *def_compress_string = NULL;
1160     char *cert_digest_string = NULL;
1161     char *s2k_cipher_string = NULL;
1162     char *s2k_digest_string = NULL;
1163     char *pers_cipher_list = NULL;
1164     char *pers_digest_list = NULL;
1165     char *pers_compress_list = NULL;
1166     int eyes_only=0;
1167     int pwfd = -1;
1168     int with_fpr = 0; /* make an option out of --fingerprint */
1169     int any_explicit_recipient = 0;
1170 #ifdef USE_SHM_COPROCESSING
1171     ulong requested_shm_size=0;
1172 #endif
1173
1174 #ifdef __riscos__
1175     riscos_global_defaults();
1176     opt.lock_once = 1;
1177 #endif /* __riscos__ */
1178
1179     trap_unaligned();
1180     set_strusage (my_strusage);
1181     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1182     /* We don't need any locking in libgcrypt unless we use any kind of
1183        threading. */
1184     gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1185     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1186      * when adding any stuff between here and the call to
1187      * secmem_init()  somewhere after the option parsing
1188      */
1189     log_set_prefix ("gpg", 1);
1190     /* check that the libraries are suitable.  Do it here because the
1191        option parse may need services of the library */
1192     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1193       {
1194         log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
1195                    NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1196       }
1197
1198     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1199
1200     may_coredump = disable_core_dumps();
1201     gnupg_init_signals (0, emergency_cleanup);
1202     create_dotlock (NULL); /* register locking cleanup */
1203     i18n_init();
1204
1205     opt.command_fd = -1; /* no command fd */
1206     opt.compress = -1; /* defaults to standard compress level */
1207     /* note: if you change these lines, look at oOpenPGP */
1208     opt.def_cipher_algo = 0;
1209     opt.def_digest_algo = 0;
1210     opt.cert_digest_algo = 0;
1211     opt.def_compress_algo = -1;
1212     opt.s2k_mode = 3; /* iterated+salted */
1213     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1214 #ifdef USE_CAST5
1215     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1216 #else
1217     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1218 #endif
1219     opt.completes_needed = 1;
1220     opt.marginals_needed = 3;
1221     opt.max_cert_depth = 5;
1222     opt.pgp2_workarounds = 1;
1223     opt.force_v3_sigs = 1;
1224     opt.escape_from = 1;
1225     opt.import_options=IMPORT_SK2PK;
1226     opt.export_options=
1227       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1228     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1229     opt.keyserver_options.export_options=
1230       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1231     opt.keyserver_options.include_subkeys=1;
1232     opt.keyserver_options.include_revoked=1;
1233     opt.keyserver_options.try_dns_srv=1;
1234     opt.verify_options=VERIFY_SHOW_POLICY|VERIFY_SHOW_NOTATION;
1235     opt.trust_model=TM_AUTO;
1236     opt.mangle_dos_filenames = 1;
1237     opt.use_agent = 1;
1238
1239 #if defined (__MINGW32__)
1240     set_homedir ( read_w32_registry_string( NULL,
1241                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1242 #else
1243     set_homedir ( getenv("GNUPGHOME") );
1244 #endif
1245     if( !*opt.homedir )
1246         set_homedir ( GNUPG_HOMEDIR );
1247
1248     /* check whether we have a config file on the commandline */
1249     orig_argc = argc;
1250     orig_argv = argv;
1251     pargs.argc = &argc;
1252     pargs.argv = &argv;
1253     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1254     while( arg_parse( &pargs, opts) ) {
1255         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1256             parse_debug++;
1257         else if( pargs.r_opt == oOptions ) {
1258             /* yes there is one, so we do not try the default one, but
1259              * read the option file when it is encountered at the commandline
1260              */
1261             default_config = 0;
1262         }
1263         else if( pargs.r_opt == oNoOptions )
1264             default_config = 0; /* --no-options */
1265         else if( pargs.r_opt == oHomedir )
1266             set_homedir ( pargs.r.ret_str );
1267         else if( pargs.r_opt == oNoPermissionWarn )
1268             opt.no_perm_warn=1;
1269         else if (pargs.r_opt == oStrict )
1270           {
1271             opt.strict=1;
1272             log_set_strict(1);
1273           }
1274         else if (pargs.r_opt == oNoStrict )
1275           {
1276             opt.strict=0;
1277             log_set_strict(0);
1278           }
1279 #ifdef USE_SHM_COPROCESSING
1280         else if( pargs.r_opt == oRunAsShmCP ) {
1281             /* does not make sense in a options file, we do it here,
1282              * so that we are the able to drop setuid as soon as possible */
1283             opt.shm_coprocess = 1;
1284             requested_shm_size = pargs.r.ret_ulong;
1285         }
1286         else if ( pargs.r_opt == oStatusFD ) {
1287             /* this is needed to ensure that the status-fd filedescriptor is
1288              * initialized when init_shm_coprocessing() is called */
1289             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1290         }
1291 #endif
1292     }
1293
1294 #ifdef HAVE_DOSISH_SYSTEM
1295     if ( strchr (opt.homedir,'\\') ) {
1296         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1297         const char *s = opt.homedir;
1298         for (d=buf,s=opt.homedir; *s; s++)
1299             *d++ = *s == '\\'? '/': *s;
1300         *d = 0;
1301         set_homedir (buf);
1302     }
1303 #endif
1304 #ifdef USE_SHM_COPROCESSING
1305     if( opt.shm_coprocess ) {
1306         init_shm_coprocessing(requested_shm_size, 1 );
1307     }
1308 #endif
1309     /* Initialize the secure memory. */
1310     gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1311     maybe_setuid = 0;
1312     /* Okay, we are now working under our real uid */
1313
1314     /* malloc hooks go here ... */
1315     assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1316
1317     set_native_charset (NULL); /* Try to auto set the character set */
1318
1319     if( default_config )
1320       {
1321        /* Try for a version specific config file first */
1322         configname = make_filename(opt.homedir,
1323                                    "gpg" EXTSEP_S "conf-" SAFE_VERSION, NULL );
1324         if(access(configname,R_OK))
1325           {
1326             xfree (configname);
1327             configname = make_filename(opt.homedir,
1328                                        "gpg" EXTSEP_S "conf", NULL );
1329           }
1330         if (!access (configname, R_OK))
1331           { /* Print a warning when both config files are present. */
1332             char *p = make_filename(opt.homedir, "options", NULL );
1333             if (!access (p, R_OK))
1334               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1335             xfree (p);
1336           }
1337         else
1338           { /* Keep on using the old default one. */
1339             xfree (configname);
1340             configname = make_filename(opt.homedir, "options", NULL );
1341           }
1342       }
1343     argc = orig_argc;
1344     argv = orig_argv;
1345     pargs.argc = &argc;
1346     pargs.argv = &argv;
1347     pargs.flags=  1;  /* do not remove the args */
1348
1349     /* By this point we have a homedir, and cannot change it. */
1350     check_permissions(opt.homedir,0);
1351
1352   next_pass:
1353     if( configname ) {
1354       if(check_permissions(configname,1))
1355         {
1356           /* If any options file is unsafe, then disable any external
1357              programs for keyserver calls or photo IDs.  Since the
1358              external program to call is set in the options file, a
1359              unsafe options file can lead to an arbitrary program
1360              being run. */
1361
1362           opt.exec_disable=1;
1363         }
1364
1365         configlineno = 0;
1366         configfp = fopen( configname, "r" );
1367         if( !configfp ) {
1368             if( default_config ) {
1369                 if( parse_debug )
1370                     log_info(_("NOTE: no default option file `%s'\n"),
1371                                                             configname );
1372             }
1373             else {
1374                 log_error(_("option file `%s': %s\n"),
1375                                     configname, strerror(errno) );
1376                 g10_exit(2);
1377             }
1378             xfree (configname); configname = NULL;
1379         }
1380         if( parse_debug && configname )
1381             log_info(_("reading options from `%s'\n"), configname );
1382         default_config = 0;
1383     }
1384
1385     while( optfile_parse( configfp, configname, &configlineno,
1386                                                 &pargs, opts) ) {
1387         switch( pargs.r_opt ) {
1388           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1389           case aListPackets: set_cmd( &cmd, aListPackets); break;
1390           case aImport: set_cmd( &cmd, aImport); break;
1391           case aFastImport: set_cmd( &cmd, aFastImport); break;
1392           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1393           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1394           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1395           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1396           case aExport: set_cmd( &cmd, aExport); break;
1397           case aExportAll: set_cmd( &cmd, aExportAll); break;
1398           case aListKeys: set_cmd( &cmd, aListKeys); break;
1399           case aListSigs: set_cmd( &cmd, aListSigs); break;
1400           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1401           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1402           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1403                                                         greeting=1; break;
1404           case aDeleteSecretAndPublicKeys:
1405             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1406             greeting=1; 
1407             break;
1408           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1409
1410           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1411           case aSym: set_cmd( &cmd, aSym); break;
1412
1413           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1414           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1415
1416           case aEncr: set_cmd( &cmd, aEncr); break;
1417           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1418           case aSign: set_cmd( &cmd, aSign );  break;
1419           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1420           case aSignKey: set_cmd( &cmd, aSignKey); break;
1421           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1422           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1423           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1424           case aStore: set_cmd( &cmd, aStore); break;
1425           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1426           case aClearsign: set_cmd( &cmd, aClearsign); break;
1427           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1428           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1429           case aVerify: set_cmd( &cmd, aVerify); break;
1430           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1431           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1432           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1433           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1434           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1435           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1436           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1437           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1438           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1439           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1440           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1441           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1442           case aListOwnerTrust:
1443             deprecated_warning(configname,configlineno,
1444                                "--list-ownertrust","--export-ownertrust","");
1445           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1446           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1447           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1448           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1449
1450           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1451           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1452
1453           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1454           case oOutput: opt.outfile = pargs.r.ret_str; break;
1455           case oQuiet: opt.quiet = 1; break;
1456           case oNoTTY: tty_no_terminal(1); break;
1457           case oDryRun: opt.dry_run = 1; break;
1458           case oInteractive: opt.interactive = 1; break;
1459           case oVerbose: g10_opt_verbose++;
1460                     opt.verbose++; opt.list_sigs=1; break;
1461           case oKOption: set_cmd( &cmd, aKMode ); break;
1462
1463           case oBatch: opt.batch = 1; nogreeting = 1; break;
1464           case oUseAgent:
1465 #ifndef __riscos__
1466             opt.use_agent = 1;
1467 #else /* __riscos__ */
1468             opt.use_agent = 0;
1469             riscos_not_implemented("use-agent");
1470 #endif /* __riscos__ */
1471             break;
1472           case oNoUseAgent: opt.use_agent = 0; break;
1473           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1474           case oAnswerYes: opt.answer_yes = 1; break;
1475           case oAnswerNo: opt.answer_no = 1; break;
1476           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1477           case oPrimaryKeyring:
1478             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1479             sl->flags=2;
1480             break;
1481           case oShowKeyring: opt.list_options|=LIST_SHOW_KEYRING; break;
1482           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1483           case oDebugAll: opt.debug = ~0; break;
1484           case oStatusFD:
1485             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1486             break;
1487 #ifdef __riscos__
1488           case oStatusFile:
1489             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1490             break;
1491 #endif /* __riscos__ */
1492           case oAttributeFD:
1493             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1494             break;
1495 #ifdef __riscos__
1496           case oAttributeFile:
1497             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1498             break;
1499 #endif /* __riscos__ */
1500           case oLoggerFD:
1501             log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
1502             break;
1503 #ifdef __riscos__
1504           case oLoggerFile:
1505             log_set_logfile( NULL,
1506                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1507             break;
1508 #endif /* __riscos__ */
1509           case oWithFingerprint:
1510             opt.with_fingerprint = 1;
1511             with_fpr=1; /*fall thru*/
1512           case oFingerprint: opt.fingerprint++; break;
1513           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1514           case oOptions:
1515             /* config files may not be nested (silently ignore them) */
1516             if( !configfp ) {
1517                 xfree (configname);
1518                 configname = xstrdup (pargs.r.ret_str);
1519                 goto next_pass;
1520             }
1521             break;
1522           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1523           case oNoDefKeyring: default_keyring = 0; break;
1524           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1525           case oNoGreeting: nogreeting = 1; break;
1526           case oNoVerbose: g10_opt_verbose = 0;
1527                            opt.verbose = 0; opt.list_sigs=0; break;
1528       /* disabled for now: 
1529           case oQuickRandom: quick_random_gen(1); break; */
1530           case oSKComments: opt.sk_comments=1; break;
1531           case oNoSKComments: opt.sk_comments=0; break;
1532           case oEmitVersion: opt.no_version=0; break;
1533           case oNoEmitVersion: opt.no_version=1; break;
1534           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1535           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1536           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1537           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1538           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1539           case oDefRecipient:
1540                     if( *pargs.r.ret_str )
1541                         opt.def_recipient = make_username(pargs.r.ret_str);
1542                     break;
1543           case oDefRecipientSelf:
1544                     xfree (opt.def_recipient); opt.def_recipient = NULL;
1545                     opt.def_recipient_self = 1;
1546                     break;
1547           case oNoDefRecipient:
1548                     xfree (opt.def_recipient); opt.def_recipient = NULL;
1549                     opt.def_recipient_self = 0;
1550                     break;
1551           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1552           case oHomedir: break;
1553           case oNoBatch: opt.batch = 0; break;
1554           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1555           case oWithColons: opt.with_colons=':'; break;
1556
1557           case oSkipVerify: opt.skip_verify=1; break;
1558           case oCompressKeys: opt.compress_keys = 1; break;
1559           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1560             /* There are many programs (like mutt) that call gpg with
1561                --always-trust so keep this option around for a long
1562                time. */
1563           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1564           case oTrustModel:
1565             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1566               opt.trust_model=TM_PGP;
1567             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1568               opt.trust_model=TM_CLASSIC;
1569             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1570               opt.trust_model=TM_ALWAYS;
1571             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1572               opt.trust_model=TM_AUTO;
1573             else
1574               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1575             break;
1576           case oForceOwnertrust:
1577             log_info(_("NOTE: %s is not for normal use!\n"),
1578                      "--force-ownertrust");
1579             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1580             if(opt.force_ownertrust==-1)
1581               {
1582                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1583                 opt.force_ownertrust=0;
1584               }
1585             break;
1586           case oLoadExtension:
1587 #ifndef __riscos__
1588 #if defined(USE_DYNAMIC_LINKING) || defined(__MINGW32__)
1589             if(check_permissions(pargs.r.ret_str,2))
1590               log_info(_("cipher extension \"%s\" not loaded due to "
1591                          "unsafe permissions\n"),pargs.r.ret_str);
1592             else
1593               register_cipher_extension(orig_argc? *orig_argv:NULL,
1594                                         pargs.r.ret_str);
1595 #endif
1596 #else /* __riscos__ */
1597             riscos_not_implemented("load-extension");
1598 #endif /* __riscos__ */
1599             break;
1600           case oRFC1991:
1601             opt.compliance = CO_RFC1991;
1602             opt.force_v4_certs = 0;
1603             opt.disable_mdc = 1;
1604             opt.escape_from = 1;
1605             break;
1606           case oOpenPGP:
1607             /* TODO: When 2440bis becomes a RFC, these may need
1608                changing. */
1609             opt.compliance = CO_RFC2440;
1610             opt.disable_mdc = 1;
1611             opt.allow_non_selfsigned_uid = 1;
1612             opt.allow_freeform_uid = 1;
1613             opt.pgp2_workarounds = 0;
1614             opt.escape_from = 0;
1615             opt.force_v3_sigs = 0;
1616             opt.compress_keys = 0;          /* not mandated  but we do it */
1617             opt.compress_sigs = 0;          /* ditto. */
1618             opt.not_dash_escaped = 0;
1619             opt.def_cipher_algo = 0;
1620             opt.def_digest_algo = 0;
1621             opt.cert_digest_algo = 0;
1622             opt.def_compress_algo = -1;
1623             opt.s2k_mode = 3; /* iterated+salted */
1624             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1625             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1626             break;
1627           case oPGP2:  opt.compliance = CO_PGP2;  break;
1628           case oPGP6:  opt.compliance = CO_PGP6;  break;
1629           case oPGP7:  opt.compliance = CO_PGP7;  break;
1630           case oPGP8:  opt.compliance = CO_PGP8;  break;
1631           case oGnuPG: opt.compliance = CO_GNUPG; break;
1632           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1633           case oCompressSigs: opt.compress_sigs = 1; break;
1634           case oRunAsShmCP:
1635 #ifndef __riscos__
1636 # ifndef USE_SHM_COPROCESSING
1637             /* not possible in the option file,
1638              * but we print the warning here anyway */
1639             log_error("shared memory coprocessing is not available\n");
1640 # endif
1641 #else /* __riscos__ */
1642             riscos_not_implemented("run-as-shm-coprocess");
1643 #endif /* __riscos__ */
1644             break;
1645           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1646           case oForYourEyesOnly: eyes_only = 1; break;
1647           case oNoForYourEyesOnly: eyes_only = 0; break;
1648           case oSetPolicyURL:
1649             add_policy_url(pargs.r.ret_str,0);
1650             add_policy_url(pargs.r.ret_str,1);
1651             break;
1652           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1653           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1654           case oShowPolicyURL:
1655             opt.list_options|=LIST_SHOW_POLICY;
1656             opt.verify_options|=VERIFY_SHOW_POLICY;
1657             break;
1658           case oNoShowPolicyURL:
1659             opt.list_options&=~LIST_SHOW_POLICY;
1660             opt.verify_options&=~VERIFY_SHOW_POLICY;
1661             break;
1662           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1663           case oComment: opt.comment_string = pargs.r.ret_str; break;
1664           case oDefaultComment: opt.comment_string = NULL; break;
1665           case oThrowKeyid: opt.throw_keyid = 1; break;
1666           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1667           case oShowPhotos: 
1668             opt.list_options|=LIST_SHOW_PHOTOS;
1669             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1670             break;
1671           case oNoShowPhotos:
1672             opt.list_options&=~LIST_SHOW_PHOTOS;
1673             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1674             break;
1675           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1676           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1677           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1678           case oForceV4Certs: opt.force_v4_certs = 1; break;
1679           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1680           case oForceMDC: opt.force_mdc = 1; break;
1681           case oNoForceMDC: opt.force_mdc = 0; break;
1682           case oDisableMDC: opt.disable_mdc = 1; break;
1683           case oNoDisableMDC: opt.disable_mdc = 0; break;
1684           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1685           case oS2KDigest: s2k_digest_string = xstrdup (pargs.r.ret_str); break;
1686           case oS2KCipher: s2k_cipher_string = xstrdup (pargs.r.ret_str); break;
1687           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1688           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1689           case oEncryptTo: /* store the recipient in the second list */
1690             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1691             sl->flags = 1;
1692             break;
1693           case oHiddenEncryptTo: /* store the recipient in the second list */
1694             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1695             sl->flags = 1|2;
1696             break;
1697           case oRecipient: /* store the recipient */
1698             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1699             any_explicit_recipient = 1;
1700             break;
1701           case oHiddenRecipient: /* store the recipient with a flag */
1702             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1703             sl->flags = 2;
1704             any_explicit_recipient = 1;
1705             break;
1706           case oTextmodeShort: opt.textmode = 2; break;
1707           case oTextmode: opt.textmode=1;  break;
1708           case oNoTextmode: opt.textmode=0;  break;
1709           case oExpert: opt.expert = 1; break;
1710           case oNoExpert: opt.expert = 0; break;
1711           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1712           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1713           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1714           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1715           case oUser: /* store the local users */
1716             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1717             break;
1718           case oCompress: opt.compress = pargs.r.ret_int; break;
1719           case oPasswdFD:
1720             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1721             break;
1722 #ifdef __riscos__
1723           case oPasswdFile:
1724             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1725             break;
1726 #endif /* __riscos__ */
1727           case oCommandFD:
1728             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1729             break;
1730 #ifdef __riscos__
1731           case oCommandFile:
1732             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1733             break;
1734 #endif /* __riscos__ */
1735           case oCipherAlgo: def_cipher_string = xstrdup (pargs.r.ret_str); break;
1736           case oDigestAlgo: def_digest_string = xstrdup (pargs.r.ret_str); break;
1737           case oCompressAlgo:
1738             /* If it is all digits, stick a Z in front of it for
1739                later.  This is for backwards compatibility with
1740                versions that took the compress algorithm number. */
1741             {
1742               char *pt=pargs.r.ret_str;
1743               while(*pt)
1744                 {
1745                   if(!isdigit(*pt))
1746                     break;
1747
1748                   pt++;
1749                 }
1750
1751               if(*pt=='\0')
1752                 {
1753                   def_compress_string=xmalloc (strlen(pargs.r.ret_str)+2);
1754                   strcpy(def_compress_string,"Z");
1755                   strcat(def_compress_string,pargs.r.ret_str);
1756                 }
1757               else
1758                 def_compress_string = xstrdup (pargs.r.ret_str);
1759             }
1760             break;
1761           case oCertDigestAlgo: cert_digest_string = xstrdup (pargs.r.ret_str); break;
1762           case oNoSecmemWarn:
1763             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
1764             break;
1765           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1766           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1767           case oCharset:
1768             if( set_native_charset( pargs.r.ret_str ) )
1769                 log_error(_("%s is not a valid character set\n"),
1770                                                     pargs.r.ret_str);
1771             break;
1772           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1773           case oEscapeFrom: opt.escape_from = 1; break;
1774           case oNoEscapeFrom: opt.escape_from = 0; break;
1775           case oLockOnce: opt.lock_once = 1; break;
1776           case oLockNever: disable_dotlock(); break;
1777           case oLockMultiple:
1778 #ifndef __riscos__
1779             opt.lock_once = 0;
1780 #else /* __riscos__ */
1781             riscos_not_implemented("lock-multiple");
1782 #endif /* __riscos__ */
1783             break;
1784           case oKeyServer:
1785             opt.keyserver_uri=xstrdup (pargs.r.ret_str);
1786             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1787               log_error(_("could not parse keyserver URI\n"));
1788             break;
1789           case oKeyServerOptions:
1790             parse_keyserver_options(pargs.r.ret_str);
1791             break;
1792           case oImportOptions:
1793             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1794               {
1795                 if(configname)
1796                   log_error(_("%s:%d: invalid import options\n"),
1797                             configname,configlineno);
1798                 else
1799                   log_error(_("invalid import options\n"));
1800               }
1801             break;
1802           case oExportOptions:
1803             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1804               {
1805                 if(configname)
1806                   log_error(_("%s:%d: invalid export options\n"),
1807                             configname,configlineno);
1808                 else
1809                   log_error(_("invalid export options\n"));
1810               }
1811             break;
1812           case oListOptions:
1813             {
1814               struct parse_options lopts[]=
1815                 {
1816                   {"show-photos",LIST_SHOW_PHOTOS},
1817                   {"show-policy-url",LIST_SHOW_POLICY},
1818                   {"show-notation",LIST_SHOW_NOTATION},
1819                   {"show-keyring",LIST_SHOW_KEYRING},
1820                   {"show-validity",LIST_SHOW_VALIDITY},
1821                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1822                   {NULL,0}
1823                 };
1824
1825               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1826                 {
1827                   if(configname)
1828                     log_error(_("%s:%d: invalid list options\n"),
1829                               configname,configlineno);
1830                   else
1831                     log_error(_("invalid list options\n"));
1832                 }
1833             }
1834             break;
1835           case oVerifyOptions:
1836             {
1837               struct parse_options vopts[]=
1838                 {
1839                   {"show-photos",VERIFY_SHOW_PHOTOS},
1840                   {"show-policy-url",VERIFY_SHOW_POLICY},
1841                   {"show-notation",VERIFY_SHOW_NOTATION},
1842                   {NULL,0}
1843                 };
1844
1845               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1846                 {
1847                   if(configname)
1848                     log_error(_("%s:%d: invalid verify options\n"),
1849                               configname,configlineno);
1850                   else
1851                     log_error(_("invalid verify options\n"));
1852                 }
1853             }
1854             break;
1855           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1856           case oExecPath:
1857             if(set_exec_path(pargs.r.ret_str,0))
1858               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1859             else
1860               opt.exec_path_set=1;
1861             break;
1862           case oNotation:
1863             add_notation_data( pargs.r.ret_str, 0 );
1864             add_notation_data( pargs.r.ret_str, 1 );
1865             break;
1866           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1867           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1868           case oShowNotation:
1869             opt.list_options|=LIST_SHOW_NOTATION;
1870             opt.verify_options|=VERIFY_SHOW_NOTATION;
1871             break;
1872           case oNoShowNotation:
1873             opt.list_options&=~LIST_SHOW_NOTATION;
1874             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1875             break;
1876           case oUtf8Strings: utf8_strings = 1; break;
1877           case oNoUtf8Strings: utf8_strings = 0; break;
1878           case oDisableCipherAlgo:
1879             {
1880               int algo = gcry_cipher_map_name (pargs.r.ret_str);
1881               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO,
1882                                &algo, sizeof algo);
1883             }
1884             break;
1885           case oDisablePubkeyAlgo:
1886             {
1887               int algo = gcry_pk_map_name (pargs.r.ret_str);
1888               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,
1889                            &algo, sizeof algo );
1890             }
1891             break;
1892           case oNoSigCache: opt.no_sig_cache = 1; break;
1893           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1894           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1895           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1896           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1897           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1898           case oNoLiteral: opt.no_literal = 1; break;
1899           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1900           case oHonorHttpProxy:
1901                 opt.keyserver_options.honor_http_proxy = 1;
1902                 deprecated_warning(configname,configlineno,
1903                                    "--honor-http-proxy",
1904                                    "--keyserver-options ",
1905                                    "honor-http-proxy");
1906                 break;
1907           case oFastListMode: opt.fast_list_mode = 1; break;
1908           case oFixedListMode: opt.fixed_list_mode = 1; break;
1909           case oListOnly: opt.list_only=1; break;
1910           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1911           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1912           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1913           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1914           case oNoRandomSeedFile: use_random_seed = 0; break;
1915           case oAutoKeyRetrieve:
1916           case oNoAutoKeyRetrieve:
1917                 opt.keyserver_options.auto_key_retrieve=
1918                                              (pargs.r_opt==oAutoKeyRetrieve);
1919                 deprecated_warning(configname,configlineno,
1920                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1921                                "--no-auto-key-retrieve","--keyserver-options ",
1922                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1923                                "no-auto-key-retrieve");
1924                 break;
1925           case oShowSessionKey: opt.show_session_key = 1; break;
1926           case oOverrideSessionKey:
1927                 opt.override_session_key = pargs.r.ret_str;
1928                 break;
1929           case oMergeOnly: opt.merge_only = 1; break;
1930           case oAllowSecretKeyImport: /* obsolete */ break;
1931           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1932           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1933           case oEnableSpecialFilenames:
1934             iobuf_enable_special_filenames (1);
1935             break;
1936           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1937           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1938           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1939           case oPreservePermissions: opt.preserve_permissions=1; break;
1940           case oDefaultPreferenceList:
1941             opt.def_preference_list = pargs.r.ret_str;
1942             break;
1943           case oPersonalCipherPreferences:
1944             pers_cipher_list=pargs.r.ret_str;
1945             break;
1946           case oPersonalDigestPreferences:
1947             pers_digest_list=pargs.r.ret_str;
1948             break;
1949           case oPersonalCompressPreferences:
1950             pers_compress_list=pargs.r.ret_str;
1951             break;
1952           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1953           case oDisplay: opt.display = pargs.r.ret_str; break;
1954           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1955           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1956           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1957           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1958           case oGroup: add_group(pargs.r.ret_str); break;
1959           case oStrict: opt.strict=1; log_set_strict(1); break;
1960           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1961
1962           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1963           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1964
1965           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1966
1967           default : pargs.err = configfp? 1:2; break;
1968         }
1969     }
1970
1971     if( configfp ) {
1972         fclose( configfp );
1973         configfp = NULL;
1974         xfree (configname); configname = NULL;
1975         goto next_pass;
1976     }
1977     xfree ( configname ); configname = NULL;
1978     if( log_get_errorcount(0) )
1979         g10_exit(2);
1980     if( nogreeting )
1981         greeting = 0;
1982
1983     if( greeting ) {
1984         fprintf(stderr, "%s %s; %s\n",
1985                         strusage(11), strusage(13), strusage(14) );
1986         fprintf(stderr, "%s\n", strusage(15) );
1987     }
1988 #ifdef IS_DEVELOPMENT_VERSION
1989     if( !opt.batch ) {
1990         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1991         log_info("It is only intended for test purposes and should NOT be\n");
1992         log_info("used in a production environment or with production keys!\n");
1993     }
1994 #endif
1995
1996     if (opt.verbose > 2)
1997         log_info ("using character set `%s'\n", get_native_charset ());
1998
1999     if( may_coredump && !opt.quiet )
2000         log_info(_("WARNING: program may create a core file!\n"));
2001
2002     if (eyes_only) {
2003       if (opt.set_filename)
2004           log_info(_("WARNING: %s overrides %s\n"),
2005                    "--for-your-eyes-only","--set-filename");
2006
2007       opt.set_filename="_CONSOLE";
2008     }
2009
2010     if (opt.no_literal) {
2011         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2012         if (opt.textmode)
2013             log_error(_("%s not allowed with %s!\n"),
2014                        "--textmode", "--no-literal" );
2015         if (opt.set_filename)
2016             log_error(_("%s makes no sense with %s!\n"),
2017                         eyes_only?"--for-your-eyes-only":"--set-filename",
2018                         "--no-literal" );
2019     }
2020
2021     if (opt.set_filesize)
2022         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2023     if( opt.batch )
2024         tty_batchmode( 1 );
2025
2026     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
2027     set_debug();
2028
2029     /* Do these after the switch(), so they can override settings. */
2030     if(PGP2)
2031       {
2032         int unusable=0;
2033
2034         if(cmd==aSign && !detached_sig)
2035           {
2036             log_info(_("you can only make detached or clear signatures "
2037                        "while in --pgp2 mode\n"));
2038             unusable=1;
2039           }
2040         else if(cmd==aSignEncr || cmd==aSignSym)
2041           {
2042             log_info(_("you can't sign and encrypt at the "
2043                        "same time while in --pgp2 mode\n"));
2044             unusable=1;
2045           }
2046         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2047           {
2048             log_info(_("you must use files (and not a pipe) when "
2049                        "working with --pgp2 enabled.\n"));
2050             unusable=1;
2051           }
2052         else if(cmd==aEncr || cmd==aSym)
2053           {
2054             /* Everything else should work without IDEA (except using
2055                a secret key encrypted with IDEA and setting an IDEA
2056                preference, but those have their own error
2057                messages). */
2058
2059             if(openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
2060               {
2061                 log_info(_("encrypting a message in --pgp2 mode requires "
2062                            "the IDEA cipher\n"));
2063                 idea_cipher_warn(1);
2064                 unusable=1;
2065               }
2066             else if(cmd==aSym)
2067               {
2068                 /* This only sets IDEA for symmetric encryption
2069                    since it is set via select_algo_from_prefs for
2070                    pk encryption. */
2071                 xfree (def_cipher_string);
2072                 def_cipher_string = xstrdup ("idea");
2073               }
2074
2075             /* PGP2 can't handle the output from the textmode
2076                filter, so we disable it for anything that could
2077                create a literal packet (only encryption and
2078                symmetric encryption, since we disable signing
2079                above). */
2080             if(!unusable)
2081               opt.textmode=0;
2082           }
2083
2084         if(unusable)
2085           compliance_failure();
2086         else
2087           {
2088             opt.force_mdc = 0;
2089             opt.disable_mdc = 1;
2090             opt.force_v4_certs = 0;
2091             opt.sk_comments = 0;
2092             opt.escape_from = 1;
2093             opt.force_v3_sigs = 1;
2094             opt.pgp2_workarounds = 1;
2095             opt.ask_sig_expire = 0;
2096             opt.ask_cert_expire = 0;
2097             xfree (def_digest_string);
2098             def_digest_string = xstrdup ("md5");
2099             opt.def_compress_algo = 1;
2100           }
2101       }
2102     else if(PGP6)
2103       {
2104         opt.sk_comments=0;
2105         opt.escape_from=1;
2106         opt.force_v3_sigs=1;
2107         opt.ask_sig_expire=0;
2108         opt.force_mdc=0;
2109         opt.disable_mdc=1;
2110       }
2111     else if(PGP7)
2112       {
2113         opt.sk_comments=0;
2114         opt.escape_from=1;
2115         opt.force_v3_sigs=1;
2116         opt.ask_sig_expire=0;
2117       }
2118     else if(PGP8)
2119       {
2120         opt.escape_from=1;
2121       }
2122
2123     /* must do this after dropping setuid, because string_to...
2124      * may try to load an module */
2125     if( def_cipher_string ) {
2126         opt.def_cipher_algo = gcry_cipher_map_name (def_cipher_string);
2127         if(opt.def_cipher_algo==0 &&
2128            (ascii_strcasecmp(def_cipher_string,"idea")==0
2129             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2130           idea_cipher_warn(1);
2131         xfree (def_cipher_string); def_cipher_string = NULL;
2132         if( openpgp_cipher_test_algo (opt.def_cipher_algo) )
2133             log_error(_("selected cipher algorithm is invalid\n"));
2134     }
2135     if( def_digest_string ) {
2136         opt.def_digest_algo = gcry_md_map_name (def_digest_string);
2137         xfree (def_digest_string); def_digest_string = NULL;
2138         if( openpgp_md_test_algo (opt.def_digest_algo) )
2139             log_error(_("selected digest algorithm is invalid\n"));
2140     }
2141     if( def_compress_string ) {
2142         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2143         xfree (def_compress_string); def_compress_string = NULL;
2144         if( check_compress_algo(opt.def_compress_algo) )
2145             log_error(_("selected compression algorithm is invalid\n"));
2146     }
2147     if( cert_digest_string ) {
2148         opt.cert_digest_algo = gcry_md_map_name (cert_digest_string);
2149         xfree (cert_digest_string); cert_digest_string = NULL;
2150         if( openpgp_md_test_algo(opt.cert_digest_algo) )
2151             log_error(_("selected certification digest algorithm is invalid\n"));
2152     }
2153     if( s2k_cipher_string ) {
2154         opt.s2k_cipher_algo = gcry_cipher_map_name (s2k_cipher_string);
2155         xfree (s2k_cipher_string); s2k_cipher_string = NULL;
2156         if( openpgp_cipher_test_algo (opt.s2k_cipher_algo) )
2157             log_error(_("selected cipher algorithm is invalid\n"));
2158     }
2159     if( s2k_digest_string ) {
2160         opt.s2k_digest_algo = gcry_md_map_name (s2k_digest_string);
2161         xfree (s2k_digest_string); s2k_digest_string = NULL;
2162         if( openpgp_md_test_algo (opt.s2k_digest_algo) )
2163             log_error(_("selected digest algorithm is invalid\n"));
2164     }
2165     if( opt.completes_needed < 1 )
2166         log_error(_("completes-needed must be greater than 0\n"));
2167     if( opt.marginals_needed < 2 )
2168         log_error(_("marginals-needed must be greater than 1\n"));
2169     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2170         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2171     switch( opt.s2k_mode ) {
2172       case 0:
2173         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2174         break;
2175       case 1: case 3: break;
2176       default:
2177         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2178     }
2179
2180     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2181       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2182
2183     /* This isn't actually needed, but does serve to error out if the
2184        string is invalid. */
2185     if(opt.def_preference_list &&
2186         keygen_set_std_prefs(opt.def_preference_list,0))
2187       log_error(_("invalid default preferences\n"));
2188
2189     /* We provide defaults for the personal digest list */
2190     if(!pers_digest_list)
2191       pers_digest_list="h2";
2192
2193     if(pers_cipher_list &&
2194        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2195       log_error(_("invalid personal cipher preferences\n"));
2196
2197     if(pers_digest_list &&
2198        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2199       log_error(_("invalid personal digest preferences\n"));
2200
2201     if(pers_compress_list &&
2202        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2203       log_error(_("invalid personal compress preferences\n"));
2204
2205     if( log_get_errorcount(0) )
2206         g10_exit(2);
2207
2208     /* Check our chosen algorithms against the list of legal
2209        algorithms. */
2210
2211     if(!GNUPG)
2212       {
2213         const char *badalg=NULL;
2214         preftype_t badtype=PREFTYPE_NONE;
2215
2216         if (opt.def_cipher_algo
2217             && !algo_available (PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2218           {
2219             badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
2220             badtype = PREFTYPE_SYM;
2221           }
2222         else if (opt.def_digest_algo
2223                 && !algo_available (PREFTYPE_HASH,opt.def_digest_algo,NULL))
2224           {
2225             badalg = gcry_md_algo_name (opt.def_digest_algo);
2226             badtype = PREFTYPE_HASH;
2227           }
2228         else if (opt.cert_digest_algo
2229                  && !algo_available (PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2230           {
2231             badalg = gcry_md_algo_name (opt.cert_digest_algo);
2232             badtype = PREFTYPE_HASH;
2233           }
2234         else if (opt.def_compress_algo!=-1
2235                  && !algo_available (PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2236           {
2237             badalg = compress_algo_to_string (opt.def_compress_algo);
2238             badtype = PREFTYPE_ZIP;
2239           }
2240
2241         if (badalg)
2242           {
2243             switch(badtype)
2244               {
2245               case PREFTYPE_SYM:
2246                 log_info(_("you may not use cipher algorithm \"%s\" "
2247                            "while in %s mode\n"),
2248                          badalg,compliance_option_string());
2249                 break;
2250               case PREFTYPE_HASH:
2251                 log_info(_("you may not use digest algorithm \"%s\" "
2252                            "while in %s mode\n"),
2253                          badalg,compliance_option_string());
2254                 break;
2255               case PREFTYPE_ZIP:
2256                 log_info(_("you may not use compression algorithm \"%s\" "
2257                            "while in %s mode\n"),
2258                          badalg,compliance_option_string());
2259                 break;
2260               default:
2261                 BUG();
2262               }
2263
2264             compliance_failure();
2265           }
2266       }
2267
2268     /* set the random seed file */
2269     if( use_random_seed ) {
2270         char *p = make_filename(opt.homedir, "random_seed", NULL );
2271         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
2272         xfree (p);
2273     }
2274
2275     if( !cmd && opt.fingerprint && !with_fpr ) {
2276         set_cmd( &cmd, aListKeys);
2277     }
2278
2279     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2280         if( cmd == aKModeC ) {
2281             opt.fingerprint = 1;
2282             cmd = aKMode;
2283         }
2284         opt.list_sigs = 0;
2285         if( opt.verbose > 2 )
2286             opt.check_sigs++;
2287         if( opt.verbose > 1 )
2288             opt.list_sigs++;
2289
2290         opt.verbose = opt.verbose > 1;
2291         g10_opt_verbose = opt.verbose;
2292     }
2293
2294     /* Compression algorithm 0 means no compression at all */
2295     if( opt.def_compress_algo == 0)
2296         opt.compress = 0;
2297
2298     /* kludge to let -sat generate a clear text signature */
2299     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2300         cmd = aClearsign;
2301
2302     if( opt.verbose > 1 )
2303         set_packet_list_mode(1);
2304
2305     /* Add the keyrings, but not for some special commands and not in
2306        case of "-kvv userid keyring".  Also avoid adding the secret
2307        keyring for a couple of commands to avoid unneeded access in
2308        case the secrings are stored on a floppy */
2309     if( cmd != aDeArmor && cmd != aEnArmor
2310         && !(cmd == aKMode && argc == 2 ) ) 
2311       {
2312         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2313             && cmd != aVerify && cmd != aVerifyFiles
2314             && cmd != aSym)
2315           {
2316             if (!sec_nrings || default_keyring) /* add default secret rings */
2317               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2318             for (sl = sec_nrings; sl; sl = sl->next)
2319               keydb_add_resource ( sl->d, 0, 1 );
2320           }
2321         if( !nrings || default_keyring )  /* add default ring */
2322             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2323         for(sl = nrings; sl; sl = sl->next )
2324             keydb_add_resource ( sl->d, sl->flags, 0 );
2325       }
2326     FREE_STRLIST(nrings);
2327     FREE_STRLIST(sec_nrings);
2328
2329
2330     if( pwfd != -1 )  /* read the passphrase now. */
2331         read_passphrase_from_fd( pwfd );
2332
2333     fname = argc? *argv : NULL;
2334
2335     switch( cmd ) {
2336       case aPrimegen:
2337       case aPrintMD:
2338       case aPrintMDs:
2339       case aGenRandom:
2340       case aDeArmor:
2341       case aEnArmor:
2342       case aFixTrustDB:
2343       case aCardStatus:
2344       case aChangePIN:
2345         break;
2346       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2347       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2348       default: rc = setup_trustdb(1, trustdb_name ); break;
2349     }
2350     if( rc )
2351         log_error(_("failed to initialize the TrustDB: %s\n"), gpg_strerror (rc));
2352
2353
2354     switch (cmd) {
2355       case aStore: 
2356       case aSym:  
2357       case aSign: 
2358       case aSignSym: 
2359       case aClearsign: 
2360         if (!opt.quiet && any_explicit_recipient)
2361           log_info (_("WARNING: recipients (-r) given "
2362                       "without using public key encryption\n"));
2363         break;
2364       default:
2365         break;
2366     }
2367
2368     switch( cmd ) {
2369       case aStore: /* only store the file */
2370         if( argc > 1 )
2371             wrong_args(_("--store [filename]"));
2372         if( (rc = encode_store(fname)) )
2373             log_error ("\b%s: store failed: %s\n",
2374                        print_fname_stdin(fname), gpg_strerror (rc) );
2375         break;
2376       case aSym: /* encrypt the given file only with the symmetric cipher */
2377         if( argc > 1 )
2378             wrong_args(_("--symmetric [filename]"));
2379         if( (rc = encode_symmetric(fname)) )
2380             log_error ("\b%s: symmetric encryption failed: %s\n",
2381                        print_fname_stdin(fname), gpg_strerror (rc) );
2382         break;
2383
2384       case aEncr: /* encrypt the given file */
2385         if( argc > 1 )
2386             wrong_args(_("--encrypt [filename]"));
2387         if( (rc = encode_crypt(fname,remusr)) )
2388             log_error("%s: encryption failed: %s\n",
2389                       print_fname_stdin(fname), gpg_strerror (rc) );
2390         break;
2391
2392       case aEncrFiles: /* encrypt the given files */
2393         encode_crypt_files(argc, argv, remusr);
2394         break;
2395           
2396       case aSign: /* sign the given file */
2397         sl = NULL;
2398         if( detached_sig ) { /* sign all files */
2399             for( ; argc; argc--, argv++ )
2400                 add_to_strlist( &sl, *argv );
2401         }
2402         else {
2403             if( argc > 1 )
2404                 wrong_args(_("--sign [filename]"));
2405             if( argc ) {
2406                 sl = xcalloc (1, sizeof *sl + strlen(fname));
2407                 strcpy(sl->d, fname);
2408             }
2409         }
2410         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2411             log_error("signing failed: %s\n", gpg_strerror (rc) );
2412         free_strlist(sl);
2413         break;
2414
2415       case aSignEncr: /* sign and encrypt the given file */
2416         if( argc > 1 )
2417             wrong_args(_("--sign --encrypt [filename]"));
2418         if( argc ) {
2419             sl = xcalloc (1, sizeof *sl + strlen(fname));
2420             strcpy(sl->d, fname);
2421         }
2422         else
2423             sl = NULL;
2424         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2425             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), gpg_strerror (rc) );
2426         free_strlist(sl);
2427         break;
2428
2429       case aSignSym: /* sign and conventionally encrypt the given file */
2430         if (argc > 1)
2431             wrong_args(_("--sign --symmetric [filename]"));
2432         rc = sign_symencrypt_file (fname, locusr);
2433         if (rc)
2434             log_error("%s: sign+symmetric failed: %s\n",
2435                       print_fname_stdin(fname), gpg_strerror (rc) );
2436         break;
2437
2438       case aClearsign: /* make a clearsig */
2439         if( argc > 1 )
2440             wrong_args(_("--clearsign [filename]"));
2441         if( (rc = clearsign_file(fname, locusr, NULL)) )
2442             log_error("%s: clearsign failed: %s\n",
2443                       print_fname_stdin(fname), gpg_strerror (rc) );
2444         break;
2445
2446       case aVerify:
2447         if( (rc = verify_signatures( argc, argv ) ))
2448             log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
2449         break;
2450
2451       case aVerifyFiles:
2452         if( (rc = verify_files( argc, argv ) ))
2453             log_error("verify files failed: %s\n", gpg_strerror (rc) );
2454         break;
2455
2456       case aDecrypt:
2457         if( argc > 1 )
2458             wrong_args(_("--decrypt [filename]"));
2459         if( (rc = decrypt_message( fname ) ))
2460             log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
2461         break;
2462
2463       case aDecryptFiles:
2464         decrypt_messages(argc, argv);
2465         break;
2466             
2467       case aSignKey: /* sign the key given as argument */
2468         if( argc != 1 )
2469             wrong_args(_("--sign-key user-id"));
2470         username = make_username( fname );
2471         keyedit_menu(fname, locusr, NULL, 1 );
2472         xfree (username);
2473         break;
2474
2475       case aLSignKey:
2476         if( argc != 1 )
2477             wrong_args(_("--lsign-key user-id"));
2478         username = make_username( fname );
2479         keyedit_menu(fname, locusr, NULL, 2 );
2480         xfree (username);
2481         break;
2482
2483       case aNRSignKey:
2484         if( argc != 1 )
2485             wrong_args(_("--nrsign-key user-id"));
2486         username = make_username( fname );
2487         keyedit_menu(fname, locusr, NULL, 3 );
2488         xfree (username);
2489         break;
2490
2491       case aNRLSignKey:
2492         if( argc != 1 )
2493             wrong_args(_("--nrlsign-key user-id"));
2494         username = make_username( fname );
2495         keyedit_menu(fname, locusr, NULL, 4 );
2496         xfree (username);
2497         break;
2498
2499       case aEditKey: /* Edit a key signature */
2500         if( !argc )
2501             wrong_args(_("--edit-key user-id [commands]"));
2502         username = make_username( fname );
2503         if( argc > 1 ) {
2504             sl = NULL;
2505             for( argc--, argv++ ; argc; argc--, argv++ )
2506                 append_to_strlist( &sl, *argv );
2507             keyedit_menu( username, locusr, sl, 0 );
2508             free_strlist(sl);
2509         }
2510         else
2511             keyedit_menu(username, locusr, NULL, 0 );
2512         xfree (username);
2513         break;
2514
2515       case aDeleteKeys:
2516       case aDeleteSecretKeys:
2517       case aDeleteSecretAndPublicKeys:
2518         sl = NULL;
2519         /* I'm adding these in reverse order as add_to_strlist2
2520            reverses them again, and it's easier to understand in the
2521            proper order :) */
2522         for( ; argc; argc-- )
2523           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2524         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2525         free_strlist(sl);
2526         break;
2527
2528       case aCheckKeys:
2529         opt.check_sigs = 1;
2530       case aListSigs:
2531         opt.list_sigs = 1;
2532       case aListKeys:
2533         sl = NULL;
2534         for( ; argc; argc--, argv++ )
2535             add_to_strlist2( &sl, *argv, utf8_strings );
2536         public_key_list( sl );
2537         free_strlist(sl);
2538         break;
2539       case aListSecretKeys:
2540         sl = NULL;
2541         for( ; argc; argc--, argv++ )
2542             add_to_strlist2( &sl, *argv, utf8_strings );
2543         secret_key_list( sl );
2544         free_strlist(sl);
2545         break;
2546
2547       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2548         if( argc < 2 ) { /* -kv [userid] */
2549             sl = NULL;
2550             if (argc && **argv)
2551                 add_to_strlist2( &sl, *argv, utf8_strings );
2552             public_key_list( sl );
2553             free_strlist(sl);
2554         }
2555         else if( argc == 2 ) { /* -kv userid keyring */
2556             if( access( argv[1], R_OK ) ) {
2557                 log_error(_("can't open %s: %s\n"),
2558                                print_fname_stdin(argv[1]), strerror(errno));
2559             }
2560             else {
2561                 /* add keyring (default keyrings are not registered in this
2562                  * special case */
2563                 keydb_add_resource( argv[1], 0, 0 );
2564                 sl = NULL;
2565                 if (**argv)
2566                     add_to_strlist2( &sl, *argv, utf8_strings );
2567                 public_key_list( sl );
2568                 free_strlist(sl);
2569             }
2570         }
2571         else
2572             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2573         break;
2574
2575       case aKeygen: /* generate a key */
2576         if( opt.batch ) {
2577             if( argc > 1 )
2578                 wrong_args("--gen-key [parameterfile]");
2579             generate_keypair( argc? *argv : NULL );
2580         }
2581         else {
2582             if( argc )
2583                 wrong_args("--gen-key");
2584             generate_keypair(NULL);
2585         }
2586         break;
2587
2588       case aFastImport:
2589         opt.import_options |= IMPORT_FAST_IMPORT;
2590       case aImport:
2591         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2592         break;
2593
2594       case aExport:
2595       case aExportAll:
2596       case aSendKeys:
2597       case aRecvKeys:
2598         sl = NULL;
2599         for( ; argc; argc--, argv++ )
2600             add_to_strlist2( &sl, *argv, utf8_strings );
2601         if( cmd == aSendKeys )
2602             rc=keyserver_export( sl );
2603         else if( cmd == aRecvKeys )
2604             rc=keyserver_import( sl );
2605         else
2606             rc=export_pubkeys( sl, opt.export_options );
2607         if(rc)
2608           {
2609             if(cmd==aSendKeys)
2610               log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
2611             else if(cmd==aRecvKeys)
2612               log_error(_("keyserver receive failed: %s\n"),gpg_strerror (rc));
2613             else
2614               log_error(_("key export failed: %s\n"),gpg_strerror (rc));
2615           }
2616         free_strlist(sl);
2617         break;
2618
2619      case aSearchKeys:
2620         sl = NULL;
2621         for( ; argc; argc--, argv++ )
2622           {
2623             if (utf8_strings)
2624               sl = append_to_strlist ( &sl, *argv );
2625             else
2626               {
2627                 char *p = native_to_utf8 ( *argv );
2628                 sl = append_to_strlist( &sl, p );
2629                 xfree( p );
2630               }
2631           }
2632
2633         rc=keyserver_search( sl );
2634         if(rc)
2635           log_error(_("keyserver search failed: %s\n"),gpg_strerror (rc));
2636         free_strlist(sl);
2637         break;
2638
2639       case aRefreshKeys:
2640         sl = NULL;
2641         for( ; argc; argc--, argv++ )
2642             add_to_strlist2( &sl, *argv, utf8_strings );
2643         rc=keyserver_refresh(sl);
2644         if(rc)
2645           log_error(_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
2646         free_strlist(sl);
2647         break;
2648
2649       case aExportSecret:
2650         sl = NULL;
2651         for( ; argc; argc--, argv++ )
2652             add_to_strlist2( &sl, *argv, utf8_strings );
2653         export_seckeys( sl );
2654         free_strlist(sl);
2655         break;
2656
2657       case aExportSecretSub:
2658         sl = NULL;
2659         for( ; argc; argc--, argv++ )
2660             add_to_strlist2( &sl, *argv, utf8_strings );
2661         export_secsubkeys( sl );
2662         free_strlist(sl);
2663         break;
2664
2665       case aGenRevoke:
2666         if( argc != 1 )
2667             wrong_args("--gen-revoke user-id");
2668         username =  make_username(*argv);
2669         gen_revoke( username );
2670         xfree ( username );
2671         break;
2672
2673       case aDesigRevoke:
2674         if( argc != 1 )
2675             wrong_args("--desig-revoke user-id");
2676         username =  make_username(*argv);
2677         gen_desig_revoke( username );
2678         xfree ( username );
2679         break;
2680
2681       case aDeArmor:
2682         if( argc > 1 )
2683             wrong_args("--dearmor [file]");
2684         rc = dearmor_file( argc? *argv: NULL );
2685         if( rc )
2686             log_error(_("dearmoring failed: %s\n"), gpg_strerror (rc));
2687         break;
2688
2689       case aEnArmor:
2690         if( argc > 1 )
2691             wrong_args("--enarmor [file]");
2692         rc = enarmor_file( argc? *argv: NULL );
2693         if( rc )
2694             log_error(_("enarmoring failed: %s\n"), gpg_strerror (rc));
2695         break;
2696
2697
2698       case aPrimegen:
2699 #if 0 /*FIXME-XXX*/
2700         {   int mode = argc < 2 ? 0 : atoi(*argv);
2701
2702             if( mode == 1 && argc == 2 ) {
2703                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2704             }
2705             else if( mode == 2 && argc == 3 ) {
2706                 mpi_print( stdout, generate_elg_prime(
2707                                              0, atoi(argv[1]),
2708                                              atoi(argv[2]), NULL,NULL ), 1);
2709             }
2710             else if( mode == 3 && argc == 3 ) {
2711                 gcry_mpi_t *factors;
2712                 mpi_print( stdout, generate_elg_prime(
2713                                              1, atoi(argv[1]),
2714                                              atoi(argv[2]), NULL,&factors ), 1);
2715                 putchar('\n');
2716                 mpi_print( stdout, factors[0], 1 ); /* print q */
2717             }
2718             else if( mode == 4 && argc == 3 ) {
2719                 gcry_mpi_t g = mpi_alloc(1);
2720                 mpi_print( stdout, generate_elg_prime(
2721                                                  0, atoi(argv[1]),
2722                                                  atoi(argv[2]), g, NULL ), 1);
2723                 putchar('\n');
2724                 mpi_print( stdout, g, 1 );
2725                 mpi_free(g);
2726             }
2727             else
2728                 wrong_args("--gen-prime mode bits [qbits] ");
2729             putchar('\n');
2730         }
2731 #endif
2732         break;
2733
2734       case aGenRandom:
2735         {
2736             int level = argc ? atoi(*argv):0;
2737             int count = argc > 1 ? atoi(argv[1]): 0;
2738             int endless = !count;
2739
2740             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2741                 wrong_args("--gen-random 0|1|2 [count]");
2742
2743             while( endless || count ) {
2744                 byte *p;
2745                 /* Wee need a multiple of 3, so that in case of
2746                    armored output we get a correct string.  No
2747                    linefolding is done, as it is best to levae this to
2748                    other tools */
2749                 size_t n = !endless && count < 99? count : 99;
2750
2751                 p = gcry_random_bytes (n, level);
2752 #ifdef HAVE_DOSISH_SYSTEM
2753                 setmode ( fileno(stdout), O_BINARY );
2754 #endif
2755                 if (opt.armor) {
2756                     char *tmp = make_radix64_string (p, n);
2757                     fputs (tmp, stdout);
2758                     xfree (tmp);
2759                     if (n%3 == 1)
2760                       putchar ('=');
2761                     if (n%3)
2762                       putchar ('=');
2763                 } else {
2764                     fwrite( p, n, 1, stdout );
2765                 }
2766                 xfree (p);
2767                 if( !endless )
2768                     count -= n;
2769             }
2770             if (opt.armor)
2771                 putchar ('\n');
2772         }
2773         break;
2774
2775       case aPrintMD:
2776         if( argc < 1)
2777             wrong_args("--print-md algo [files]");
2778         {
2779             int all_algos = (**argv=='*' && !(*argv)[1]);
2780             int algo = all_algos? 0 : gcry_md_map_name (*argv);
2781
2782             if( !algo && !all_algos )
2783                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2784             else {
2785                 argc--; argv++;
2786                 if( !argc )
2787                     print_mds(NULL, algo);
2788                 else {
2789                     for(; argc; argc--, argv++ )
2790                         print_mds(*argv, algo);
2791                 }
2792             }
2793         }
2794         break;
2795
2796       case aPrintMDs: /* old option */
2797         if( !argc )
2798             print_mds(NULL,0);
2799         else {
2800             for(; argc; argc--, argv++ )
2801                 print_mds(*argv,0);
2802         }
2803         break;
2804
2805       case aListTrustDB:
2806         if( !argc )
2807             list_trustdb(NULL);
2808         else {
2809             for( ; argc; argc--, argv++ )
2810                 list_trustdb( *argv );
2811         }
2812         break;
2813
2814       case aUpdateTrustDB:
2815         if( argc )
2816             wrong_args("--update-trustdb");
2817         update_trustdb();
2818         break;
2819
2820       case aCheckTrustDB:
2821         /* Old versions allowed for arguments - ignore them */
2822         check_trustdb();
2823         break;
2824
2825       case aFixTrustDB:
2826         log_error("this command is not yet implemented.\n");
2827         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2828         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2829         break;
2830
2831       case aListTrustPath:
2832         if( !argc )
2833             wrong_args("--list-trust-path <user-ids>");
2834         for( ; argc; argc--, argv++ ) {
2835             username = make_username( *argv );
2836             list_trust_path( username );
2837             xfree (username);
2838         }
2839         break;
2840
2841       case aExportOwnerTrust:
2842         if( argc )
2843             wrong_args("--export-ownertrust");
2844         export_ownertrust();
2845         break;
2846
2847       case aImportOwnerTrust:
2848         if( argc > 1 )
2849             wrong_args("--import-ownertrust [file]");
2850         import_ownertrust( argc? *argv:NULL );
2851         break;
2852       
2853       case aPipeMode:
2854         if ( argc )
2855             wrong_args ("--pipemode");
2856         run_in_pipemode ();
2857         break;
2858
2859       case aRebuildKeydbCaches:
2860         if (argc)
2861             wrong_args ("--rebuild-keydb-caches");
2862         keydb_rebuild_caches ();
2863         break;
2864
2865     case aCardStatus:
2866       if (argc)
2867         wrong_args ("--card-status");
2868       card_status (stdout);
2869       break;
2870
2871     case aChangePIN:
2872       if (!argc)
2873         change_pin (0);
2874       else if (argc == 1)
2875         change_pin ( atoi (*argv));
2876       else
2877         wrong_args ("--change-pin [no]");
2878       break;
2879
2880       case aListPackets:
2881         opt.list_packets=2;
2882       default:
2883         if( argc > 1 )
2884             wrong_args(_("[filename]"));
2885         /* Issue some output for the unix newbie */
2886         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2887                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2888             log_info(_("Go ahead and type your message ...\n"));
2889
2890         if( !(a = iobuf_open(fname)) )
2891             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2892         else {
2893
2894             if( !opt.no_armor ) {
2895                 if( use_armor_filter( a ) ) {
2896                     memset( &afx, 0, sizeof afx);
2897                     iobuf_push_filter( a, armor_filter, &afx );
2898                 }
2899             }
2900             if( cmd == aListPackets ) {
2901                 set_packet_list_mode(1);
2902                 opt.list_packets=1;
2903             }
2904             rc = proc_packets(NULL, a );
2905             if( rc )
2906                 log_error("processing message failed: %s\n", gpg_strerror (rc) );
2907             iobuf_close(a);
2908         }
2909         break;
2910     }
2911
2912     /* cleanup */
2913     FREE_STRLIST(remusr);
2914     FREE_STRLIST(locusr);
2915     g10_exit(0);
2916     return 8; /*NEVER REACHED*/
2917 }
2918
2919 /* Note: This function is used by signal handlers!. */
2920 static void
2921 emergency_cleanup (void)
2922 {
2923   gcry_control (GCRYCTL_TERM_SECMEM );
2924 }
2925
2926
2927 void
2928 g10_exit( int rc )
2929 {
2930   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
2931   if (opt.debug & DBG_MEMSTAT_VALUE)
2932     {
2933       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
2934       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
2935     }
2936   if (opt.debug)
2937     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
2938   emergency_cleanup ();
2939   rc = rc? rc : log_get_errorcount(0)? 2 :
2940        g10_errors_seen? 1 : 0;
2941   exit (rc );
2942 }
2943
2944
2945 /* Pretty-print hex hashes.  This assumes at least an 80-character
2946    display, but there are a few other similar assumptions in the
2947    display code. */
2948 static void
2949 print_hex( MD_HANDLE md, int algo, const char *fname )
2950 {
2951   int i,n,count,indent=0;
2952   const byte *p;
2953
2954   if(fname)
2955     indent=printf("%s: ",fname);
2956
2957   if(indent>40)
2958     {
2959       printf("\n");
2960       indent=0;
2961     }
2962
2963   if(algo==DIGEST_ALGO_RMD160)
2964     indent+=printf("RMD160 = ");
2965   else if(algo==DIGEST_ALGO_TIGER)
2966     indent+=printf(" TIGER = ");
2967   else if(algo>0)
2968     indent+=printf("%6s = ", gcry_md_algo_name (algo));
2969   else
2970     algo=abs(algo);
2971
2972   count=indent;
2973
2974   p = gcry_md_read (md, algo);
2975   n = gcry_md_get_algo_dlen (algo);
2976
2977   count+=printf("%02X",*p++);
2978
2979   for(i=1;i<n;i++,p++)
2980     {
2981       if(n==16)
2982         {
2983           if(count+2>79)
2984             {
2985               printf("\n%*s",indent," ");
2986               count=indent;
2987             }
2988           else
2989             count+=printf(" ");
2990
2991           if(!(i%8))
2992             count+=printf(" ");
2993         }
2994       else if (n==20)
2995         {
2996           if(!(i%2))
2997             {
2998               if(count+4>79)
2999                 {
3000                   printf("\n%*s",indent," ");
3001                   count=indent;
3002                 }
3003               else
3004                 count+=printf(" ");
3005             }
3006
3007           if(!(i%10))
3008             count+=printf(" ");
3009         }
3010       else
3011         {
3012           if(!(i%4))
3013             {
3014               if(count+8>79)
3015                 {
3016                   printf("\n%*s",indent," ");
3017                   count=indent;
3018                 }
3019               else
3020                 count+=printf(" ");
3021             }
3022         }
3023
3024       count+=printf("%02X",*p);
3025     }
3026
3027   printf("\n");
3028 }
3029
3030 static void
3031 print_hashline( MD_HANDLE md, int algo, const char *fname )
3032 {
3033     int i, n;
3034     const byte *p;
3035     
3036     if ( fname ) {
3037         for (p = fname; *p; p++ ) {
3038             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3039                 printf("%%%02X", *p );
3040             else 
3041                 putchar( *p );
3042         }
3043     }
3044     putchar(':');
3045     printf("%d:", algo );
3046     p = gcry_md_read (md, algo );
3047     n = gcry_md_get_algo_dlen (algo);
3048     for(i=0; i < n ; i++, p++ ) 
3049         printf("%02X", *p );
3050     putchar(':');
3051     putchar('\n');
3052 }
3053
3054 static void
3055 print_mds( const char *fname, int algo )
3056 {
3057     FILE *fp;
3058     char buf[1024];
3059     size_t n;
3060     MD_HANDLE md;
3061
3062     if( !fname ) {
3063         fp = stdin;
3064 #ifdef HAVE_DOSISH_SYSTEM
3065         setmode ( fileno(fp) , O_BINARY );
3066 #endif
3067     }
3068     else {
3069         fp = fopen( fname, "rb" );
3070     }
3071     if( !fp ) {
3072         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3073         return;
3074     }
3075
3076     gcry_md_open (&md, 0, 0 );
3077     if( algo )
3078         gcry_md_enable ( md, algo );
3079     else {
3080         gcry_md_enable (md, GCRY_MD_MD5 );
3081         gcry_md_enable (md, GCRY_MD_SHA1 );
3082         gcry_md_enable (md, GCRY_MD_RMD160 );
3083 #ifdef USE_TIGER192
3084         gcry_md_enable (md, GCRY_MD_TIGER );
3085 #endif
3086 #ifdef USE_SHA256
3087         gcry_md_enable (md, GCRY_MD_SHA256 );
3088 #endif
3089 #ifdef USE_SHA512
3090         gcry_md_enable (md, GCRY_MD_SHA384 );
3091         gcry_md_enable (md, GCRY_MD_SHA512 );
3092 #endif
3093     }
3094
3095     while( (n=fread( buf, 1, DIM(buf), fp )) )
3096         gcry_md_write (md, buf, n);
3097     if( ferror(fp) )
3098         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3099     else {
3100         gcry_md_final (md);
3101         if ( opt.with_colons ) {
3102             if ( algo ) 
3103                 print_hashline( md, algo, fname );
3104             else {
3105                 print_hashline( md, GCRY_MD_MD5, fname );
3106                 print_hashline( md, GCRY_MD_SHA1, fname );
3107                 print_hashline( md, GCRY_MD_RMD160, fname );
3108 #ifdef USE_TIGER192
3109                 print_hashline( md, GCRY_MD_TIGER, fname );
3110 #endif
3111 #ifdef USE_SHA256
3112                 print_hashline( md, GCRY_MD_SHA256, fname );
3113 #endif
3114 #ifdef USE_SHA512
3115                 print_hashline( md, GCRY_MD_SHA384, fname );
3116                 print_hashline( md, GCRY_MD_SHA512, fname );
3117 #endif
3118             }
3119         }
3120         else {
3121             if( algo )
3122                print_hex(md,-algo,fname);
3123             else {
3124                 print_hex( md, GCRY_MD_MD5, fname );
3125                 print_hex( md, GCRY_MD_SHA1, fname );
3126                 print_hex( md, GCRY_MD_RMD160, fname );
3127 #ifdef USE_TIGER192
3128                 print_hex( md, GCRY_MD_TIGER, fname );
3129 #endif
3130 #ifdef USE_SHA256
3131                 print_hex( md, GCRY_MD_SHA256, fname );
3132 #endif
3133 #ifdef USE_SHA512
3134                 print_hex( md, GCRY_MD_SHA384, fname );
3135                 print_hex( md, GCRY_MD_SHA512, fname );
3136 #endif
3137             }
3138         }
3139     }
3140     gcry_md_close (md);
3141
3142     if( fp != stdin )
3143         fclose(fp);
3144 }
3145
3146
3147 /****************
3148  * Check the supplied name,value string and add it to the notation
3149  * data to be used for signatures.  which==0 for sig notations, and 1
3150  * for cert notations.
3151 */
3152 static void
3153 add_notation_data( const char *string, int which )
3154 {
3155     const char *s;
3156     STRLIST sl,*notation_data;
3157     int critical=0;
3158     int highbit=0;
3159     int saw_at=0;
3160
3161     if(which)
3162       notation_data=&opt.cert_notation_data;
3163     else
3164       notation_data=&opt.sig_notation_data;
3165
3166     if( *string == '!' ) {
3167         critical = 1;
3168         string++;
3169     }
3170
3171     /* If and when the IETF assigns some official name tags, we'll
3172        have to add them here. */
3173
3174     for( s=string ; *s != '='; s++ )
3175       {
3176         if( *s=='@')
3177           saw_at=1;
3178
3179         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3180           {
3181             log_error(_("a notation name must have only printable characters "
3182                         "or spaces, and end with an '='\n") );
3183             return;
3184           }
3185       }
3186
3187     if(!saw_at && !opt.expert)
3188       {
3189         log_error(
3190                 _("a user notation name must contain the '@' character\n"));
3191         return;
3192       }
3193
3194     /* we only support printable text - therefore we enforce the use
3195      * of only printable characters (an empty value is valid) */
3196     for( s++; *s ; s++ ) {
3197         if( iscntrl(*s) ) {
3198             log_error(_("a notation value must not use "
3199                         "any control characters\n") );
3200             return;
3201         }
3202         else if( *s & 0x80 )
3203             highbit = 1;
3204     }
3205
3206     if( highbit )   /* must use UTF8 encoding */
3207         sl = add_to_strlist2( notation_data, string, utf8_strings );
3208     else
3209         sl = add_to_strlist( notation_data, string );
3210
3211     if( critical )
3212         sl->flags |= 1;
3213 }
3214
3215
3216 static void
3217 add_policy_url( const char *string, int which )
3218 {
3219   int i,critical=0;
3220   STRLIST sl;
3221
3222   if(*string=='!')
3223     {
3224       string++;
3225       critical=1;
3226     }
3227
3228   for(i=0;i<strlen(string);i++)
3229     if(string[i]&0x80 || iscntrl(string[i]))
3230       break;
3231
3232   if(i==0 || i<strlen(string))
3233     {
3234       if(which)
3235         log_error(_("the given certification policy URL is invalid\n"));
3236       else
3237         log_error(_("the given signature policy URL is invalid\n"));
3238     }
3239
3240   if(which)
3241     sl=add_to_strlist( &opt.cert_policy_url, string );
3242   else
3243     sl=add_to_strlist( &opt.sig_policy_url, string );
3244
3245   if(critical)
3246     sl->flags |= 1;    
3247 }