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