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