* options.h, g10.c (main), keyserver.c (keyserver_refresh): Maintain and
[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             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1326             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1327               log_error(_("could not parse keyserver URI\n"));
1328             break;
1329           case oKeyServerOptions:
1330             parse_keyserver_options(pargs.r.ret_str);
1331             break;
1332           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1333           case oExecPath:
1334             {
1335               /* Notice that path is never freed.  That is
1336                  intentional due to the way putenv() works. */
1337               char *path=m_alloc(5+strlen(pargs.r.ret_str)+1);
1338               strcpy(path,"PATH=");
1339               strcat(path,pargs.r.ret_str);
1340               if(putenv(path)!=0)
1341                 log_error(_("unable to set exec-path to %s\n"),path);
1342             }
1343             break;
1344           case oNotation:
1345             add_notation_data( pargs.r.ret_str, 0 );
1346             add_notation_data( pargs.r.ret_str, 1 );
1347             break;
1348           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1349           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1350           case oShowNotation: opt.show_notation=1; break;
1351           case oNoShowNotation: opt.show_notation=0; break;
1352           case oUtf8Strings: utf8_strings = 1; break;
1353           case oNoUtf8Strings: utf8_strings = 0; break;
1354           case oDisableCipherAlgo:
1355                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1356                 break;
1357           case oDisablePubkeyAlgo:
1358                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1359                 break;
1360           case oNoSigCache: opt.no_sig_cache = 1; break;
1361           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1362           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1363           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1364           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1365           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1366           case oNoLiteral: opt.no_literal = 1; break;
1367           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1368           case oHonorHttpProxy:
1369                 opt.keyserver_options.honor_http_proxy = 1;
1370                 deprecated_warning(configname,configlineno,
1371                                    "--honor-http-proxy",
1372                                    "--keyserver-options ",
1373                                    "honor-http-proxy");
1374                 break;
1375           case oFastListMode: opt.fast_list_mode = 1; break;
1376           case oFixedListMode: opt.fixed_list_mode = 1; break;
1377           case oListOnly: opt.list_only=1; break;
1378           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1379           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1380           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1381           case oNoRandomSeedFile: use_random_seed = 0; break;
1382           case oAutoKeyRetrieve:
1383           case oNoAutoKeyRetrieve:
1384                 opt.keyserver_options.auto_key_retrieve=
1385                                              (pargs.r_opt==oAutoKeyRetrieve);
1386                 deprecated_warning(configname,configlineno,
1387                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1388                                "--no-auto-key-retrieve","--keyserver-options ",
1389                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1390                                "no-auto-key-retrieve");
1391                 break;
1392           case oShowSessionKey: opt.show_session_key = 1; break;
1393           case oOverrideSessionKey:
1394                 opt.override_session_key = pargs.r.ret_str;
1395                 break;
1396           case oMergeOnly: opt.merge_only = 1; break;
1397           case oAllowSecretKeyImport: /* obsolete */ break;
1398           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1399           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1400           case oEnableSpecialFilenames:
1401             iobuf_enable_special_filenames (1);
1402             break;
1403           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1404           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1405           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1406           case oPreservePermissions: opt.preserve_permissions=1; break;
1407           case oDefaultPreferenceList:
1408             opt.def_preference_list = pargs.r.ret_str;
1409             break;
1410           case oPersonalCipherPreferences:
1411             pers_cipher_list=pargs.r.ret_str;
1412             break;
1413           case oPersonalDigestPreferences:
1414             pers_digest_list=pargs.r.ret_str;
1415             break;
1416           case oPersonalCompressPreferences:
1417             pers_compress_list=pargs.r.ret_str;
1418             break;
1419           case oDisplay: opt.display = pargs.r.ret_str; break;
1420           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1421           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1422           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1423           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1424           case oGroup: add_group(pargs.r.ret_str); break;
1425           default : pargs.err = configfp? 1:2; break;
1426         }
1427     }
1428
1429     if( configfp ) {
1430         fclose( configfp );
1431         configfp = NULL;
1432         m_free(configname); configname = NULL;
1433         goto next_pass;
1434     }
1435     m_free( configname ); configname = NULL;
1436     if( log_get_errorcount(0) )
1437         g10_exit(2);
1438     if( nogreeting )
1439         greeting = 0;
1440
1441     if( greeting ) {
1442         fprintf(stderr, "%s %s; %s\n",
1443                         strusage(11), strusage(13), strusage(14) );
1444         fprintf(stderr, "%s\n", strusage(15) );
1445     }
1446   #ifdef IS_DEVELOPMENT_VERSION
1447     if( !opt.batch ) {
1448         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1449         log_info("It is only intended for test purposes and should NOT be\n");
1450         log_info("used in a production environment or with production keys!\n");
1451     }
1452   #endif
1453
1454     check_permissions(opt.homedir,0,0);
1455
1456     if(unsafe_files)
1457       {
1458         STRLIST tmp;
1459
1460         for(tmp=unsafe_files;tmp;tmp=tmp->next)
1461           check_permissions(tmp->d,0,0);
1462
1463         free_strlist(unsafe_files);
1464       }
1465
1466     if(extensions)
1467       {
1468         STRLIST tmp;
1469
1470         for(tmp=extensions;tmp;tmp=tmp->next)
1471           check_permissions(tmp->d,1,0);
1472
1473         free_strlist(extensions);
1474       }
1475
1476     if( may_coredump && !opt.quiet )
1477         log_info(_("WARNING: program may create a core file!\n"));
1478
1479     if (eyes_only) {
1480       if (opt.set_filename)
1481           log_info(_("WARNING: %s overrides %s\n"),
1482                    "--for-your-eyes-only","--set-filename");
1483
1484       opt.set_filename="_CONSOLE";
1485     }
1486
1487     if (opt.no_literal) {
1488         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1489         if (opt.textmode)
1490             log_error(_("%s not allowed with %s!\n"),
1491                        "--textmode", "--no-literal" );
1492         if (opt.set_filename)
1493             log_error(_("%s makes no sense with %s!\n"),
1494                         eyes_only?"--for-your-eyes-only":"--set-filename",
1495                         "--no-literal" );
1496     }
1497
1498     if (opt.set_filesize)
1499         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1500     if( opt.batch )
1501         tty_batchmode( 1 );
1502
1503     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1504
1505     set_debug();
1506     g10_opt_homedir = opt.homedir;
1507
1508     /* Do these after the switch(), so they can override settings. */
1509     if(opt.pgp2 && (opt.pgp6 || opt.pgp7))
1510       log_error(_("%s not allowed with %s!\n"),
1511                 "--pgp2",opt.pgp6?"--pgp6":"--pgp7");
1512     else
1513       {
1514         if(opt.pgp2)
1515           {
1516             int unusable=0;
1517
1518             if(cmd==aSign && !detached_sig)
1519               {
1520                 log_info(_("you can only make detached or clear signatures "
1521                            "while in --pgp2 mode\n"));
1522                 unusable=1;
1523               }
1524             else if(cmd==aSignEncr || cmd==aSignSym)
1525               {
1526                 log_info(_("you can't sign and encrypt at the "
1527                            "same time while in --pgp2 mode\n"));
1528                 unusable=1;
1529               }
1530             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1531               {
1532                 log_info(_("you must use files (and not a pipe) when "
1533                            "working with --pgp2 enabled.\n"));
1534                 unusable=1;
1535               }
1536             else if(cmd==aEncr || cmd==aSym)
1537               {
1538                 /* Everything else should work without IDEA (except using
1539                    a secret key encrypted with IDEA and setting an IDEA
1540                    preference, but those have their own error
1541                    messages). */
1542
1543                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1544                   {
1545                     log_info(_("encrypting a message in --pgp2 mode requires "
1546                                "the IDEA cipher\n"));
1547                     idea_cipher_warn(1);
1548                     unusable=1;
1549                   }
1550                 else if(cmd==aSym)
1551                   {
1552                     m_free(def_cipher_string);
1553                     def_cipher_string = m_strdup("idea");
1554                   }
1555               }
1556
1557             if(unusable)
1558               {
1559                 log_info(_("this message may not be usable by PGP 2.x\n"));
1560                 opt.pgp2=0;
1561               }
1562             else
1563               {
1564                 opt.rfc1991 = 1;
1565                 opt.rfc2440 = 0;
1566                 opt.force_mdc = 0;
1567                 opt.disable_mdc = 1;
1568                 opt.force_v4_certs = 0;
1569                 opt.sk_comments = 0;
1570                 opt.escape_from = 1;
1571                 opt.force_v3_sigs = 1;
1572                 opt.pgp2_workarounds = 1;
1573                 opt.ask_sig_expire = 0;
1574                 opt.ask_cert_expire = 0;
1575                 m_free(def_digest_string);
1576                 def_digest_string = m_strdup("md5");
1577                 opt.def_compress_algo = 1;
1578               }
1579           }
1580
1581         if(opt.pgp6 || opt.pgp7)
1582           {
1583             opt.force_mdc=0;
1584             opt.disable_mdc=1;
1585             opt.sk_comments=0;
1586             opt.escape_from=1;
1587             opt.force_v3_sigs=1;
1588             opt.ask_sig_expire=0;
1589             opt.def_compress_algo=1;
1590           }
1591       }
1592
1593     /* must do this after dropping setuid, because string_to...
1594      * may try to load an module */
1595     if( def_cipher_string ) {
1596         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1597         if(opt.def_cipher_algo==0 &&
1598            ascii_strcasecmp(def_cipher_string,"idea")==0)
1599           idea_cipher_warn(1);
1600         m_free(def_cipher_string); def_cipher_string = NULL;
1601         if( check_cipher_algo(opt.def_cipher_algo) )
1602             log_error(_("selected cipher algorithm is invalid\n"));
1603     }
1604     if( def_digest_string ) {
1605         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1606         m_free(def_digest_string); def_digest_string = NULL;
1607         if( check_digest_algo(opt.def_digest_algo) )
1608             log_error(_("selected digest algorithm is invalid\n"));
1609     }
1610     if( cert_digest_string ) {
1611         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1612         m_free(cert_digest_string); cert_digest_string = NULL;
1613         if( check_digest_algo(opt.cert_digest_algo) )
1614             log_error(_("selected certification digest algorithm is invalid\n"));
1615     }
1616     if( s2k_cipher_string ) {
1617         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
1618         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
1619         if( check_cipher_algo(opt.s2k_cipher_algo) )
1620             log_error(_("selected cipher algorithm is invalid\n"));
1621     }
1622     if( s2k_digest_string ) {
1623         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
1624         m_free(s2k_digest_string); s2k_digest_string = NULL;
1625         if( check_digest_algo(opt.s2k_digest_algo) )
1626             log_error(_("selected digest algorithm is invalid\n"));
1627     }
1628     if( opt.def_compress_algo < -1 || opt.def_compress_algo > 2 )
1629         log_error(_("compress algorithm must be in range %d..%d\n"), 0, 2);
1630     if( opt.completes_needed < 1 )
1631         log_error(_("completes-needed must be greater than 0\n"));
1632     if( opt.marginals_needed < 2 )
1633         log_error(_("marginals-needed must be greater than 1\n"));
1634     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1635         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1636     switch( opt.s2k_mode ) {
1637       case 0:
1638         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1639         break;
1640       case 1: case 3: break;
1641       default:
1642         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1643     }
1644
1645     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
1646       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
1647
1648     /* This isn't actually needed, but does serve to error out if the
1649        string is invalid. */
1650     if(opt.def_preference_list &&
1651         keygen_set_std_prefs(opt.def_preference_list,0))
1652       log_error(_("invalid default preferences\n"));
1653
1654     /* We provide defaults for the personal digest list */
1655     if(!pers_digest_list)
1656       pers_digest_list="h2";
1657
1658     if(pers_cipher_list &&
1659        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
1660       log_error(_("invalid personal cipher preferences\n"));
1661
1662     if(pers_digest_list &&
1663        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
1664       log_error(_("invalid personal digest preferences\n"));
1665
1666     if(pers_compress_list &&
1667        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
1668       log_error(_("invalid personal compress preferences\n"));
1669
1670     if( log_get_errorcount(0) )
1671         g10_exit(2);
1672
1673     /* set the random seed file */
1674     if( use_random_seed ) {
1675         char *p = make_filename(opt.homedir, "random_seed", NULL );
1676         check_permissions(p,0,0);
1677         set_random_seed_file(p);
1678         m_free(p);
1679     }
1680
1681     if( !cmd && opt.fingerprint && !with_fpr ) {
1682         set_cmd( &cmd, aListKeys);
1683     }
1684
1685     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1686         if( cmd == aKModeC ) {
1687             opt.fingerprint = 1;
1688             cmd = aKMode;
1689         }
1690         opt.list_sigs = 0;
1691         if( opt.verbose > 2 )
1692             opt.check_sigs++;
1693         if( opt.verbose > 1 )
1694             opt.list_sigs++;
1695
1696         opt.verbose = opt.verbose > 1;
1697         g10_opt_verbose = opt.verbose;
1698     }
1699
1700     /* Compression algorithm 0 means no compression at all */
1701     if( opt.def_compress_algo == 0)
1702         opt.compress = 0;
1703
1704     /* kludge to let -sat generate a clear text signature */
1705     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1706         cmd = aClearsign;
1707
1708     if( opt.verbose > 1 )
1709         set_packet_list_mode(1);
1710
1711     /* Add the keyrings, but not for some special commands and not in
1712        case of "-kvv userid keyring".  Also avoid adding the secret
1713        keyring for a couple of commands to avoid unneeded access in
1714        case the secrings are stored on a floppy */
1715     if( cmd != aDeArmor && cmd != aEnArmor
1716         && !(cmd == aKMode && argc == 2 ) ) 
1717       {
1718         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
1719             && cmd != aVerify && cmd != aVerifyFiles
1720             && cmd != aSym)
1721           {
1722             if (!sec_nrings || default_keyring) /* add default secret rings */
1723               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
1724             for (sl = sec_nrings; sl; sl = sl->next)
1725               keydb_add_resource ( sl->d, 0, 1 );
1726           }
1727         if( !nrings || default_keyring )  /* add default ring */
1728             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
1729         for(sl = nrings; sl; sl = sl->next )
1730             keydb_add_resource ( sl->d, 0, 0 );
1731       }
1732     FREE_STRLIST(nrings);
1733     FREE_STRLIST(sec_nrings);
1734
1735
1736     if( pwfd != -1 )  /* read the passphrase now. */
1737         read_passphrase_from_fd( pwfd );
1738
1739     fname = argc? *argv : NULL;
1740
1741     switch( cmd ) {
1742       case aPrimegen:
1743       case aPrintMD:
1744       case aPrintMDs:
1745       case aGenRandom:
1746       case aDeArmor:
1747       case aEnArmor:
1748       case aFixTrustDB:
1749         break;
1750       case aKMode:
1751       case aListKeys:
1752       case aListSecretKeys:
1753       case aCheckKeys:
1754         if( opt.with_colons ) /* need this to list the trust */
1755             rc = setup_trustdb(1, trustdb_name );
1756         break;
1757       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1758       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1759       default: rc = setup_trustdb(1, trustdb_name ); break;
1760     }
1761     if( rc )
1762         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1763
1764
1765     switch (cmd) {
1766       case aStore: 
1767       case aSym:  
1768       case aSign: 
1769       case aSignSym: 
1770       case aClearsign: 
1771         if (!opt.quiet && any_explicit_recipient)
1772           log_info (_("WARNING: recipients (-r) given "
1773                       "without using public key encryption\n"));
1774         break;
1775       default:
1776         break;
1777     }
1778
1779     switch( cmd ) {
1780       case aStore: /* only store the file */
1781         if( argc > 1 )
1782             wrong_args(_("--store [filename]"));
1783         if( (rc = encode_store(fname)) )
1784             log_error_f( print_fname_stdin(fname),
1785                         "store failed: %s\n", g10_errstr(rc) );
1786         break;
1787       case aSym: /* encrypt the given file only with the symmetric cipher */
1788         if( argc > 1 )
1789             wrong_args(_("--symmetric [filename]"));
1790         if( (rc = encode_symmetric(fname)) )
1791             log_error_f(print_fname_stdin(fname),
1792                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1793         break;
1794
1795       case aEncr: /* encrypt the given file */
1796         if( argc > 1 )
1797             wrong_args(_("--encrypt [filename]"));
1798         if( (rc = encode_crypt(fname,remusr)) )
1799             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1800         break;
1801
1802       case aEncrFiles: /* encrypt the given files */
1803         encode_crypt_files(argc, argv, remusr);
1804         break;
1805           
1806       case aSign: /* sign the given file */
1807         sl = NULL;
1808         if( detached_sig ) { /* sign all files */
1809             for( ; argc; argc--, argv++ )
1810                 add_to_strlist( &sl, *argv );
1811         }
1812         else {
1813             if( argc > 1 )
1814                 wrong_args(_("--sign [filename]"));
1815             if( argc ) {
1816                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1817                 strcpy(sl->d, fname);
1818             }
1819         }
1820         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1821             log_error("signing failed: %s\n", g10_errstr(rc) );
1822         free_strlist(sl);
1823         break;
1824
1825       case aSignEncr: /* sign and encrypt the given file */
1826         if( argc > 1 )
1827             wrong_args(_("--sign --encrypt [filename]"));
1828         if( argc ) {
1829             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1830             strcpy(sl->d, fname);
1831         }
1832         else
1833             sl = NULL;
1834         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1835             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1836         free_strlist(sl);
1837         break;
1838
1839       case aSignSym: /* sign and conventionally encrypt the given file */
1840         if (argc > 1)
1841             wrong_args(_("--sign --symmetric [filename]"));
1842         rc = sign_symencrypt_file (fname, locusr);
1843         if (rc)
1844             log_error("%s: sign+symmetric failed: %s\n",
1845                       print_fname_stdin(fname), g10_errstr(rc) );
1846         break;
1847
1848       case aClearsign: /* make a clearsig */
1849         if( argc > 1 )
1850             wrong_args(_("--clearsign [filename]"));
1851         if( (rc = clearsign_file(fname, locusr, NULL)) )
1852             log_error("%s: clearsign failed: %s\n",
1853                       print_fname_stdin(fname), g10_errstr(rc) );
1854         break;
1855
1856       case aVerify:
1857         if( (rc = verify_signatures( argc, argv ) ))
1858             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1859         break;
1860
1861       case aVerifyFiles:
1862         if( (rc = verify_files( argc, argv ) ))
1863             log_error("verify files failed: %s\n", g10_errstr(rc) );
1864         break;
1865
1866       case aDecrypt:
1867         if( argc > 1 )
1868             wrong_args(_("--decrypt [filename]"));
1869         if( (rc = decrypt_message( fname ) ))
1870             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1871         break;
1872
1873       case aDecryptFiles:
1874         decrypt_messages(argc, argv);
1875         break;
1876             
1877       case aSignKey: /* sign the key given as argument */
1878         if( argc != 1 )
1879             wrong_args(_("--sign-key user-id"));
1880         username = make_username( fname );
1881         keyedit_menu(fname, locusr, NULL, 1 );
1882         m_free(username);
1883         break;
1884
1885       case aLSignKey:
1886         if( argc != 1 )
1887             wrong_args(_("--lsign-key user-id"));
1888         username = make_username( fname );
1889         keyedit_menu(fname, locusr, NULL, 2 );
1890         m_free(username);
1891         break;
1892
1893       case aNRSignKey:
1894         if( argc != 1 )
1895             wrong_args(_("--nrsign-key user-id"));
1896         username = make_username( fname );
1897         keyedit_menu(fname, locusr, NULL, 3 );
1898         m_free(username);
1899         break;
1900
1901       case aNRLSignKey:
1902         if( argc != 1 )
1903             wrong_args(_("--nrlsign-key user-id"));
1904         username = make_username( fname );
1905         keyedit_menu(fname, locusr, NULL, 4 );
1906         m_free(username);
1907         break;
1908
1909       case aEditKey: /* Edit a key signature */
1910         if( !argc )
1911             wrong_args(_("--edit-key user-id [commands]"));
1912         username = make_username( fname );
1913         if( argc > 1 ) {
1914             sl = NULL;
1915             for( argc--, argv++ ; argc; argc--, argv++ )
1916                 append_to_strlist( &sl, *argv );
1917             keyedit_menu( username, locusr, sl, 0 );
1918             free_strlist(sl);
1919         }
1920         else
1921             keyedit_menu(username, locusr, NULL, 0 );
1922         m_free(username);
1923         break;
1924
1925       case aDeleteKeys:
1926       case aDeleteSecretKeys:
1927       case aDeleteSecretAndPublicKeys:
1928         sl = NULL;
1929         /* I'm adding these in reverse order as add_to_strlist2
1930            reverses them again, and it's easier to understand in the
1931            proper order :) */
1932         for( ; argc; argc-- )
1933           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
1934         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
1935         free_strlist(sl);
1936         break;
1937
1938       case aCheckKeys:
1939         opt.check_sigs = 1;
1940       case aListSigs:
1941         opt.list_sigs = 1;
1942       case aListKeys:
1943         sl = NULL;
1944         for( ; argc; argc--, argv++ )
1945             add_to_strlist2( &sl, *argv, utf8_strings );
1946         public_key_list( sl );
1947         free_strlist(sl);
1948         break;
1949       case aListSecretKeys:
1950         sl = NULL;
1951         for( ; argc; argc--, argv++ )
1952             add_to_strlist2( &sl, *argv, utf8_strings );
1953         secret_key_list( sl );
1954         free_strlist(sl);
1955         break;
1956
1957       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1958         if( argc < 2 ) { /* -kv [userid] */
1959             sl = NULL;
1960             if (argc && **argv)
1961                 add_to_strlist2( &sl, *argv, utf8_strings );
1962             public_key_list( sl );
1963             free_strlist(sl);
1964         }
1965         else if( argc == 2 ) { /* -kv userid keyring */
1966             if( access( argv[1], R_OK ) ) {
1967                 log_error(_("can't open %s: %s\n"),
1968                                print_fname_stdin(argv[1]), strerror(errno));
1969             }
1970             else {
1971                 /* add keyring (default keyrings are not registered in this
1972                  * special case */
1973                 keydb_add_resource( argv[1], 0, 0 );
1974                 sl = NULL;
1975                 if (**argv)
1976                     add_to_strlist2( &sl, *argv, utf8_strings );
1977                 public_key_list( sl );
1978                 free_strlist(sl);
1979             }
1980         }
1981         else
1982             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
1983         break;
1984
1985       case aKeygen: /* generate a key */
1986         if( opt.batch ) {
1987             if( argc > 1 )
1988                 wrong_args("--gen-key [parameterfile]");
1989             generate_keypair( argc? *argv : NULL );
1990         }
1991         else {
1992             if( argc )
1993                 wrong_args("--gen-key");
1994             generate_keypair(NULL);
1995         }
1996         break;
1997
1998       case aFastImport:
1999       case aImport:
2000         import_keys( argc? argv:NULL, argc, (cmd == aFastImport), NULL );
2001         break;
2002
2003       case aExport:
2004       case aExportAll:
2005       case aSendKeys:
2006       case aRecvKeys:
2007         sl = NULL;
2008         for( ; argc; argc--, argv++ )
2009             add_to_strlist2( &sl, *argv, utf8_strings );
2010         if( cmd == aSendKeys )
2011             keyserver_export( sl );
2012         else if( cmd == aRecvKeys )
2013             keyserver_import( sl );
2014         else
2015             export_pubkeys( sl, (cmd == aExport) );
2016         free_strlist(sl);
2017         break;
2018
2019      case aSearchKeys:
2020         sl = NULL;
2021         for( ; argc; argc--, argv++ )
2022           append_to_strlist2( &sl, *argv, utf8_strings );
2023
2024         keyserver_search( sl );
2025         free_strlist(sl);
2026         break;
2027
2028       case aRefreshKeys:
2029         sl = NULL;
2030         for( ; argc; argc--, argv++ )
2031             add_to_strlist2( &sl, *argv, utf8_strings );
2032         keyserver_refresh(sl);
2033         free_strlist(sl);
2034         break;
2035
2036       case aExportSecret:
2037         sl = NULL;
2038         for( ; argc; argc--, argv++ )
2039             add_to_strlist2( &sl, *argv, utf8_strings );
2040         export_seckeys( sl );
2041         free_strlist(sl);
2042         break;
2043
2044       case aExportSecretSub:
2045         sl = NULL;
2046         for( ; argc; argc--, argv++ )
2047             add_to_strlist2( &sl, *argv, utf8_strings );
2048         export_secsubkeys( sl );
2049         free_strlist(sl);
2050         break;
2051
2052       case aGenRevoke:
2053         if( argc != 1 )
2054             wrong_args("--gen-revoke user-id");
2055         username =  make_username(*argv);
2056         gen_revoke( username );
2057         m_free( username );
2058         break;
2059
2060       case aDesigRevoke:
2061         if( argc != 1 )
2062             wrong_args("--desig-revoke user-id");
2063         username =  make_username(*argv);
2064         gen_desig_revoke( username );
2065         m_free( username );
2066         break;
2067
2068       case aDeArmor:
2069         if( argc > 1 )
2070             wrong_args("--dearmor [file]");
2071         rc = dearmor_file( argc? *argv: NULL );
2072         if( rc )
2073             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2074         break;
2075
2076       case aEnArmor:
2077         if( argc > 1 )
2078             wrong_args("--enarmor [file]");
2079         rc = enarmor_file( argc? *argv: NULL );
2080         if( rc )
2081             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2082         break;
2083
2084
2085       case aPrimegen:
2086         {   int mode = argc < 2 ? 0 : atoi(*argv);
2087
2088             if( mode == 1 && argc == 2 ) {
2089                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2090             }
2091             else if( mode == 2 && argc == 3 ) {
2092                 mpi_print( stdout, generate_elg_prime(
2093                                              0, atoi(argv[1]),
2094                                              atoi(argv[2]), NULL,NULL ), 1);
2095             }
2096             else if( mode == 3 && argc == 3 ) {
2097                 MPI *factors;
2098                 mpi_print( stdout, generate_elg_prime(
2099                                              1, atoi(argv[1]),
2100                                              atoi(argv[2]), NULL,&factors ), 1);
2101                 putchar('\n');
2102                 mpi_print( stdout, factors[0], 1 ); /* print q */
2103             }
2104             else if( mode == 4 && argc == 3 ) {
2105                 MPI g = mpi_alloc(1);
2106                 mpi_print( stdout, generate_elg_prime(
2107                                                  0, atoi(argv[1]),
2108                                                  atoi(argv[2]), g, NULL ), 1);
2109                 putchar('\n');
2110                 mpi_print( stdout, g, 1 );
2111                 mpi_free(g);
2112             }
2113             else
2114                 wrong_args("--gen-prime mode bits [qbits] ");
2115             putchar('\n');
2116         }
2117         break;
2118
2119       case aGenRandom:
2120         {
2121             int level = argc ? atoi(*argv):0;
2122             int count = argc > 1 ? atoi(argv[1]): 0;
2123             int endless = !count;
2124
2125             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2126                 wrong_args("--gen-random 0|1|2 [count]");
2127
2128             while( endless || count ) {
2129                 byte *p;
2130                 /* Wee need a multiple of 3, so that in case of
2131                    armored output we get a correct string.  No
2132                    linefolding is done, as it is best to levae this to
2133                    other tools */
2134                 size_t n = !endless && count < 99? count : 99;
2135
2136                 p = get_random_bits( n*8, level, 0);
2137               #ifdef HAVE_DOSISH_SYSTEM
2138                 setmode ( fileno(stdout), O_BINARY );
2139               #endif
2140                 if (opt.armor) {
2141                     char *tmp = make_radix64_string (p, n);
2142                     fputs (tmp, stdout);
2143                     m_free (tmp);
2144                     if (n%3 == 1)
2145                       putchar ('=');
2146                     if (n%3)
2147                       putchar ('=');
2148                 } else {
2149                     fwrite( p, n, 1, stdout );
2150                 }
2151                 m_free(p);
2152                 if( !endless )
2153                     count -= n;
2154             }
2155             if (opt.armor)
2156                 putchar ('\n');
2157         }
2158         break;
2159
2160       case aPrintMD:
2161         if( argc < 1)
2162             wrong_args("--print-md algo [files]");
2163         {
2164             int all_algos = (**argv=='*' && !(*argv)[1]);
2165             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2166
2167             if( !algo && !all_algos )
2168                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2169             else {
2170                 argc--; argv++;
2171                 if( !argc )
2172                     print_mds(NULL, algo);
2173                 else {
2174                     for(; argc; argc--, argv++ )
2175                         print_mds(*argv, algo);
2176                 }
2177             }
2178         }
2179         break;
2180
2181       case aPrintMDs: /* old option */
2182         if( !argc )
2183             print_mds(NULL,0);
2184         else {
2185             for(; argc; argc--, argv++ )
2186                 print_mds(*argv,0);
2187         }
2188         break;
2189
2190       case aListTrustDB:
2191         if( !argc )
2192             list_trustdb(NULL);
2193         else {
2194             for( ; argc; argc--, argv++ )
2195                 list_trustdb( *argv );
2196         }
2197         break;
2198
2199       case aUpdateTrustDB:
2200         if( argc )
2201             wrong_args("--update-trustdb");
2202         update_trustdb();
2203         break;
2204
2205       case aCheckTrustDB:
2206         /* Old versions allowed for arguments - ignore them */
2207         check_trustdb();
2208         break;
2209
2210       case aFixTrustDB:
2211         log_error("this command is not yet implemented.\n");
2212         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2213         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2214         break;
2215
2216       case aListTrustPath:
2217         if( !argc )
2218             wrong_args("--list-trust-path <user-ids>");
2219         for( ; argc; argc--, argv++ ) {
2220             username = make_username( *argv );
2221             list_trust_path( username );
2222             m_free(username);
2223         }
2224         break;
2225
2226       case aExportOwnerTrust:
2227         if( argc )
2228             wrong_args("--export-ownertrust");
2229         export_ownertrust();
2230         break;
2231
2232       case aImportOwnerTrust:
2233         if( argc > 1 )
2234             wrong_args("--import-ownertrust [file]");
2235         import_ownertrust( argc? *argv:NULL );
2236         break;
2237       
2238       case aPipeMode:
2239         if ( argc )
2240             wrong_args ("--pipemode");
2241         run_in_pipemode ();
2242         break;
2243
2244       case aRebuildKeydbCaches:
2245         if (argc)
2246             wrong_args ("--rebuild-keydb-caches");
2247         keydb_rebuild_caches ();
2248         break;
2249
2250       case aListPackets:
2251         opt.list_packets=2;
2252       default:
2253         if( argc > 1 )
2254             wrong_args(_("[filename]"));
2255         /* Issue some output for the unix newbie */
2256         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2257                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2258             log_info(_("Go ahead and type your message ...\n"));
2259
2260         if( !(a = iobuf_open(fname)) )
2261             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2262         else {
2263
2264             if( !opt.no_armor ) {
2265                 if( use_armor_filter( a ) ) {
2266                     memset( &afx, 0, sizeof afx);
2267                     iobuf_push_filter( a, armor_filter, &afx );
2268                 }
2269             }
2270             if( cmd == aListPackets ) {
2271                 set_packet_list_mode(1);
2272                 opt.list_packets=1;
2273             }
2274             rc = proc_packets(NULL, a );
2275             if( rc )
2276                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2277             iobuf_close(a);
2278         }
2279         break;
2280     }
2281
2282     /* cleanup */
2283     FREE_STRLIST(remusr);
2284     FREE_STRLIST(locusr);
2285     g10_exit(0);
2286     return 8; /*NEVER REACHED*/
2287 }
2288
2289
2290 void
2291 g10_exit( int rc )
2292 {
2293     update_random_seed_file();
2294     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2295         m_print_stats("on exit");
2296         random_dump_stats();
2297     }
2298     if( opt.debug )
2299         secmem_dump_stats();
2300     secmem_term();
2301     rc = rc? rc : log_get_errorcount(0)? 2 :
2302                         g10_errors_seen? 1 : 0;
2303     exit(rc );
2304 }
2305
2306
2307
2308
2309 static void
2310 print_hex( byte *p, size_t n )
2311 {
2312     int i;
2313
2314     if( n == 20 ) {
2315         for(i=0; i < n ; i++, i++, p += 2 ) {
2316             if( i )
2317                 putchar(' ');
2318             if( i == 10 )
2319                 putchar(' ');
2320             printf("%02X%02X", *p, p[1] );
2321         }
2322     }
2323     else if( n == 24 ) {
2324         for(i=0; i < n ; i += 4, p += 4 ) {
2325             if( i )
2326                 putchar(' ');
2327             if( i == 12 )
2328                 putchar(' ');
2329             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2330         }
2331     }
2332     else {
2333         for(i=0; i < n ; i++, p++ ) {
2334             if( i )
2335                 putchar(' ');
2336             if( i && !(i%8) )
2337                 putchar(' ');
2338             printf("%02X", *p );
2339         }
2340     }
2341 }
2342
2343 static void
2344 print_hashline( MD_HANDLE md, int algo, const char *fname )
2345 {
2346     int i, n;
2347     const byte *p;
2348     
2349     if ( fname ) {
2350         for (p = fname; *p; p++ ) {
2351             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2352                 printf("%%%02X", *p );
2353             else 
2354                 putchar( *p );
2355         }
2356     }
2357     putchar(':');
2358     printf("%d:", algo );
2359     p = md_read( md, algo );
2360     n = md_digest_length(algo);
2361     for(i=0; i < n ; i++, p++ ) 
2362         printf("%02X", *p );
2363     putchar(':');
2364     putchar('\n');
2365 }
2366
2367 static void
2368 print_mds( const char *fname, int algo )
2369 {
2370     FILE *fp;
2371     char buf[1024];
2372     size_t n;
2373     MD_HANDLE md;
2374     char *pname;
2375
2376     if( !fname ) {
2377         fp = stdin;
2378       #ifdef HAVE_DOSISH_SYSTEM
2379         setmode ( fileno(fp) , O_BINARY );
2380       #endif
2381         pname = m_strdup("[stdin]: ");
2382     }
2383     else {
2384         pname = m_alloc(strlen(fname)+3);
2385         strcpy(stpcpy(pname,fname),": ");
2386         fp = fopen( fname, "rb" );
2387     }
2388     if( !fp ) {
2389         log_error("%s%s\n", pname, strerror(errno) );
2390         m_free(pname);
2391         return;
2392     }
2393
2394     md = md_open( 0, 0 );
2395     if( algo )
2396         md_enable( md, algo );
2397     else {
2398         md_enable( md, DIGEST_ALGO_MD5 );
2399         md_enable( md, DIGEST_ALGO_SHA1 );
2400         md_enable( md, DIGEST_ALGO_RMD160 );
2401         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2402             md_enable( md, DIGEST_ALGO_TIGER );
2403     }
2404
2405     while( (n=fread( buf, 1, DIM(buf), fp )) )
2406         md_write( md, buf, n );
2407     if( ferror(fp) )
2408         log_error("%s%s\n", pname, strerror(errno) );
2409     else {
2410         md_final(md);
2411         if ( opt.with_colons ) {
2412             if ( algo ) 
2413                 print_hashline( md, algo, fname );
2414             else {
2415                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2416                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2417                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2418                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2419                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2420             }
2421         }
2422         else {
2423             if( algo ) {
2424                 if( fname )
2425                     fputs( pname, stdout );
2426                 print_hex(md_read(md, algo), md_digest_length(algo) );
2427             }
2428             else {
2429                 printf(  "%s   MD5 = ", fname?pname:"" );
2430                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2431                 printf("\n%s  SHA1 = ", fname?pname:""  );
2432                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2433                 printf("\n%sRMD160 = ", fname?pname:""  );
2434                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2435                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2436                     printf("\n%s TIGER = ", fname?pname:""  );
2437                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2438                 }
2439             }
2440             putchar('\n');
2441         }
2442     }
2443     md_close(md);
2444
2445     if( fp != stdin )
2446         fclose(fp);
2447 }
2448
2449
2450 /****************
2451  * Check the supplied name,value string and add it to the notation
2452  * data to be used for signatures.  which==0 for sig notations, and 1
2453  * for cert notations.
2454 */
2455 static void
2456 add_notation_data( const char *string, int which )
2457 {
2458     const char *s;
2459     STRLIST sl,*notation_data;
2460     int critical=0;
2461     int highbit=0;
2462
2463     if(which)
2464       notation_data=&opt.cert_notation_data;
2465     else
2466       notation_data=&opt.sig_notation_data;
2467
2468     if( *string == '!' ) {
2469         critical = 1;
2470         string++;
2471     }
2472
2473     for( s=string ; *s != '='; s++ ) {
2474         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) ) {
2475             log_error(_("a notation name must have only printable characters "
2476                         "or spaces, and end with an '='\n") );
2477             return;
2478         }
2479     }
2480     /* we only support printable text - therefore we enforce the use
2481      * of only printable characters (an empty value is valid) */
2482     for( s++; *s ; s++ ) {
2483         if( iscntrl(*s) ) {
2484             log_error(_("a notation value must not use "
2485                         "any control characters\n") );
2486             return;
2487         }
2488         else if( *s & 0x80 )
2489             highbit = 1;
2490     }
2491
2492     if( highbit )   /* must use UTF8 encoding */
2493         sl = add_to_strlist2( notation_data, string, utf8_strings );
2494     else
2495         sl = add_to_strlist( notation_data, string );
2496
2497     if( critical )
2498         sl->flags |= 1;
2499 }
2500
2501
2502 static void
2503 add_policy_url( const char *string, int which )
2504 {
2505   int i,critical=0;
2506   STRLIST sl;
2507
2508   if(*string=='!')
2509     {
2510       string++;
2511       critical=1;
2512     }
2513
2514   for(i=0;i<strlen(string);i++)
2515     if(string[i]&0x80 || iscntrl(string[i]))
2516       break;
2517
2518   if(i==0 || i<strlen(string))
2519     {
2520       if(which)
2521         log_error(_("the given certification policy URL is invalid\n"));
2522       else
2523         log_error(_("the given signature policy URL is invalid\n"));
2524     }
2525
2526   if(which)
2527     sl=add_to_strlist( &opt.cert_policy_url, string );
2528   else
2529     sl=add_to_strlist( &opt.sig_policy_url, string );
2530
2531   if(critical)
2532     sl->flags |= 1;    
2533 }