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