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