* photoid.c (get_default_photo_command, show_photos): Honor
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998,1999,2000,2001,2002 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 #ifdef HAVE_DOSISH_SYSTEM
29   #include <fcntl.h> /* for setmode() */
30 #endif
31
32 #define INCLUDED_BY_MAIN_MODULE 1
33 #include "packet.h"
34 #include "iobuf.h"
35 #include "memory.h"
36 #include "util.h"
37 #include "main.h"
38 #include "options.h"
39 #include "keydb.h"
40 #include "trustdb.h"
41 #include "mpi.h"
42 #include "cipher.h"
43 #include "filter.h"
44 #include "ttyio.h"
45 #include "i18n.h"
46 #include "status.h"
47 #include "g10defs.h"
48 #include "keyserver-internal.h"
49 #include "exec.h"
50
51 enum cmd_and_opt_values { aNull = 0,
52     oArmor        = 'a',
53     aDetachedSign = 'b',
54     aSym          = 'c',
55     aDecrypt      = 'd',
56     aEncr         = 'e',
57     aEncrFiles,
58     oInteractive  = 'i',
59     oKOption      = 'k',
60     oDryRun       = 'n',
61     oOutput       = 'o',
62     oQuiet        = 'q',
63     oRecipient    = 'r',
64     aSign         = 's',
65     oTextmodeShort= 't',
66     oUser         = 'u',
67     oVerbose      = 'v',
68     oCompress     = 'z',
69     oNotation     = 'N',
70     oBatch        = 500,
71     oSigNotation,
72     oCertNotation,
73     oShowNotation,
74     oNoShowNotation,
75     aDecryptFiles,                          
76     aClearsign,
77     aStore,
78     aKeygen,
79     aSignEncr,
80     aSignSym,
81     aSignKey,
82     aLSignKey,
83     aNRSignKey,
84     aNRLSignKey,
85     aListPackets,
86     aEditKey,
87     aDeleteKeys,
88     aDeleteSecretKeys,
89     aDeleteSecretAndPublicKeys,
90     aKMode,
91     aKModeC,
92     aImport,
93     aFastImport,
94     aVerify,
95     aVerifyFiles,
96     aListKeys,
97     aListSigs,
98     aListSecretKeys,
99     aSendKeys,
100     aRecvKeys,
101     aSearchKeys,
102     aExport,
103     aExportAll,
104     aExportSecret,
105     aExportSecretSub,
106     aCheckKeys,
107     aGenRevoke,
108     aDesigRevoke,
109     aPrimegen,
110     aPrintMD,
111     aPrintMDs,
112     aCheckTrustDB,
113     aUpdateTrustDB,
114     aFixTrustDB,
115     aListTrustDB,
116     aListTrustPath,
117     aExportOwnerTrust,
118     aImportOwnerTrust,
119     aDeArmor,
120     aEnArmor,
121     aGenRandom,
122     aPipeMode,
123     aRebuildKeydbCaches,
124     aRefreshKeys,
125
126     oTextmode,
127     oExpert,
128     oNoExpert,
129     oAskSigExpire,
130     oNoAskSigExpire,
131     oAskCertExpire,
132     oNoAskCertExpire,
133     oFingerprint,
134     oWithFingerprint,
135     oAnswerYes,
136     oAnswerNo,
137     oDefCertCheckLevel,
138     oKeyring,
139     oSecretKeyring,
140     oShowKeyring,
141     oDefaultKey,
142     oDefRecipient,
143     oDefRecipientSelf,
144     oNoDefRecipient,
145     oOptions,
146     oDebug,
147     oDebugAll,
148     oStatusFD,
149 #ifdef __riscos__
150     oStatusFile,
151 #endif /* __riscos__ */
152     oAttributeFD,
153 #ifdef __riscos__
154     oAttributeFile,
155 #endif /* __riscos__ */
156     oSKComments,
157     oNoSKComments,
158     oNoVersion,
159     oEmitVersion,
160     oCompletesNeeded,
161     oMarginalsNeeded,
162     oMaxCertDepth,
163     oLoadExtension,
164     oRFC1991,
165     oOpenPGP,
166     oPGP2,
167     oNoPGP2,
168     oPGP6,
169     oNoPGP6,
170     oPGP7,
171     oNoPGP7,
172     oCipherAlgo,
173     oDigestAlgo,
174     oCertDigestAlgo,
175     oCompressAlgo,
176     oPasswdFD,
177 #ifdef __riscos__
178     oPasswdFile,
179 #endif /* __riscos__ */
180     oCommandFD,
181 #ifdef __riscos__
182     oCommandFile,
183 #endif /* __riscos__ */
184     oQuickRandom,
185     oNoVerbose,
186     oTrustDBName,
187     oNoSecmemWarn,
188     oNoPermissionWarn,
189     oNoArmor,
190     oNoDefKeyring,
191     oNoGreeting,
192     oNoTTY,
193     oNoOptions,
194     oNoBatch,
195     oHomedir,
196     oWithColons,
197     oWithKeyData,
198     oSkipVerify,
199     oCompressKeys,
200     oCompressSigs,
201     oAlwaysTrust,
202     oEmuChecksumBug,
203     oRunAsShmCP,
204     oSetFilename,
205     oForYourEyesOnly,
206     oNoForYourEyesOnly,
207     oSetPolicyURL,
208     oSigPolicyURL,
209     oCertPolicyURL,
210     oShowPolicyURL,
211     oNoShowPolicyURL,
212     oUseEmbeddedFilename,
213     oComment,
214     oDefaultComment,
215     oThrowKeyid,
216     oShowPhotos,
217     oNoShowPhotos,
218     oPhotoViewer,
219     oForceV3Sigs,
220     oNoForceV3Sigs,
221     oForceV4Certs,
222     oNoForceV4Certs,
223     oForceMDC,
224     oNoForceMDC,
225     oDisableMDC,
226     oNoDisableMDC,
227     oS2KMode,
228     oS2KDigest,
229     oS2KCipher,
230     oSimpleSKChecksum,                          
231     oCharset,
232     oNotDashEscaped,
233     oEscapeFrom,
234     oNoEscapeFrom,
235     oLockOnce,
236     oLockMultiple,
237     oLockNever,
238     oKeyServer,
239     oKeyServerOptions,
240     oTempDir,
241     oExecPath,
242     oEncryptTo,
243     oNoEncryptTo,
244     oLoggerFD,
245 #ifdef __riscos__
246     oLoggerFile,
247 #endif /* __riscos__ */
248     oUtf8Strings,
249     oNoUtf8Strings,
250     oDisableCipherAlgo,
251     oDisablePubkeyAlgo,
252     oAllowNonSelfsignedUID,
253     oNoAllowNonSelfsignedUID,
254     oAllowFreeformUID,
255     oNoAllowFreeformUID,
256     oAllowSecretKeyImport,                      
257     oEnableSpecialFilenames,
258     oNoLiteral,
259     oSetFilesize,
260     oHonorHttpProxy,
261     oFastListMode,
262     oListOnly,
263     oIgnoreTimeConflict,
264     oIgnoreValidFrom,                         
265     oIgnoreCrcError,                          
266     oShowSessionKey,
267     oOverrideSessionKey,
268     oNoRandomSeedFile,
269     oAutoKeyRetrieve,
270     oNoAutoKeyRetrieve,
271     oUseAgent,
272     oNoUseAgent,
273     oGpgAgentInfo,
274     oMergeOnly,
275     oTryAllSecrets,
276     oTrustedKey,
277     oNoExpensiveTrustChecks,
278     oFixedListMode,
279     oNoSigCache,
280     oNoSigCreateCheck,
281     oAutoCheckTrustDB,
282     oNoAutoCheckTrustDB,
283     oPreservePermissions,
284     oDefaultPreferenceList,
285     oPersonalCipherPreferences,
286     oPersonalDigestPreferences,
287     oPersonalCompressPreferences,
288     oEmu3DESS2KBug,  /* will be removed in 1.1 */
289     oEmuMDEncodeBug,
290     oDisplay,
291     oTTYname,
292     oTTYtype,
293     oLCctype,
294     oLCmessages,
295     oGroup,
296 aTest };
297
298
299 static ARGPARSE_OPTS opts[] = {
300
301     { 300, NULL, 0, N_("@Commands:\n ") },
302
303     { aSign, "sign",      256, N_("|[file]|make a signature")},
304     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
305     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
306     { aEncr, "encrypt",   256, N_("encrypt data")},
307     { aEncrFiles, "encrypt-files", 256, N_("|[files]|encrypt files")},
308     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
309     { aStore, "store",     256, N_("store only")},
310     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
311     { aDecryptFiles, "decrypt-files", 256, N_("|[files]|decrypt files")},
312     { aVerify, "verify"   , 256, N_("verify a signature")},
313     { aVerifyFiles, "verify-files" , 256, "@" },
314     { aListKeys, "list-keys", 256, N_("list keys")},
315     { aListKeys, "list-public-keys", 256, "@" },
316     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
317     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
318     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
319     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
320     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
321     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
322     { aDeleteSecretKeys, "delete-secret-keys",256,
323                                     N_("remove keys from the secret keyring")},
324     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
325     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
326     { aNRSignKey, "nrsign-key"  ,256, N_("sign a key non-revocably")},
327     { aNRLSignKey, "nrlsign-key"  ,256, N_("sign a key locally and non-revocably")},
328     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
329     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
330     { aDesigRevoke, "desig-revoke",256, "@" },
331     { aExport, "export"           , 256, N_("export keys") },
332     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
333     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
334     { aSearchKeys, "search-keys" , 256,
335                                     N_("search for keys on a key server") },
336     { aRefreshKeys, "refresh-keys", 256,
337                                     N_("update all keys from a keyserver")},
338     { aExportAll, "export-all"    , 256, "@" },
339     { aExportSecret, "export-secret-keys" , 256, "@" },
340     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
341     { aImport, "import",      256     , N_("import/merge keys")},
342     { aFastImport, "fast-import",  256 , "@"},
343     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
344     { aExportOwnerTrust,
345               "export-ownertrust", 256, N_("export the ownertrust values")},
346     { aImportOwnerTrust,
347               "import-ownertrust", 256 , N_("import ownertrust values")},
348     { aUpdateTrustDB,
349               "update-trustdb",0 , N_("update the trust database")},
350     { aCheckTrustDB,
351               "check-trustdb",0 , N_("unattended trust database update")},
352     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
353     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
354     { aDeArmor, "dearmour", 256, "@" },
355     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
356     { aEnArmor, "enarmour", 256, "@" },
357     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
358     { aPrimegen, "gen-prime" , 256, "@" },
359     { aGenRandom, "gen-random" , 256, "@" },
360
361     { 301, NULL, 0, N_("@\nOptions:\n ") },
362
363     { oArmor, "armor",     0, N_("create ascii armored output")},
364     { oArmor, "armour",     0, "@" },
365     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
366     { oRecipient, "remote-user", 2, "@"},  /* old option name */
367     { oDefRecipient, "default-recipient" ,2,
368                                   N_("|NAME|use NAME as default recipient")},
369     { oDefRecipientSelf, "default-recipient-self" ,0,
370                                 N_("use the default key as default recipient")},
371     { oNoDefRecipient, "no-default-recipient", 0, "@" },
372     { oTempDir, "temp-directory", 2, "@" },
373     { oExecPath, "exec-path", 2, "@" },
374     { oEncryptTo, "encrypt-to", 2, "@" },
375     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
376     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
377     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
378     { oTextmodeShort, NULL,   0, "@"},
379     { oTextmode, "textmode",  0, N_("use canonical text mode")},
380     { oExpert, "expert",   0, "@"},
381     { oNoExpert, "no-expert",   0, "@"},
382     { oAskSigExpire, "ask-sig-expire",   0, "@"},
383     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
384     { oAskCertExpire, "ask-cert-expire",   0, "@"},
385     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
386     { oOutput, "output",    2, N_("use as output file")},
387     { oVerbose, "verbose",   0, N_("verbose") },
388     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
389     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
390     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
391     { oNoForceV3Sigs, "no-force-v3-sigs", 0, N_("do not force v3 signatures") },
392     { oForceV4Certs, "force-v4-certs", 0, N_("force v4 key signatures") },
393     { oNoForceV4Certs, "no-force-v4-certs", 0, N_("do not force v4 key signatures") },
394     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
395     { oNoForceMDC, "no-force-mdc", 0, "@" },
396     { oDisableMDC, "disable-mdc", 0, N_("never use a MDC for encryption") },
397     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
398     { oDryRun, "dry-run",   0, N_("do not make any changes") },
399   /*{ oInteractive, "interactive", 0, N_("prompt before overwriting") }, */
400     { oUseAgent, "use-agent",0, N_("use the gpg-agent")},
401     { oNoUseAgent, "no-use-agent",0, "@"},
402     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
403     { oBatch, "batch",     0, N_("batch mode: never ask")},
404     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
405     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
406     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
407     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
408     { oShowKeyring, "show-keyring", 0, N_("show which keyring a listed key is on")},
409     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
410     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
411     { oKeyServerOptions, "keyserver-options",2,"@"},
412     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
413     { oOptions, "options"   , 2, N_("read options from file")},
414
415     { oDebug, "debug"     ,4|16, "@"},
416     { oDebugAll, "debug-all" ,0, "@"},
417     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
418 #ifdef __riscos__
419     { oStatusFile, "status-file" ,2, N_("|[file]|write status info to file") },
420 #endif /* __riscos__ */
421     { oAttributeFD, "attribute-fd" ,1, "@" },
422 #ifdef __riscos__
423     { oAttributeFile, "attribute-file" ,2, "@" },
424 #endif /* __riscos__ */
425     { oNoSKComments, "no-comment", 0,   "@"},
426     { oNoSKComments, "no-sk-comments", 0,   "@"},
427     { oSKComments, "sk-comments", 0,   "@"},
428     { oCompletesNeeded, "completes-needed", 1, "@"},
429     { oMarginalsNeeded, "marginals-needed", 1, "@"},
430     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
431     { oTrustedKey, "trusted-key", 2, N_("|KEYID|ultimately trust this key")},
432     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
433     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
434     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
435     { oPGP2, "pgp2", 0, N_("set all packet, cipher and digest options to PGP 2.x behavior")},
436     { oNoPGP2, "no-pgp2", 0, "@"},
437     { oPGP6, "pgp6", 0, "@"},
438     { oNoPGP6, "no-pgp6", 0, "@"},
439     { oPGP7, "pgp7", 0, "@"},
440     { oNoPGP7, "no-pgp7", 0, "@"},
441     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
442     { oS2KDigest, "s2k-digest-algo",2,
443                 N_("|NAME|use message digest algorithm NAME for passphrases")},
444     { oS2KCipher, "s2k-cipher-algo",2,
445                 N_("|NAME|use cipher algorithm NAME for passphrases")},
446     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
447     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
448     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
449     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
450     { oCompressAlgo, "compress-algo", 1 , N_("|N|use compress algorithm N")},
451     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
452     { oShowPhotos,   "show-photos", 0, N_("Show Photo IDs")},
453     { oNoShowPhotos, "no-show-photos", 0, N_("Don't show Photo IDs")},
454     { oPhotoViewer,  "photo-viewer", 2, N_("Set command line to view Photo IDs")},
455     { oNotation,   "notation-data", 2, "@" },
456     { oSigNotation,   "sig-notation", 2, "@" },
457     { oCertNotation,  "cert-notation", 2, "@" },
458
459     { 302, NULL, 0, N_(
460   "@\n(See the man page for a complete listing of all commands and options)\n"
461                       )},
462
463     { 303, NULL, 0, N_("@\nExamples:\n\n"
464     " -se -r Bob [file]          sign and encrypt for user Bob\n"
465     " --clearsign [file]         make a clear text signature\n"
466     " --detach-sign [file]       make a detached signature\n"
467     " --list-keys [names]        show keys\n"
468     " --fingerprint [names]      show fingerprints\n"  ) },
469
470   /* hidden options */
471     { aExportOwnerTrust, "list-ownertrust",0 , "@"},  /* alias */
472     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
473     { aListTrustDB, "list-trustdb",0 , "@"},
474     { aListTrustPath, "list-trust-path",0, "@"},
475     { aPipeMode,  "pipemode", 0, "@" },
476     { oKOption, NULL,    0, "@"},
477     { oPasswdFD, "passphrase-fd",1, "@" },
478 #ifdef __riscos__
479     { oPasswdFile, "passphrase-file",2, "@" },
480 #endif /* __riscos__ */
481     { oCommandFD, "command-fd",1, "@" },
482 #ifdef __riscos__
483     { oCommandFile, "command-file",2, "@" },
484 #endif /* __riscos__ */
485     { oQuickRandom, "quick-random", 0, "@"},
486     { oNoVerbose, "no-verbose", 0, "@"},
487     { oTrustDBName, "trustdb-name", 2, "@" },
488     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
489     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
490     { oNoArmor, "no-armor",   0, "@"},
491     { oNoArmor, "no-armour",   0, "@"},
492     { oNoDefKeyring, "no-default-keyring", 0, "@" },
493     { oNoGreeting, "no-greeting", 0, "@" },
494     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
495     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
496     { oNoBatch, "no-batch", 0, "@" },
497     { oWithColons, "with-colons", 0, "@"},
498     { oWithKeyData,"with-key-data", 0, "@"},
499     { aListKeys, "list-key", 0, "@" }, /* alias */
500     { aListSigs, "list-sig", 0, "@" }, /* alias */
501     { aCheckKeys, "check-sig",0, "@" }, /* alias */
502     { oSkipVerify, "skip-verify",0, "@" },
503     { oCompressKeys, "compress-keys",0, "@"},
504     { oCompressSigs, "compress-sigs",0, "@"},
505     { oDefCertCheckLevel, "default-cert-check-level", 1, "@"},
506     { oAlwaysTrust, "always-trust", 0, "@"},
507     { oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
508     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
509     { oSetFilename, "set-filename", 2, "@" },
510     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
511     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
512     { oSetPolicyURL, "set-policy-url", 2, "@" },
513     { oSigPolicyURL, "sig-policy-url", 2, "@" },
514     { oCertPolicyURL, "cert-policy-url", 2, "@" },
515     { oShowPolicyURL, "show-policy-url", 0, "@" },
516     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
517     { oShowNotation, "show-notation", 0, "@" },
518     { oNoShowNotation, "no-show-notation", 0, "@" },
519     { oComment, "comment", 2, "@" },
520     { oDefaultComment, "default-comment", 0, "@" },
521     { oNoVersion, "no-version", 0, "@"},
522     { oEmitVersion, "emit-version", 0, "@"},
523     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
524     { oEscapeFrom, "escape-from-lines", 0, "@" },
525     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
526     { oLockOnce, "lock-once", 0, "@" },
527     { oLockMultiple, "lock-multiple", 0, "@" },
528     { oLockNever, "lock-never", 0, "@" },
529     { oLoggerFD, "logger-fd",1, "@" },
530 #ifdef __riscos__
531     { oLoggerFile, "logger-file",2, "@" },
532 #endif /* __riscos__ */
533     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
534     { oUtf8Strings, "utf8-strings", 0, "@" },
535     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
536     { oWithFingerprint, "with-fingerprint", 0, "@" },
537     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
538     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
539     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
540     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
541     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
542     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
543     { oNoLiteral, "no-literal", 0, "@" },
544     { oSetFilesize, "set-filesize", 20, "@" },
545     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
546     { oFastListMode,"fast-list-mode", 0, "@" },
547     { oFixedListMode,"fixed-list-mode", 0, "@" },
548     { oListOnly, "list-only", 0, "@"},
549     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
550     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
551     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
552     { oShowSessionKey, "show-session-key", 0, "@" },
553     { oOverrideSessionKey, "override-session-key", 2, "@" },
554     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
555     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
556     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
557     { oNoSigCache,         "no-sig-cache", 0, "@" },
558     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
559     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
560     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
561     { oMergeOnly,         "merge-only", 0, "@" },
562     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
563     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
564     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
565     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
566     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
567     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
568     { oPreservePermissions, "preserve-permissions", 0, "@"},
569     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
570     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
571     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
572     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
573     { oEmu3DESS2KBug,  "emulate-3des-s2k-bug", 0, "@"},
574     { oEmuMDEncodeBug,  "emulate-md-encode-bug", 0, "@"},
575     { oDisplay,    "display",     2, "@" },
576     { oTTYname,    "ttyname",     2, "@" },
577     { oTTYtype,    "ttytype",     2, "@" },
578     { oLCctype,    "lc-ctype",    2, "@" },
579     { oLCmessages, "lc-messages", 2, "@" },
580     { oGroup,      "group",       2, "@" },
581 {0} };
582
583
584
585 int g10_errors_seen = 0;
586
587 static int utf8_strings = 0;
588 static int maybe_setuid = 1;
589
590 static char *build_list( const char *text, char letter,
591                          const char *(*mapf)(int), int (*chkf)(int) );
592 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
593                         enum cmd_and_opt_values new_cmd );
594 static void print_hex( byte *p, size_t n );
595 static void print_mds( const char *fname, int algo );
596 static void add_notation_data( const char *string, int which );
597 static void add_policy_url( const char *string, int which );
598
599 #ifdef __riscos__
600 RISCOS_GLOBAL_STATICS("GnuPG Heap")
601 #endif /* __riscos__ */
602
603 const char *
604 strusage( int level )
605 {
606   static char *digests, *pubkeys, *ciphers, *zips;
607     const char *p;
608     switch( level ) {
609       case 11: p = "gpg (GnuPG)";
610         break;
611       case 13: p = VERSION; break;
612       case 17: p = PRINTABLE_OS_NAME; break;
613       case 19: p =
614             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
615         break;
616       case 1:
617       case 40:  p =
618             _("Usage: gpg [options] [files] (-h for help)");
619         break;
620       case 41:  p =
621             _("Syntax: gpg [options] [files]\n"
622               "sign, check, encrypt or decrypt\n"
623               "default operation depends on the input data\n");
624         break;
625
626       case 31: p = "\nHome: "; break;
627 #ifndef __riscos__
628       case 32: p = opt.homedir; break;
629 #else /* __riscos__ */
630       case 32: p = make_filename(opt.homedir, NULL); break;
631 #endif /* __riscos__ */
632       case 33: p = _("\nSupported algorithms:\n"); break;
633       case 34:
634         if( !pubkeys )
635             pubkeys = build_list("Pubkey: ", 0, pubkey_algo_to_string,
636                                                         check_pubkey_algo );
637         p = pubkeys;
638         break;
639       case 35:
640         if( !ciphers )
641             ciphers = build_list("Cipher: ", 'S', cipher_algo_to_string,
642                                                         check_cipher_algo );
643         p = ciphers;
644         break;
645       case 36:
646         if( !digests )
647             digests = build_list("Hash: ", 'H', digest_algo_to_string,
648                                                         check_digest_algo );
649         p = digests;
650         break;
651       case 37:
652         if( !zips )
653             zips = build_list("Compress: ",'Z',compress_algo_to_string,
654                                                         check_compress_algo);
655         p = zips;
656         break;
657
658       default:  p = default_strusage(level);
659     }
660     return p;
661 }
662
663
664 static char *
665 build_list( const char *text, char letter,
666             const char * (*mapf)(int), int (*chkf)(int) )
667 {
668     int i;
669     const char *s;
670     size_t n=strlen(text)+2;
671     char *list, *p, *line=NULL;
672
673     if( maybe_setuid )
674         secmem_init( 0 );    /* drop setuid */
675
676     for(i=0; i <= 110; i++ )
677         if( !chkf(i) && (s=mapf(i)) )
678             n += strlen(s) + 7 + 2;
679     list = m_alloc( 21 + n ); *list = 0;
680     for(p=NULL, i=0; i <= 110; i++ ) {
681         if( !chkf(i) && (s=mapf(i)) ) {
682             if( !p ) {
683                 p = stpcpy( list, text );
684                 line=p;
685             }
686             else
687                 p = stpcpy( p, ", ");
688
689             if(strlen(line)>60) {
690               int spaces=strlen(text);
691
692               list=m_realloc(list,n+spaces+1);
693               /* realloc could move the block, so find the end again */
694               p=list;
695               while(*p)
696                 p++;
697
698               p=stpcpy(p, "\n");
699               line=p;
700               for(;spaces;spaces--)
701                 p=stpcpy(p, " ");
702             }
703
704             p = stpcpy(p, s );
705             if(opt.verbose && letter)
706               {
707                 char num[8];
708                 sprintf(num," (%c%d)",letter,i);
709                 p = stpcpy(p,num);
710               }
711         }
712     }
713     if( p )
714         p = stpcpy(p, "\n" );
715     return list;
716 }
717
718
719 static void
720 i18n_init(void)
721 {
722   #ifdef USE_SIMPLE_GETTEXT
723     set_gettext_file( PACKAGE );
724   #else
725   #ifdef ENABLE_NLS
726     setlocale( LC_ALL, "" );
727     bindtextdomain( PACKAGE, G10_LOCALEDIR );
728     textdomain( PACKAGE );
729   #endif
730   #endif
731 }
732
733 static void
734 wrong_args( const char *text)
735 {
736     fputs(_("usage: gpg [options] "),stderr);
737     fputs(text,stderr);
738     putc('\n',stderr);
739     g10_exit(2);
740 }
741
742
743 static char *
744 make_username( const char *string )
745 {
746     char *p;
747     if( utf8_strings )
748         p = m_strdup(string);
749     else
750         p = native_to_utf8( string );
751     return p;
752 }
753
754
755 static void
756 set_debug(void)
757 {
758     if( opt.debug & DBG_MEMORY_VALUE )
759         memory_debug_mode = 1;
760     if( opt.debug & DBG_MEMSTAT_VALUE )
761         memory_stat_debug_mode = 1;
762     if( opt.debug & DBG_MPI_VALUE )
763         mpi_debug_mode = 1;
764     if( opt.debug & DBG_CIPHER_VALUE )
765         g10c_debug_mode = 1;
766     if( opt.debug & DBG_IOBUF_VALUE )
767         iobuf_debug_mode = 1;
768
769 }
770
771
772 static void
773 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
774 {
775     enum cmd_and_opt_values cmd = *ret_cmd;
776
777     if( !cmd || cmd == new_cmd )
778         cmd = new_cmd;
779     else if( cmd == aSign && new_cmd == aEncr )
780         cmd = aSignEncr;
781     else if( cmd == aEncr && new_cmd == aSign )
782         cmd = aSignEncr;
783     else if( cmd == aSign && new_cmd == aSym )
784         cmd = aSignSym;
785     else if( cmd == aSym && new_cmd == aSign )
786         cmd = aSignSym;
787     else if( cmd == aKMode && new_cmd == aSym )
788         cmd = aKModeC;
789     else if(    ( cmd == aSign     && new_cmd == aClearsign )
790              || ( cmd == aClearsign && new_cmd == aSign )  )
791         cmd = aClearsign;
792     else {
793         log_error(_("conflicting commands\n"));
794         g10_exit(2);
795     }
796
797     *ret_cmd = cmd;
798 }
799
800
801 static void add_group(char *string)
802 {
803   char *name,*value;
804   struct groupitem *item;
805   STRLIST values=NULL;
806
807   /* Break off the group name */
808   name=strsep(&string," ");
809   if(string==NULL)
810     {
811       log_error(_("no values for group \"%s\"\n"),name);
812       return;
813     }
814
815   /* Break apart the values */
816   while((value=strsep(&string," ")) && *value!='\0')
817     add_to_strlist2(&values,value,utf8_strings);
818
819   item=m_alloc(sizeof(struct groupitem));
820   item->name=name;
821   item->values=values;
822   item->next=opt.grouplist;
823
824   opt.grouplist=item;
825 }
826
827
828 int
829 main( int argc, char **argv )
830 {
831     ARGPARSE_ARGS pargs;
832     IOBUF a;
833     int rc=0;
834     int orig_argc;
835     char **orig_argv;
836     const char *fname;
837     char *username;
838     STRLIST unsafe_files=NULL;
839     STRLIST extensions=NULL;
840     int may_coredump;
841     STRLIST sl, remusr= NULL, locusr=NULL;
842     STRLIST nrings=NULL, sec_nrings=NULL;
843     armor_filter_context_t afx;
844     int detached_sig = 0;
845     FILE *configfp = NULL;
846     char *configname = NULL;
847     unsigned configlineno;
848     int parse_debug = 0;
849     int default_config = 1;
850     int default_keyring = 1;
851     int greeting = 0;
852     int nogreeting = 0;
853     int use_random_seed = 1;
854     enum cmd_and_opt_values cmd = 0;
855     const char *trustdb_name = NULL;
856     char *def_cipher_string = NULL;
857     char *def_digest_string = NULL;
858     char *cert_digest_string = NULL;
859     char *s2k_cipher_string = NULL;
860     char *s2k_digest_string = NULL;
861     char *pers_cipher_list = NULL;
862     char *pers_digest_list = NULL;
863     char *pers_compress_list = NULL;
864     int eyes_only=0;
865     int pwfd = -1;
866     int with_fpr = 0; /* make an option out of --fingerprint */
867     int any_explicit_recipient = 0;
868   #ifdef USE_SHM_COPROCESSING
869     ulong requested_shm_size=0;
870   #endif
871
872   #ifdef __riscos__
873     riscos_global_defaults();
874     opt.lock_once = 1;
875   #endif /* __riscos__ */
876
877     trap_unaligned();
878     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
879     /* Please note that we may running SUID(ROOT), so be very CAREFUL
880      * when adding any stuff between here and the call to
881      * secmem_init()  somewhere after the option parsing
882      */
883     log_set_name("gpg");
884     secure_random_alloc(); /* put random number into secure memory */
885     may_coredump = disable_core_dumps();
886     init_signals();
887     create_dotlock(NULL); /* register locking cleanup */
888     i18n_init();
889     opt.command_fd = -1; /* no command fd */
890     opt.compress = -1; /* defaults to standard compress level */
891     /* note: if you change these lines, look at oOpenPGP */
892     opt.def_cipher_algo = 0;
893     opt.def_digest_algo = 0;
894     opt.cert_digest_algo = 0;
895     opt.def_compress_algo = -1;
896     opt.s2k_mode = 3; /* iterated+salted */
897     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
898     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
899     opt.completes_needed = 1;
900     opt.marginals_needed = 3;
901     opt.max_cert_depth = 5;
902     opt.pgp2_workarounds = 1;
903     opt.force_v3_sigs = 1;
904     opt.escape_from = 1;
905     opt.keyserver_options.include_subkeys=1;
906 #if defined (__MINGW32__) || defined (__CYGWIN32__)
907     opt.homedir = read_w32_registry_string( NULL, "Software\\GNU\\GnuPG", "HomeDir" );
908 #else
909     opt.homedir = getenv("GNUPGHOME");
910 #endif
911     if( !opt.homedir || !*opt.homedir ) {
912         opt.homedir = GNUPG_HOMEDIR;
913     }
914
915     /* check whether we have a config file on the commandline */
916     orig_argc = argc;
917     orig_argv = argv;
918     pargs.argc = &argc;
919     pargs.argv = &argv;
920     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
921     while( arg_parse( &pargs, opts) ) {
922         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
923             parse_debug++;
924         else if( pargs.r_opt == oOptions ) {
925             /* yes there is one, so we do not try the default one, but
926              * read the option file when it is encountered at the commandline
927              */
928             default_config = 0;
929         }
930         else if( pargs.r_opt == oNoOptions )
931             default_config = 0; /* --no-options */
932         else if( pargs.r_opt == oHomedir )
933             opt.homedir = pargs.r.ret_str;
934       #ifdef USE_SHM_COPROCESSING
935         else if( pargs.r_opt == oRunAsShmCP ) {
936             /* does not make sense in a options file, we do it here,
937              * so that we are the able to drop setuid as soon as possible */
938             opt.shm_coprocess = 1;
939             requested_shm_size = pargs.r.ret_ulong;
940         }
941         else if ( pargs.r_opt == oStatusFD ) {
942             /* this is needed to ensure that the status-fd filedescriptor is
943              * initialized when init_shm_coprocessing() is called */
944             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
945         }
946       #endif
947     }
948
949 #ifdef HAVE_DOSISH_SYSTEM
950     if ( strchr (opt.homedir,'\\') ) {
951         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
952         const char *s = opt.homedir;
953         for (d=buf,s=opt.homedir; *s; s++)
954             *d++ = *s == '\\'? '/': *s;
955         *d = 0;
956         opt.homedir = buf;
957     }
958 #endif
959 #ifdef USE_SHM_COPROCESSING
960     if( opt.shm_coprocess ) {
961         init_shm_coprocessing(requested_shm_size, 1 );
962     }
963 #endif
964     /* initialize the secure memory. */
965     secmem_init( 16384 );
966     maybe_setuid = 0;
967     /* Okay, we are now working under our real uid */
968
969     if( default_config )
970         configname = make_filename(opt.homedir, "options", NULL );
971
972     argc = orig_argc;
973     argv = orig_argv;
974     pargs.argc = &argc;
975     pargs.argv = &argv;
976     pargs.flags=  1;  /* do not remove the args */
977   next_pass:
978     if( configname ) {
979
980       if(check_permissions(configname,0,1))
981         {
982           add_to_strlist(&unsafe_files,configname);
983
984           /* If any options file is unsafe, then disable any external
985              programs for keyserver calls or photo IDs.  Since the
986              external program to call is set in the options file, a
987              unsafe options file can lead to an arbitrary program
988              being run. */
989
990           opt.exec_disable=1;
991         }
992
993         configlineno = 0;
994         configfp = fopen( configname, "r" );
995         if( !configfp ) {
996             if( default_config ) {
997                 if( parse_debug )
998                     log_info(_("NOTE: no default option file `%s'\n"),
999                                                             configname );
1000             }
1001             else {
1002                 log_error(_("option file `%s': %s\n"),
1003                                     configname, strerror(errno) );
1004                 g10_exit(2);
1005             }
1006             m_free(configname); configname = NULL;
1007         }
1008         if( parse_debug && configname )
1009             log_info(_("reading options from `%s'\n"), configname );
1010         default_config = 0;
1011     }
1012
1013     while( optfile_parse( configfp, configname, &configlineno,
1014                                                 &pargs, opts) ) {
1015         switch( pargs.r_opt ) {
1016           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1017           case aListPackets: set_cmd( &cmd, aListPackets); break;
1018           case aImport: set_cmd( &cmd, aImport); break;
1019           case aFastImport: set_cmd( &cmd, aFastImport); break;
1020           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1021           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1022           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1023           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1024           case aExport: set_cmd( &cmd, aExport); break;
1025           case aExportAll: set_cmd( &cmd, aExportAll); break;
1026           case aListKeys: set_cmd( &cmd, aListKeys); break;
1027           case aListSigs: set_cmd( &cmd, aListSigs); break;
1028           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1029           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1030           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1031                                                         greeting=1; break;
1032           case aDeleteSecretAndPublicKeys:
1033             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1034             greeting=1; 
1035             break;
1036           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1037
1038           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1039           case aSym: set_cmd( &cmd, aSym); break;
1040
1041           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1042           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1043
1044           case aEncr: set_cmd( &cmd, aEncr); break;
1045           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1046           case aSign: set_cmd( &cmd, aSign );  break;
1047           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1048           case aSignKey: set_cmd( &cmd, aSignKey); break;
1049           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1050           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1051           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1052           case aStore: set_cmd( &cmd, aStore); break;
1053           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1054           case aClearsign: set_cmd( &cmd, aClearsign); break;
1055           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1056           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1057           case aVerify: set_cmd( &cmd, aVerify); break;
1058           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1059           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1060           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1061           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1062           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1063           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1064           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1065           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1066           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1067           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1068           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1069           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1070           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1071           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1072           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1073           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1074
1075           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1076           case oOutput: opt.outfile = pargs.r.ret_str; break;
1077           case oQuiet: opt.quiet = 1; break;
1078           case oNoTTY: tty_no_terminal(1); break;
1079           case oDryRun: opt.dry_run = 1; break;
1080           case oInteractive: opt.interactive = 1; break;
1081           case oVerbose: g10_opt_verbose++;
1082                     opt.verbose++; opt.list_sigs=1; break;
1083           case oKOption: set_cmd( &cmd, aKMode ); break;
1084
1085           case oBatch: opt.batch = 1; nogreeting = 1; break;
1086           case oUseAgent:
1087 #ifndef __riscos__
1088             opt.use_agent = 1;
1089 #else /* __riscos__ */
1090             opt.use_agent = 0;
1091             not_implemented("use-agent");
1092 #endif /* __riscos__ */
1093             break;
1094           case oNoUseAgent: opt.use_agent = 0; break;
1095           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1096           case oAnswerYes: opt.answer_yes = 1; break;
1097           case oAnswerNo: opt.answer_no = 1; break;
1098           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1099           case oShowKeyring: opt.show_keyring = 1; break;
1100           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1101           case oDebugAll: opt.debug = ~0; break;
1102           case oStatusFD:
1103             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1104             break;
1105 #ifdef __riscos__
1106           case oStatusFile:
1107             set_status_fd( iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1108             break;
1109 #endif /* __riscos__ */
1110           case oAttributeFD:
1111             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1112             break;
1113 #ifdef __riscos__
1114           case oAttributeFile:
1115             set_attrib_fd(iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1116             break;
1117 #endif /* __riscos__ */
1118           case oLoggerFD:
1119             log_set_logfile( NULL,
1120                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1121             break;
1122 #ifdef __riscos__
1123           case oLoggerFile:
1124             log_set_logfile( NULL,
1125                              iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1126             break;
1127 #endif /* __riscos__ */
1128           case oWithFingerprint:
1129             opt.with_fingerprint = 1;
1130             with_fpr=1; /*fall thru*/
1131           case oFingerprint: opt.fingerprint++; break;
1132           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1133           case oOptions:
1134             /* config files may not be nested (silently ignore them) */
1135             if( !configfp ) {
1136                 m_free(configname);
1137                 configname = m_strdup(pargs.r.ret_str);
1138                 goto next_pass;
1139             }
1140             break;
1141           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1142           case oNoDefKeyring: default_keyring = 0; break;
1143           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1144           case oNoGreeting: nogreeting = 1; break;
1145           case oNoVerbose: g10_opt_verbose = 0;
1146                            opt.verbose = 0; opt.list_sigs=0; break;
1147           case oQuickRandom: quick_random_gen(1); break;
1148           case oSKComments: opt.sk_comments=1; break;
1149           case oNoSKComments: opt.sk_comments=0; break;
1150           case oNoVersion: opt.no_version=1; break;
1151           case oEmitVersion: opt.no_version=0; break;
1152           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1153           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1154           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1155           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1156           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1157           case oDefRecipient:
1158                     if( *pargs.r.ret_str )
1159                         opt.def_recipient = make_username(pargs.r.ret_str);
1160                     break;
1161           case oDefRecipientSelf:
1162                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1163                     opt.def_recipient_self = 1;
1164                     break;
1165           case oNoDefRecipient:
1166                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1167                     opt.def_recipient_self = 0;
1168                     break;
1169           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1170           case oHomedir: break;
1171           case oNoBatch: opt.batch = 0; break;
1172           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1173           case oWithColons: opt.with_colons=':'; break;
1174
1175           case oSkipVerify: opt.skip_verify=1; break;
1176           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
1177           case oCompressKeys: opt.compress_keys = 1; break;
1178           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1179           case oAlwaysTrust: opt.always_trust = 1; break;
1180           case oLoadExtension:
1181 #ifndef __riscos__
1182             add_to_strlist(&extensions,pargs.r.ret_str);
1183             register_cipher_extension(orig_argc? *orig_argv:NULL,
1184                                       pargs.r.ret_str);
1185 #else /* __riscos__ */
1186             not_implemented("load-extension");
1187 #endif /* __riscos__ */
1188             break;
1189           case oRFC1991:
1190             opt.rfc1991 = 1;
1191             opt.rfc2440 = 0;
1192             opt.force_v4_certs = 0;
1193             opt.sk_comments = 0;
1194             opt.escape_from = 1;
1195             break;
1196           case oOpenPGP:
1197             opt.rfc1991 = 0;
1198             opt.rfc2440 = 1;
1199             opt.allow_non_selfsigned_uid = 1;
1200             opt.allow_freeform_uid = 1;
1201             opt.pgp2_workarounds = 0;
1202             opt.escape_from = 0;
1203             opt.force_v3_sigs = 0;
1204             opt.compress_keys = 0;          /* not mandated  but we do it */
1205             opt.compress_sigs = 0;          /* ditto. */
1206             opt.not_dash_escaped = 0;
1207             opt.def_cipher_algo = 0;
1208             opt.def_digest_algo = 0;
1209             opt.cert_digest_algo = 0;
1210             opt.def_compress_algo = 1;
1211             opt.s2k_mode = 3; /* iterated+salted */
1212             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1213             opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1214             break;
1215           case oPGP2: opt.pgp2 = 1; break;
1216           case oNoPGP2: opt.pgp2 = 0; break;
1217           case oPGP6: opt.pgp6 = 1; break;
1218           case oNoPGP6: opt.pgp6 = 0; break;
1219           case oPGP7: opt.pgp7 = 1; break;
1220           case oNoPGP7: opt.pgp7 = 0; break;
1221           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
1222           case oEmu3DESS2KBug:  opt.emulate_bugs |= EMUBUG_3DESS2K; break;
1223           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1224           case oCompressSigs: opt.compress_sigs = 1; break;
1225           case oRunAsShmCP:
1226 #ifndef __riscos__
1227           #ifndef USE_SHM_COPROCESSING
1228             /* not possible in the option file,
1229              * but we print the warning here anyway */
1230             log_error("shared memory coprocessing is not available\n");
1231           #endif
1232 #else /* __riscos__ */
1233             not_implemented("run-as-shm-coprocess");
1234 #endif /* __riscos__ */
1235             break;
1236           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1237           case oForYourEyesOnly: eyes_only = 1; break;
1238           case oNoForYourEyesOnly: eyes_only = 0; break;
1239           case oSetPolicyURL:
1240             add_policy_url(pargs.r.ret_str,0);
1241             add_policy_url(pargs.r.ret_str,1);
1242             break;
1243           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1244           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1245           case oShowPolicyURL: opt.show_policy_url=1; break;
1246           case oNoShowPolicyURL: opt.show_policy_url=0; break;
1247           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1248           case oComment: opt.comment_string = pargs.r.ret_str; break;
1249           case oDefaultComment: opt.comment_string = NULL; break;
1250           case oThrowKeyid: opt.throw_keyid = 1; break;
1251           case oShowPhotos: opt.show_photos = 1; break;
1252           case oNoShowPhotos: opt.show_photos = 0; break;
1253           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1254           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1255           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1256           case oForceV4Certs: opt.force_v4_certs = 1; break;
1257           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1258           case oForceMDC: opt.force_mdc = 1; break;
1259           case oNoForceMDC: opt.force_mdc = 0; break;
1260           case oDisableMDC: opt.disable_mdc = 1; break;
1261           case oNoDisableMDC: opt.disable_mdc = 0; break;
1262           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1263           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1264           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1265           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1266           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1267           case oEncryptTo: /* store the recipient in the second list */
1268             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1269             sl->flags = 1;
1270             break;
1271           case oRecipient: /* store the recipient */
1272             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1273             any_explicit_recipient = 1;
1274             break;
1275           case oTextmodeShort: opt.textmode = 2; break;
1276           case oTextmode: opt.textmode=1;  break;
1277           case oExpert: opt.expert = 1; break;
1278           case oNoExpert: opt.expert = 0; break;
1279           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1280           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1281           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1282           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1283           case oUser: /* store the local users */
1284             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1285             break;
1286           case oCompress: opt.compress = pargs.r.ret_int; break;
1287           case oPasswdFD:
1288             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1289             break;
1290 #ifdef __riscos__
1291           case oPasswdFile:
1292             pwfd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1293             break;
1294 #endif /* __riscos__ */
1295           case oCommandFD:
1296             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1297             break;
1298 #ifdef __riscos__
1299           case oCommandFile:
1300             opt.command_fd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1301             break;
1302 #endif /* __riscos__ */
1303           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1304           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1305           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1306           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1307           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1308           case oCharset:
1309             if( set_native_charset( pargs.r.ret_str ) )
1310                 log_error(_("%s is not a valid character set\n"),
1311                                                     pargs.r.ret_str);
1312             break;
1313           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1314           case oEscapeFrom: opt.escape_from = 1; break;
1315           case oNoEscapeFrom: opt.escape_from = 0; break;
1316           case oLockOnce: opt.lock_once = 1; break;
1317           case oLockNever: disable_dotlock(); break;
1318           case oLockMultiple:
1319 #ifndef __riscos__
1320             opt.lock_once = 0;
1321 #else /* __riscos__ */
1322             not_implemented("lock-multiple");
1323 #endif /* __riscos__ */
1324             break;
1325           case oKeyServer:
1326             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1327             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1328               log_error(_("could not parse keyserver URI\n"));
1329             break;
1330           case oKeyServerOptions:
1331             parse_keyserver_options(pargs.r.ret_str);
1332             break;
1333           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1334           case oExecPath:
1335 #ifndef FIXED_EXEC_PATH
1336             if(set_exec_path(pargs.r.ret_str))
1337               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1338 #endif
1339             break;
1340           case oNotation:
1341             add_notation_data( pargs.r.ret_str, 0 );
1342             add_notation_data( pargs.r.ret_str, 1 );
1343             break;
1344           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1345           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1346           case oShowNotation: opt.show_notation=1; break;
1347           case oNoShowNotation: opt.show_notation=0; break;
1348           case oUtf8Strings: utf8_strings = 1; break;
1349           case oNoUtf8Strings: utf8_strings = 0; break;
1350           case oDisableCipherAlgo:
1351                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1352                 break;
1353           case oDisablePubkeyAlgo:
1354                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1355                 break;
1356           case oNoSigCache: opt.no_sig_cache = 1; break;
1357           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1358           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1359           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1360           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1361           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1362           case oNoLiteral: opt.no_literal = 1; break;
1363           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1364           case oHonorHttpProxy:
1365                 opt.keyserver_options.honor_http_proxy = 1;
1366                 deprecated_warning(configname,configlineno,
1367                                    "--honor-http-proxy",
1368                                    "--keyserver-options ",
1369                                    "honor-http-proxy");
1370                 break;
1371           case oFastListMode: opt.fast_list_mode = 1; break;
1372           case oFixedListMode: opt.fixed_list_mode = 1; break;
1373           case oListOnly: opt.list_only=1; break;
1374           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1375           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1376           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1377           case oNoRandomSeedFile: use_random_seed = 0; break;
1378           case oAutoKeyRetrieve:
1379           case oNoAutoKeyRetrieve:
1380                 opt.keyserver_options.auto_key_retrieve=
1381                                              (pargs.r_opt==oAutoKeyRetrieve);
1382                 deprecated_warning(configname,configlineno,
1383                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1384                                "--no-auto-key-retrieve","--keyserver-options ",
1385                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1386                                "no-auto-key-retrieve");
1387                 break;
1388           case oShowSessionKey: opt.show_session_key = 1; break;
1389           case oOverrideSessionKey:
1390                 opt.override_session_key = pargs.r.ret_str;
1391                 break;
1392           case oMergeOnly: opt.merge_only = 1; break;
1393           case oAllowSecretKeyImport: /* obsolete */ break;
1394           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1395           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1396           case oEnableSpecialFilenames:
1397             iobuf_enable_special_filenames (1);
1398             break;
1399           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1400           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1401           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1402           case oPreservePermissions: opt.preserve_permissions=1; break;
1403           case oDefaultPreferenceList:
1404             opt.def_preference_list = pargs.r.ret_str;
1405             break;
1406           case oPersonalCipherPreferences:
1407             pers_cipher_list=pargs.r.ret_str;
1408             break;
1409           case oPersonalDigestPreferences:
1410             pers_digest_list=pargs.r.ret_str;
1411             break;
1412           case oPersonalCompressPreferences:
1413             pers_compress_list=pargs.r.ret_str;
1414             break;
1415           case oDisplay: opt.display = pargs.r.ret_str; break;
1416           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1417           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1418           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1419           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1420           case oGroup: add_group(pargs.r.ret_str); break;
1421           default : pargs.err = configfp? 1:2; break;
1422         }
1423     }
1424
1425     if( configfp ) {
1426         fclose( configfp );
1427         configfp = NULL;
1428         m_free(configname); configname = NULL;
1429         goto next_pass;
1430     }
1431     m_free( configname ); configname = NULL;
1432     if( log_get_errorcount(0) )
1433         g10_exit(2);
1434     if( nogreeting )
1435         greeting = 0;
1436
1437     if( greeting ) {
1438         fprintf(stderr, "%s %s; %s\n",
1439                         strusage(11), strusage(13), strusage(14) );
1440         fprintf(stderr, "%s\n", strusage(15) );
1441     }
1442   #ifdef IS_DEVELOPMENT_VERSION
1443     if( !opt.batch ) {
1444         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1445         log_info("It is only intended for test purposes and should NOT be\n");
1446         log_info("used in a production environment or with production keys!\n");
1447     }
1448   #endif
1449
1450     check_permissions(opt.homedir,0,0);
1451
1452     if(unsafe_files)
1453       {
1454         STRLIST tmp;
1455
1456         for(tmp=unsafe_files;tmp;tmp=tmp->next)
1457           check_permissions(tmp->d,0,0);
1458
1459         free_strlist(unsafe_files);
1460       }
1461
1462     if(extensions)
1463       {
1464         STRLIST tmp;
1465
1466         for(tmp=extensions;tmp;tmp=tmp->next)
1467           check_permissions(tmp->d,1,0);
1468
1469         free_strlist(extensions);
1470       }
1471
1472     if( may_coredump && !opt.quiet )
1473         log_info(_("WARNING: program may create a core file!\n"));
1474
1475     if (eyes_only) {
1476       if (opt.set_filename)
1477           log_info(_("WARNING: %s overrides %s\n"),
1478                    "--for-your-eyes-only","--set-filename");
1479
1480       opt.set_filename="_CONSOLE";
1481     }
1482
1483     if (opt.no_literal) {
1484         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1485         if (opt.textmode)
1486             log_error(_("%s not allowed with %s!\n"),
1487                        "--textmode", "--no-literal" );
1488         if (opt.set_filename)
1489             log_error(_("%s makes no sense with %s!\n"),
1490                         eyes_only?"--for-your-eyes-only":"--set-filename",
1491                         "--no-literal" );
1492     }
1493
1494     if (opt.set_filesize)
1495         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1496     if( opt.batch )
1497         tty_batchmode( 1 );
1498
1499     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1500
1501     set_debug();
1502     g10_opt_homedir = opt.homedir;
1503
1504     /* Do these after the switch(), so they can override settings. */
1505     if(opt.pgp2 && (opt.pgp6 || opt.pgp7))
1506       log_error(_("%s not allowed with %s!\n"),
1507                 "--pgp2",opt.pgp6?"--pgp6":"--pgp7");
1508     else
1509       {
1510         if(opt.pgp2)
1511           {
1512             int unusable=0;
1513
1514             if(cmd==aSign && !detached_sig)
1515               {
1516                 log_info(_("you can only make detached or clear signatures "
1517                            "while in --pgp2 mode\n"));
1518                 unusable=1;
1519               }
1520             else if(cmd==aSignEncr || cmd==aSignSym)
1521               {
1522                 log_info(_("you can't sign and encrypt at the "
1523                            "same time while in --pgp2 mode\n"));
1524                 unusable=1;
1525               }
1526             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1527               {
1528                 log_info(_("you must use files (and not a pipe) when "
1529                            "working with --pgp2 enabled.\n"));
1530                 unusable=1;
1531               }
1532             else if(cmd==aEncr || cmd==aSym)
1533               {
1534                 /* Everything else should work without IDEA (except using
1535                    a secret key encrypted with IDEA and setting an IDEA
1536                    preference, but those have their own error
1537                    messages). */
1538
1539                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1540                   {
1541                     log_info(_("encrypting a message in --pgp2 mode requires "
1542                                "the IDEA cipher\n"));
1543                     idea_cipher_warn(1);
1544                     unusable=1;
1545                   }
1546                 else if(cmd==aSym)
1547                   {
1548                     m_free(def_cipher_string);
1549                     def_cipher_string = m_strdup("idea");
1550                   }
1551               }
1552
1553             if(unusable)
1554               {
1555                 log_info(_("this message may not be usable by PGP 2.x\n"));
1556                 opt.pgp2=0;
1557               }
1558             else
1559               {
1560                 opt.rfc1991 = 1;
1561                 opt.rfc2440 = 0;
1562                 opt.force_mdc = 0;
1563                 opt.disable_mdc = 1;
1564                 opt.force_v4_certs = 0;
1565                 opt.sk_comments = 0;
1566                 opt.escape_from = 1;
1567                 opt.force_v3_sigs = 1;
1568                 opt.pgp2_workarounds = 1;
1569                 opt.ask_sig_expire = 0;
1570                 opt.ask_cert_expire = 0;
1571                 m_free(def_digest_string);
1572                 def_digest_string = m_strdup("md5");
1573                 opt.def_compress_algo = 1;
1574               }
1575           }
1576
1577         if(opt.pgp6 || opt.pgp7)
1578           {
1579             opt.force_mdc=0;
1580             opt.disable_mdc=1;
1581             opt.sk_comments=0;
1582             opt.escape_from=1;
1583             opt.force_v3_sigs=1;
1584             opt.ask_sig_expire=0;
1585             opt.def_compress_algo=1;
1586           }
1587       }
1588
1589     /* must do this after dropping setuid, because string_to...
1590      * may try to load an module */
1591     if( def_cipher_string ) {
1592         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1593         if(opt.def_cipher_algo==0 &&
1594            ascii_strcasecmp(def_cipher_string,"idea")==0)
1595           idea_cipher_warn(1);
1596         m_free(def_cipher_string); def_cipher_string = NULL;
1597         if( check_cipher_algo(opt.def_cipher_algo) )
1598             log_error(_("selected cipher algorithm is invalid\n"));
1599     }
1600     if( def_digest_string ) {
1601         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1602         m_free(def_digest_string); def_digest_string = NULL;
1603         if( check_digest_algo(opt.def_digest_algo) )
1604             log_error(_("selected digest algorithm is invalid\n"));
1605     }
1606     if( cert_digest_string ) {
1607         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1608         m_free(cert_digest_string); cert_digest_string = NULL;
1609         if( check_digest_algo(opt.cert_digest_algo) )
1610             log_error(_("selected certification digest algorithm is invalid\n"));
1611     }
1612     if( s2k_cipher_string ) {
1613         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
1614         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
1615         if( check_cipher_algo(opt.s2k_cipher_algo) )
1616             log_error(_("selected cipher algorithm is invalid\n"));
1617     }
1618     if( s2k_digest_string ) {
1619         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
1620         m_free(s2k_digest_string); s2k_digest_string = NULL;
1621         if( check_digest_algo(opt.s2k_digest_algo) )
1622             log_error(_("selected digest algorithm is invalid\n"));
1623     }
1624     if( opt.def_compress_algo < -1 || opt.def_compress_algo > 2 )
1625         log_error(_("compress algorithm must be in range %d..%d\n"), 0, 2);
1626     if( opt.completes_needed < 1 )
1627         log_error(_("completes-needed must be greater than 0\n"));
1628     if( opt.marginals_needed < 2 )
1629         log_error(_("marginals-needed must be greater than 1\n"));
1630     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1631         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1632     switch( opt.s2k_mode ) {
1633       case 0:
1634         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1635         break;
1636       case 1: case 3: break;
1637       default:
1638         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1639     }
1640
1641     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
1642       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
1643
1644     /* This isn't actually needed, but does serve to error out if the
1645        string is invalid. */
1646     if(opt.def_preference_list &&
1647         keygen_set_std_prefs(opt.def_preference_list,0))
1648       log_error(_("invalid default preferences\n"));
1649
1650     /* We provide defaults for the personal digest list */
1651     if(!pers_digest_list)
1652       pers_digest_list="h2";
1653
1654     if(pers_cipher_list &&
1655        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
1656       log_error(_("invalid personal cipher preferences\n"));
1657
1658     if(pers_digest_list &&
1659        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
1660       log_error(_("invalid personal digest preferences\n"));
1661
1662     if(pers_compress_list &&
1663        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
1664       log_error(_("invalid personal compress preferences\n"));
1665
1666     if( log_get_errorcount(0) )
1667         g10_exit(2);
1668
1669     /* set the random seed file */
1670     if( use_random_seed ) {
1671         char *p = make_filename(opt.homedir, "random_seed", NULL );
1672         check_permissions(p,0,0);
1673         set_random_seed_file(p);
1674         m_free(p);
1675     }
1676
1677     if( !cmd && opt.fingerprint && !with_fpr ) {
1678         set_cmd( &cmd, aListKeys);
1679     }
1680
1681     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1682         if( cmd == aKModeC ) {
1683             opt.fingerprint = 1;
1684             cmd = aKMode;
1685         }
1686         opt.list_sigs = 0;
1687         if( opt.verbose > 2 )
1688             opt.check_sigs++;
1689         if( opt.verbose > 1 )
1690             opt.list_sigs++;
1691
1692         opt.verbose = opt.verbose > 1;
1693         g10_opt_verbose = opt.verbose;
1694     }
1695
1696     /* Compression algorithm 0 means no compression at all */
1697     if( opt.def_compress_algo == 0)
1698         opt.compress = 0;
1699
1700     /* kludge to let -sat generate a clear text signature */
1701     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1702         cmd = aClearsign;
1703
1704     if( opt.verbose > 1 )
1705         set_packet_list_mode(1);
1706
1707     /* Add the keyrings, but not for some special commands and not in
1708        case of "-kvv userid keyring".  Also avoid adding the secret
1709        keyring for a couple of commands to avoid unneeded access in
1710        case the secrings are stored on a floppy */
1711     if( cmd != aDeArmor && cmd != aEnArmor
1712         && !(cmd == aKMode && argc == 2 ) ) 
1713       {
1714         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
1715             && cmd != aVerify && cmd != aVerifyFiles
1716             && cmd != aSym)
1717           {
1718             if (!sec_nrings || default_keyring) /* add default secret rings */
1719               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
1720             for (sl = sec_nrings; sl; sl = sl->next)
1721               keydb_add_resource ( sl->d, 0, 1 );
1722           }
1723         if( !nrings || default_keyring )  /* add default ring */
1724             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
1725         for(sl = nrings; sl; sl = sl->next )
1726             keydb_add_resource ( sl->d, 0, 0 );
1727       }
1728     FREE_STRLIST(nrings);
1729     FREE_STRLIST(sec_nrings);
1730
1731
1732     if( pwfd != -1 )  /* read the passphrase now. */
1733         read_passphrase_from_fd( pwfd );
1734
1735     fname = argc? *argv : NULL;
1736
1737     switch( cmd ) {
1738       case aPrimegen:
1739       case aPrintMD:
1740       case aPrintMDs:
1741       case aGenRandom:
1742       case aDeArmor:
1743       case aEnArmor:
1744       case aFixTrustDB:
1745         break;
1746       case aKMode:
1747       case aListKeys:
1748       case aListSecretKeys:
1749       case aCheckKeys:
1750         if( opt.with_colons ) /* need this to list the trust */
1751             rc = setup_trustdb(1, trustdb_name );
1752         break;
1753       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1754       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1755       default: rc = setup_trustdb(1, trustdb_name ); break;
1756     }
1757     if( rc )
1758         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1759
1760
1761     switch (cmd) {
1762       case aStore: 
1763       case aSym:  
1764       case aSign: 
1765       case aSignSym: 
1766       case aClearsign: 
1767         if (!opt.quiet && any_explicit_recipient)
1768           log_info (_("WARNING: recipients (-r) given "
1769                       "without using public key encryption\n"));
1770         break;
1771       default:
1772         break;
1773     }
1774
1775     switch( cmd ) {
1776       case aStore: /* only store the file */
1777         if( argc > 1 )
1778             wrong_args(_("--store [filename]"));
1779         if( (rc = encode_store(fname)) )
1780             log_error_f( print_fname_stdin(fname),
1781                         "store failed: %s\n", g10_errstr(rc) );
1782         break;
1783       case aSym: /* encrypt the given file only with the symmetric cipher */
1784         if( argc > 1 )
1785             wrong_args(_("--symmetric [filename]"));
1786         if( (rc = encode_symmetric(fname)) )
1787             log_error_f(print_fname_stdin(fname),
1788                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1789         break;
1790
1791       case aEncr: /* encrypt the given file */
1792         if( argc > 1 )
1793             wrong_args(_("--encrypt [filename]"));
1794         if( (rc = encode_crypt(fname,remusr)) )
1795             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1796         break;
1797
1798       case aEncrFiles: /* encrypt the given files */
1799         encode_crypt_files(argc, argv, remusr);
1800         break;
1801           
1802       case aSign: /* sign the given file */
1803         sl = NULL;
1804         if( detached_sig ) { /* sign all files */
1805             for( ; argc; argc--, argv++ )
1806                 add_to_strlist( &sl, *argv );
1807         }
1808         else {
1809             if( argc > 1 )
1810                 wrong_args(_("--sign [filename]"));
1811             if( argc ) {
1812                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1813                 strcpy(sl->d, fname);
1814             }
1815         }
1816         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1817             log_error("signing failed: %s\n", g10_errstr(rc) );
1818         free_strlist(sl);
1819         break;
1820
1821       case aSignEncr: /* sign and encrypt the given file */
1822         if( argc > 1 )
1823             wrong_args(_("--sign --encrypt [filename]"));
1824         if( argc ) {
1825             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1826             strcpy(sl->d, fname);
1827         }
1828         else
1829             sl = NULL;
1830         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1831             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1832         free_strlist(sl);
1833         break;
1834
1835       case aSignSym: /* sign and conventionally encrypt the given file */
1836         if (argc > 1)
1837             wrong_args(_("--sign --symmetric [filename]"));
1838         rc = sign_symencrypt_file (fname, locusr);
1839         if (rc)
1840             log_error("%s: sign+symmetric failed: %s\n",
1841                       print_fname_stdin(fname), g10_errstr(rc) );
1842         break;
1843
1844       case aClearsign: /* make a clearsig */
1845         if( argc > 1 )
1846             wrong_args(_("--clearsign [filename]"));
1847         if( (rc = clearsign_file(fname, locusr, NULL)) )
1848             log_error("%s: clearsign failed: %s\n",
1849                       print_fname_stdin(fname), g10_errstr(rc) );
1850         break;
1851
1852       case aVerify:
1853         if( (rc = verify_signatures( argc, argv ) ))
1854             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1855         break;
1856
1857       case aVerifyFiles:
1858         if( (rc = verify_files( argc, argv ) ))
1859             log_error("verify files failed: %s\n", g10_errstr(rc) );
1860         break;
1861
1862       case aDecrypt:
1863         if( argc > 1 )
1864             wrong_args(_("--decrypt [filename]"));
1865         if( (rc = decrypt_message( fname ) ))
1866             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1867         break;
1868
1869       case aDecryptFiles:
1870         decrypt_messages(argc, argv);
1871         break;
1872             
1873       case aSignKey: /* sign the key given as argument */
1874         if( argc != 1 )
1875             wrong_args(_("--sign-key user-id"));
1876         username = make_username( fname );
1877         keyedit_menu(fname, locusr, NULL, 1 );
1878         m_free(username);
1879         break;
1880
1881       case aLSignKey:
1882         if( argc != 1 )
1883             wrong_args(_("--lsign-key user-id"));
1884         username = make_username( fname );
1885         keyedit_menu(fname, locusr, NULL, 2 );
1886         m_free(username);
1887         break;
1888
1889       case aNRSignKey:
1890         if( argc != 1 )
1891             wrong_args(_("--nrsign-key user-id"));
1892         username = make_username( fname );
1893         keyedit_menu(fname, locusr, NULL, 3 );
1894         m_free(username);
1895         break;
1896
1897       case aNRLSignKey:
1898         if( argc != 1 )
1899             wrong_args(_("--nrlsign-key user-id"));
1900         username = make_username( fname );
1901         keyedit_menu(fname, locusr, NULL, 4 );
1902         m_free(username);
1903         break;
1904
1905       case aEditKey: /* Edit a key signature */
1906         if( !argc )
1907             wrong_args(_("--edit-key user-id [commands]"));
1908         username = make_username( fname );
1909         if( argc > 1 ) {
1910             sl = NULL;
1911             for( argc--, argv++ ; argc; argc--, argv++ )
1912                 append_to_strlist( &sl, *argv );
1913             keyedit_menu( username, locusr, sl, 0 );
1914             free_strlist(sl);
1915         }
1916         else
1917             keyedit_menu(username, locusr, NULL, 0 );
1918         m_free(username);
1919         break;
1920
1921       case aDeleteKeys:
1922       case aDeleteSecretKeys:
1923       case aDeleteSecretAndPublicKeys:
1924         sl = NULL;
1925         /* I'm adding these in reverse order as add_to_strlist2
1926            reverses them again, and it's easier to understand in the
1927            proper order :) */
1928         for( ; argc; argc-- )
1929           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
1930         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
1931         free_strlist(sl);
1932         break;
1933
1934       case aCheckKeys:
1935         opt.check_sigs = 1;
1936       case aListSigs:
1937         opt.list_sigs = 1;
1938       case aListKeys:
1939         sl = NULL;
1940         for( ; argc; argc--, argv++ )
1941             add_to_strlist2( &sl, *argv, utf8_strings );
1942         public_key_list( sl );
1943         free_strlist(sl);
1944         break;
1945       case aListSecretKeys:
1946         sl = NULL;
1947         for( ; argc; argc--, argv++ )
1948             add_to_strlist2( &sl, *argv, utf8_strings );
1949         secret_key_list( sl );
1950         free_strlist(sl);
1951         break;
1952
1953       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1954         if( argc < 2 ) { /* -kv [userid] */
1955             sl = NULL;
1956             if (argc && **argv)
1957                 add_to_strlist2( &sl, *argv, utf8_strings );
1958             public_key_list( sl );
1959             free_strlist(sl);
1960         }
1961         else if( argc == 2 ) { /* -kv userid keyring */
1962             if( access( argv[1], R_OK ) ) {
1963                 log_error(_("can't open %s: %s\n"),
1964                                print_fname_stdin(argv[1]), strerror(errno));
1965             }
1966             else {
1967                 /* add keyring (default keyrings are not registered in this
1968                  * special case */
1969                 keydb_add_resource( argv[1], 0, 0 );
1970                 sl = NULL;
1971                 if (**argv)
1972                     add_to_strlist2( &sl, *argv, utf8_strings );
1973                 public_key_list( sl );
1974                 free_strlist(sl);
1975             }
1976         }
1977         else
1978             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
1979         break;
1980
1981       case aKeygen: /* generate a key */
1982         if( opt.batch ) {
1983             if( argc > 1 )
1984                 wrong_args("--gen-key [parameterfile]");
1985             generate_keypair( argc? *argv : NULL );
1986         }
1987         else {
1988             if( argc )
1989                 wrong_args("--gen-key");
1990             generate_keypair(NULL);
1991         }
1992         break;
1993
1994       case aFastImport:
1995       case aImport:
1996         import_keys( argc? argv:NULL, argc, (cmd == aFastImport), NULL );
1997         break;
1998
1999       case aExport:
2000       case aExportAll:
2001       case aSendKeys:
2002       case aRecvKeys:
2003         sl = NULL;
2004         for( ; argc; argc--, argv++ )
2005             add_to_strlist2( &sl, *argv, utf8_strings );
2006         if( cmd == aSendKeys )
2007             keyserver_export( sl );
2008         else if( cmd == aRecvKeys )
2009             keyserver_import( sl );
2010         else
2011             export_pubkeys( sl, (cmd == aExport) );
2012         free_strlist(sl);
2013         break;
2014
2015      case aSearchKeys:
2016         sl = NULL;
2017         for( ; argc; argc--, argv++ )
2018           append_to_strlist2( &sl, *argv, utf8_strings );
2019
2020         keyserver_search( sl );
2021         free_strlist(sl);
2022         break;
2023
2024       case aRefreshKeys:
2025         sl = NULL;
2026         for( ; argc; argc--, argv++ )
2027             add_to_strlist2( &sl, *argv, utf8_strings );
2028         keyserver_refresh(sl);
2029         free_strlist(sl);
2030         break;
2031
2032       case aExportSecret:
2033         sl = NULL;
2034         for( ; argc; argc--, argv++ )
2035             add_to_strlist2( &sl, *argv, utf8_strings );
2036         export_seckeys( sl );
2037         free_strlist(sl);
2038         break;
2039
2040       case aExportSecretSub:
2041         sl = NULL;
2042         for( ; argc; argc--, argv++ )
2043             add_to_strlist2( &sl, *argv, utf8_strings );
2044         export_secsubkeys( sl );
2045         free_strlist(sl);
2046         break;
2047
2048       case aGenRevoke:
2049         if( argc != 1 )
2050             wrong_args("--gen-revoke user-id");
2051         username =  make_username(*argv);
2052         gen_revoke( username );
2053         m_free( username );
2054         break;
2055
2056       case aDesigRevoke:
2057         if( argc != 1 )
2058             wrong_args("--desig-revoke user-id");
2059         username =  make_username(*argv);
2060         gen_desig_revoke( username );
2061         m_free( username );
2062         break;
2063
2064       case aDeArmor:
2065         if( argc > 1 )
2066             wrong_args("--dearmor [file]");
2067         rc = dearmor_file( argc? *argv: NULL );
2068         if( rc )
2069             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2070         break;
2071
2072       case aEnArmor:
2073         if( argc > 1 )
2074             wrong_args("--enarmor [file]");
2075         rc = enarmor_file( argc? *argv: NULL );
2076         if( rc )
2077             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2078         break;
2079
2080
2081       case aPrimegen:
2082         {   int mode = argc < 2 ? 0 : atoi(*argv);
2083
2084             if( mode == 1 && argc == 2 ) {
2085                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2086             }
2087             else if( mode == 2 && argc == 3 ) {
2088                 mpi_print( stdout, generate_elg_prime(
2089                                              0, atoi(argv[1]),
2090                                              atoi(argv[2]), NULL,NULL ), 1);
2091             }
2092             else if( mode == 3 && argc == 3 ) {
2093                 MPI *factors;
2094                 mpi_print( stdout, generate_elg_prime(
2095                                              1, atoi(argv[1]),
2096                                              atoi(argv[2]), NULL,&factors ), 1);
2097                 putchar('\n');
2098                 mpi_print( stdout, factors[0], 1 ); /* print q */
2099             }
2100             else if( mode == 4 && argc == 3 ) {
2101                 MPI g = mpi_alloc(1);
2102                 mpi_print( stdout, generate_elg_prime(
2103                                                  0, atoi(argv[1]),
2104                                                  atoi(argv[2]), g, NULL ), 1);
2105                 putchar('\n');
2106                 mpi_print( stdout, g, 1 );
2107                 mpi_free(g);
2108             }
2109             else
2110                 wrong_args("--gen-prime mode bits [qbits] ");
2111             putchar('\n');
2112         }
2113         break;
2114
2115       case aGenRandom:
2116         {
2117             int level = argc ? atoi(*argv):0;
2118             int count = argc > 1 ? atoi(argv[1]): 0;
2119             int endless = !count;
2120
2121             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2122                 wrong_args("--gen-random 0|1|2 [count]");
2123
2124             while( endless || count ) {
2125                 byte *p;
2126                 /* Wee need a multiple of 3, so that in case of
2127                    armored output we get a correct string.  No
2128                    linefolding is done, as it is best to levae this to
2129                    other tools */
2130                 size_t n = !endless && count < 99? count : 99;
2131
2132                 p = get_random_bits( n*8, level, 0);
2133               #ifdef HAVE_DOSISH_SYSTEM
2134                 setmode ( fileno(stdout), O_BINARY );
2135               #endif
2136                 if (opt.armor) {
2137                     char *tmp = make_radix64_string (p, n);
2138                     fputs (tmp, stdout);
2139                     m_free (tmp);
2140                     if (n%3 == 1)
2141                       putchar ('=');
2142                     if (n%3)
2143                       putchar ('=');
2144                 } else {
2145                     fwrite( p, n, 1, stdout );
2146                 }
2147                 m_free(p);
2148                 if( !endless )
2149                     count -= n;
2150             }
2151             if (opt.armor)
2152                 putchar ('\n');
2153         }
2154         break;
2155
2156       case aPrintMD:
2157         if( argc < 1)
2158             wrong_args("--print-md algo [files]");
2159         {
2160             int all_algos = (**argv=='*' && !(*argv)[1]);
2161             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2162
2163             if( !algo && !all_algos )
2164                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2165             else {
2166                 argc--; argv++;
2167                 if( !argc )
2168                     print_mds(NULL, algo);
2169                 else {
2170                     for(; argc; argc--, argv++ )
2171                         print_mds(*argv, algo);
2172                 }
2173             }
2174         }
2175         break;
2176
2177       case aPrintMDs: /* old option */
2178         if( !argc )
2179             print_mds(NULL,0);
2180         else {
2181             for(; argc; argc--, argv++ )
2182                 print_mds(*argv,0);
2183         }
2184         break;
2185
2186       case aListTrustDB:
2187         if( !argc )
2188             list_trustdb(NULL);
2189         else {
2190             for( ; argc; argc--, argv++ )
2191                 list_trustdb( *argv );
2192         }
2193         break;
2194
2195       case aUpdateTrustDB:
2196         if( argc )
2197             wrong_args("--update-trustdb");
2198         update_trustdb();
2199         break;
2200
2201       case aCheckTrustDB:
2202         /* Old versions allowed for arguments - ignore them */
2203         check_trustdb();
2204         break;
2205
2206       case aFixTrustDB:
2207         log_error("this command is not yet implemented.\n");
2208         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2209         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2210         break;
2211
2212       case aListTrustPath:
2213         if( !argc )
2214             wrong_args("--list-trust-path <user-ids>");
2215         for( ; argc; argc--, argv++ ) {
2216             username = make_username( *argv );
2217             list_trust_path( username );
2218             m_free(username);
2219         }
2220         break;
2221
2222       case aExportOwnerTrust:
2223         if( argc )
2224             wrong_args("--export-ownertrust");
2225         export_ownertrust();
2226         break;
2227
2228       case aImportOwnerTrust:
2229         if( argc > 1 )
2230             wrong_args("--import-ownertrust [file]");
2231         import_ownertrust( argc? *argv:NULL );
2232         break;
2233       
2234       case aPipeMode:
2235         if ( argc )
2236             wrong_args ("--pipemode");
2237         run_in_pipemode ();
2238         break;
2239
2240       case aRebuildKeydbCaches:
2241         if (argc)
2242             wrong_args ("--rebuild-keydb-caches");
2243         keydb_rebuild_caches ();
2244         break;
2245
2246       case aListPackets:
2247         opt.list_packets=2;
2248       default:
2249         if( argc > 1 )
2250             wrong_args(_("[filename]"));
2251         /* Issue some output for the unix newbie */
2252         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2253                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2254             log_info(_("Go ahead and type your message ...\n"));
2255
2256         if( !(a = iobuf_open(fname)) )
2257             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2258         else {
2259
2260             if( !opt.no_armor ) {
2261                 if( use_armor_filter( a ) ) {
2262                     memset( &afx, 0, sizeof afx);
2263                     iobuf_push_filter( a, armor_filter, &afx );
2264                 }
2265             }
2266             if( cmd == aListPackets ) {
2267                 set_packet_list_mode(1);
2268                 opt.list_packets=1;
2269             }
2270             rc = proc_packets(NULL, a );
2271             if( rc )
2272                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2273             iobuf_close(a);
2274         }
2275         break;
2276     }
2277
2278     /* cleanup */
2279     FREE_STRLIST(remusr);
2280     FREE_STRLIST(locusr);
2281     g10_exit(0);
2282     return 8; /*NEVER REACHED*/
2283 }
2284
2285
2286 void
2287 g10_exit( int rc )
2288 {
2289     update_random_seed_file();
2290     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2291         m_print_stats("on exit");
2292         random_dump_stats();
2293     }
2294     if( opt.debug )
2295         secmem_dump_stats();
2296     secmem_term();
2297     rc = rc? rc : log_get_errorcount(0)? 2 :
2298                         g10_errors_seen? 1 : 0;
2299     exit(rc );
2300 }
2301
2302
2303
2304
2305 static void
2306 print_hex( byte *p, size_t n )
2307 {
2308     int i;
2309
2310     if( n == 20 ) {
2311         for(i=0; i < n ; i++, i++, p += 2 ) {
2312             if( i )
2313                 putchar(' ');
2314             if( i == 10 )
2315                 putchar(' ');
2316             printf("%02X%02X", *p, p[1] );
2317         }
2318     }
2319     else if( n == 24 ) {
2320         for(i=0; i < n ; i += 4, p += 4 ) {
2321             if( i )
2322                 putchar(' ');
2323             if( i == 12 )
2324                 putchar(' ');
2325             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2326         }
2327     }
2328     else {
2329         for(i=0; i < n ; i++, p++ ) {
2330             if( i )
2331                 putchar(' ');
2332             if( i && !(i%8) )
2333                 putchar(' ');
2334             printf("%02X", *p );
2335         }
2336     }
2337 }
2338
2339 static void
2340 print_hashline( MD_HANDLE md, int algo, const char *fname )
2341 {
2342     int i, n;
2343     const byte *p;
2344     
2345     if ( fname ) {
2346         for (p = fname; *p; p++ ) {
2347             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2348                 printf("%%%02X", *p );
2349             else 
2350                 putchar( *p );
2351         }
2352     }
2353     putchar(':');
2354     printf("%d:", algo );
2355     p = md_read( md, algo );
2356     n = md_digest_length(algo);
2357     for(i=0; i < n ; i++, p++ ) 
2358         printf("%02X", *p );
2359     putchar(':');
2360     putchar('\n');
2361 }
2362
2363 static void
2364 print_mds( const char *fname, int algo )
2365 {
2366     FILE *fp;
2367     char buf[1024];
2368     size_t n;
2369     MD_HANDLE md;
2370     char *pname;
2371
2372     if( !fname ) {
2373         fp = stdin;
2374       #ifdef HAVE_DOSISH_SYSTEM
2375         setmode ( fileno(fp) , O_BINARY );
2376       #endif
2377         pname = m_strdup("[stdin]: ");
2378     }
2379     else {
2380         pname = m_alloc(strlen(fname)+3);
2381         strcpy(stpcpy(pname,fname),": ");
2382         fp = fopen( fname, "rb" );
2383     }
2384     if( !fp ) {
2385         log_error("%s%s\n", pname, strerror(errno) );
2386         m_free(pname);
2387         return;
2388     }
2389
2390     md = md_open( 0, 0 );
2391     if( algo )
2392         md_enable( md, algo );
2393     else {
2394         md_enable( md, DIGEST_ALGO_MD5 );
2395         md_enable( md, DIGEST_ALGO_SHA1 );
2396         md_enable( md, DIGEST_ALGO_RMD160 );
2397         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2398             md_enable( md, DIGEST_ALGO_TIGER );
2399     }
2400
2401     while( (n=fread( buf, 1, DIM(buf), fp )) )
2402         md_write( md, buf, n );
2403     if( ferror(fp) )
2404         log_error("%s%s\n", pname, strerror(errno) );
2405     else {
2406         md_final(md);
2407         if ( opt.with_colons ) {
2408             if ( algo ) 
2409                 print_hashline( md, algo, fname );
2410             else {
2411                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2412                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2413                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2414                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2415                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2416             }
2417         }
2418         else {
2419             if( algo ) {
2420                 if( fname )
2421                     fputs( pname, stdout );
2422                 print_hex(md_read(md, algo), md_digest_length(algo) );
2423             }
2424             else {
2425                 printf(  "%s   MD5 = ", fname?pname:"" );
2426                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2427                 printf("\n%s  SHA1 = ", fname?pname:""  );
2428                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2429                 printf("\n%sRMD160 = ", fname?pname:""  );
2430                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2431                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2432                     printf("\n%s TIGER = ", fname?pname:""  );
2433                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2434                 }
2435             }
2436             putchar('\n');
2437         }
2438     }
2439     md_close(md);
2440
2441     if( fp != stdin )
2442         fclose(fp);
2443 }
2444
2445
2446 /****************
2447  * Check the supplied name,value string and add it to the notation
2448  * data to be used for signatures.  which==0 for sig notations, and 1
2449  * for cert notations.
2450 */
2451 static void
2452 add_notation_data( const char *string, int which )
2453 {
2454     const char *s;
2455     STRLIST sl,*notation_data;
2456     int critical=0;
2457     int highbit=0;
2458
2459     if(which)
2460       notation_data=&opt.cert_notation_data;
2461     else
2462       notation_data=&opt.sig_notation_data;
2463
2464     if( *string == '!' ) {
2465         critical = 1;
2466         string++;
2467     }
2468
2469     for( s=string ; *s != '='; s++ ) {
2470         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) ) {
2471             log_error(_("a notation name must have only printable characters "
2472                         "or spaces, and end with an '='\n") );
2473             return;
2474         }
2475     }
2476     /* we only support printable text - therefore we enforce the use
2477      * of only printable characters (an empty value is valid) */
2478     for( s++; *s ; s++ ) {
2479         if( iscntrl(*s) ) {
2480             log_error(_("a notation value must not use "
2481                         "any control characters\n") );
2482             return;
2483         }
2484         else if( *s & 0x80 )
2485             highbit = 1;
2486     }
2487
2488     if( highbit )   /* must use UTF8 encoding */
2489         sl = add_to_strlist2( notation_data, string, utf8_strings );
2490     else
2491         sl = add_to_strlist( notation_data, string );
2492
2493     if( critical )
2494         sl->flags |= 1;
2495 }
2496
2497
2498 static void
2499 add_policy_url( const char *string, int which )
2500 {
2501   int i,critical=0;
2502   STRLIST sl;
2503
2504   if(*string=='!')
2505     {
2506       string++;
2507       critical=1;
2508     }
2509
2510   for(i=0;i<strlen(string);i++)
2511     if(string[i]&0x80 || iscntrl(string[i]))
2512       break;
2513
2514   if(i==0 || i<strlen(string))
2515     {
2516       if(which)
2517         log_error(_("the given certification policy URL is invalid\n"));
2518       else
2519         log_error(_("the given signature policy URL is invalid\n"));
2520     }
2521
2522   if(which)
2523     sl=add_to_strlist( &opt.cert_policy_url, string );
2524   else
2525     sl=add_to_strlist( &opt.sig_policy_url, string );
2526
2527   if(critical)
2528     sl->flags |= 1;    
2529 }