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