* passphrase.c (agent_send_all_options): Make use of $GPG_TTY.
[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 #if defined (_WIN32)
1190     set_homedir ( read_w32_registry_string( NULL,
1191                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1192 #else
1193     set_homedir ( getenv("GNUPGHOME") );
1194 #endif
1195     if( !*opt.homedir )
1196         set_homedir ( GNUPG_HOMEDIR );
1197
1198     /* check whether we have a config file on the commandline */
1199     orig_argc = argc;
1200     orig_argv = argv;
1201     pargs.argc = &argc;
1202     pargs.argv = &argv;
1203     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1204     while( arg_parse( &pargs, opts) ) {
1205         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1206             parse_debug++;
1207         else if( pargs.r_opt == oOptions ) {
1208             /* yes there is one, so we do not try the default one, but
1209              * read the option file when it is encountered at the commandline
1210              */
1211             default_config = 0;
1212         }
1213         else if( pargs.r_opt == oNoOptions )
1214             default_config = 0; /* --no-options */
1215         else if( pargs.r_opt == oHomedir )
1216             set_homedir ( pargs.r.ret_str );
1217         else if( pargs.r_opt == oNoPermissionWarn )
1218             opt.no_perm_warn=1;
1219         else if (pargs.r_opt == oStrict )
1220           {
1221             opt.strict=1;
1222             log_set_strict(1);
1223           }
1224         else if (pargs.r_opt == oNoStrict )
1225           {
1226             opt.strict=0;
1227             log_set_strict(0);
1228           }
1229 #ifdef USE_SHM_COPROCESSING
1230         else if( pargs.r_opt == oRunAsShmCP ) {
1231             /* does not make sense in a options file, we do it here,
1232              * so that we are the able to drop setuid as soon as possible */
1233             opt.shm_coprocess = 1;
1234             requested_shm_size = pargs.r.ret_ulong;
1235         }
1236         else if ( pargs.r_opt == oStatusFD ) {
1237             /* this is needed to ensure that the status-fd filedescriptor is
1238              * initialized when init_shm_coprocessing() is called */
1239             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1240         }
1241 #endif
1242     }
1243
1244 #ifdef HAVE_DOSISH_SYSTEM
1245     if ( strchr (opt.homedir,'\\') ) {
1246         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1247         const char *s = opt.homedir;
1248         for (d=buf,s=opt.homedir; *s; s++)
1249             *d++ = *s == '\\'? '/': *s;
1250         *d = 0;
1251         set_homedir (buf);
1252     }
1253 #endif
1254 #ifdef USE_SHM_COPROCESSING
1255     if( opt.shm_coprocess ) {
1256         init_shm_coprocessing(requested_shm_size, 1 );
1257     }
1258 #endif
1259     /* initialize the secure memory. */
1260     secmem_init( 32768 );
1261     maybe_setuid = 0;
1262     /* Okay, we are now working under our real uid */
1263
1264     set_native_charset (NULL); /* Try to auto set the character set */
1265
1266     if( default_config )
1267       {
1268        /* Try for a version specific config file first */
1269         configname = make_filename(opt.homedir,
1270                                    "gpg" EXTSEP_S "conf-" SAFE_VERSION, NULL );
1271         if(access(configname,R_OK))
1272           {
1273             m_free(configname);
1274             configname = make_filename(opt.homedir,
1275                                        "gpg" EXTSEP_S "conf", NULL );
1276           }
1277         if (!access (configname, R_OK))
1278           { /* Print a warning when both config files are present. */
1279             char *p = make_filename(opt.homedir, "options", NULL );
1280             if (!access (p, R_OK))
1281               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1282             m_free (p);
1283           }
1284         else
1285           { /* Keep on using the old default one. */
1286             m_free (configname);
1287             configname = make_filename(opt.homedir, "options", NULL );
1288           }
1289       }
1290     argc = orig_argc;
1291     argv = orig_argv;
1292     pargs.argc = &argc;
1293     pargs.argv = &argv;
1294     pargs.flags=  1;  /* do not remove the args */
1295
1296     /* By this point we have a homedir, and cannot change it. */
1297     check_permissions(opt.homedir,0);
1298
1299   next_pass:
1300     if( configname ) {
1301       if(check_permissions(configname,1))
1302         {
1303           /* If any options file is unsafe, then disable any external
1304              programs for keyserver calls or photo IDs.  Since the
1305              external program to call is set in the options file, a
1306              unsafe options file can lead to an arbitrary program
1307              being run. */
1308
1309           opt.exec_disable=1;
1310         }
1311
1312         configlineno = 0;
1313         configfp = fopen( configname, "r" );
1314         if( !configfp ) {
1315             if( default_config ) {
1316                 if( parse_debug )
1317                     log_info(_("NOTE: no default option file `%s'\n"),
1318                                                             configname );
1319             }
1320             else {
1321                 log_error(_("option file `%s': %s\n"),
1322                                     configname, strerror(errno) );
1323                 g10_exit(2);
1324             }
1325             m_free(configname); configname = NULL;
1326         }
1327         if( parse_debug && configname )
1328             log_info(_("reading options from `%s'\n"), configname );
1329         default_config = 0;
1330     }
1331
1332     while( optfile_parse( configfp, configname, &configlineno,
1333                                                 &pargs, opts) ) {
1334         switch( pargs.r_opt ) {
1335           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1336           case aListPackets: set_cmd( &cmd, aListPackets); break;
1337           case aImport: set_cmd( &cmd, aImport); break;
1338           case aFastImport: set_cmd( &cmd, aFastImport); break;
1339           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1340           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1341           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1342           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1343           case aExport: set_cmd( &cmd, aExport); break;
1344           case aExportAll: set_cmd( &cmd, aExportAll); break;
1345           case aListKeys: set_cmd( &cmd, aListKeys); break;
1346           case aListSigs: set_cmd( &cmd, aListSigs); break;
1347           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1348           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1349           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1350                                                         greeting=1; break;
1351           case aDeleteSecretAndPublicKeys:
1352             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1353             greeting=1; 
1354             break;
1355           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1356
1357           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1358           case aSym: set_cmd( &cmd, aSym); break;
1359
1360           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1361           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1362
1363           case aEncr: set_cmd( &cmd, aEncr); break;
1364           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1365           case aSign: set_cmd( &cmd, aSign );  break;
1366           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1367           case aSignKey: set_cmd( &cmd, aSignKey); break;
1368           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1369           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1370           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1371           case aStore: set_cmd( &cmd, aStore); break;
1372           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1373           case aClearsign: set_cmd( &cmd, aClearsign); break;
1374           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1375           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1376           case aVerify: set_cmd( &cmd, aVerify); break;
1377           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1378           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1379           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1380           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1381           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1382           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1383           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1384           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1385           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1386           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1387           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1388           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1389           case aListOwnerTrust:
1390             deprecated_warning(configname,configlineno,
1391                                "--list-ownertrust","--export-ownertrust","");
1392           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1393           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1394           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1395           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1396
1397           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1398           case oOutput: opt.outfile = pargs.r.ret_str; break;
1399           case oQuiet: opt.quiet = 1; break;
1400           case oNoTTY: tty_no_terminal(1); break;
1401           case oDryRun: opt.dry_run = 1; break;
1402           case oInteractive: opt.interactive = 1; break;
1403           case oVerbose: g10_opt_verbose++;
1404                     opt.verbose++; opt.list_sigs=1; break;
1405           case oKOption: set_cmd( &cmd, aKMode ); break;
1406
1407           case oBatch: opt.batch = 1; nogreeting = 1; break;
1408           case oUseAgent:
1409 #ifndef __riscos__
1410             opt.use_agent = 1;
1411 #else /* __riscos__ */
1412             opt.use_agent = 0;
1413             riscos_not_implemented("use-agent");
1414 #endif /* __riscos__ */
1415             break;
1416           case oNoUseAgent: opt.use_agent = 0; break;
1417           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1418           case oAnswerYes: opt.answer_yes = 1; break;
1419           case oAnswerNo: opt.answer_no = 1; break;
1420           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1421           case oPrimaryKeyring:
1422             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1423             sl->flags=2;
1424             break;
1425           case oShowKeyring: opt.list_options|=LIST_SHOW_KEYRING; break;
1426           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1427           case oDebugAll: opt.debug = ~0; break;
1428           case oStatusFD:
1429             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1430             break;
1431 #ifdef __riscos__
1432           case oStatusFile:
1433             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1434             break;
1435 #endif /* __riscos__ */
1436           case oAttributeFD:
1437             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1438             break;
1439 #ifdef __riscos__
1440           case oAttributeFile:
1441             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1442             break;
1443 #endif /* __riscos__ */
1444           case oLoggerFD:
1445             log_set_logfile( NULL,
1446                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1447             break;
1448 #ifdef __riscos__
1449           case oLoggerFile:
1450             log_set_logfile( NULL,
1451                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1452             break;
1453 #endif /* __riscos__ */
1454           case oWithFingerprint:
1455             opt.with_fingerprint = 1;
1456             with_fpr=1; /*fall thru*/
1457           case oFingerprint: opt.fingerprint++; break;
1458           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1459           case oOptions:
1460             /* config files may not be nested (silently ignore them) */
1461             if( !configfp ) {
1462                 m_free(configname);
1463                 configname = m_strdup(pargs.r.ret_str);
1464                 goto next_pass;
1465             }
1466             break;
1467           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1468           case oNoDefKeyring: default_keyring = 0; break;
1469           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1470           case oNoGreeting: nogreeting = 1; break;
1471           case oNoVerbose: g10_opt_verbose = 0;
1472                            opt.verbose = 0; opt.list_sigs=0; break;
1473           case oQuickRandom: quick_random_gen(1); break;
1474           case oSKComments: opt.sk_comments=1; break;
1475           case oNoSKComments: opt.sk_comments=0; break;
1476           case oEmitVersion: opt.no_version=0; break;
1477           case oNoEmitVersion: opt.no_version=1; break;
1478           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1479           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1480           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1481           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1482           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1483           case oDefRecipient:
1484                     if( *pargs.r.ret_str )
1485                         opt.def_recipient = make_username(pargs.r.ret_str);
1486                     break;
1487           case oDefRecipientSelf:
1488                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1489                     opt.def_recipient_self = 1;
1490                     break;
1491           case oNoDefRecipient:
1492                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1493                     opt.def_recipient_self = 0;
1494                     break;
1495           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1496           case oHomedir: break;
1497           case oNoBatch: opt.batch = 0; break;
1498           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1499           case oWithColons: opt.with_colons=':'; break;
1500
1501           case oSkipVerify: opt.skip_verify=1; break;
1502           case oCompressKeys: opt.compress_keys = 1; break;
1503           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1504             /* There are many programs (like mutt) that call gpg with
1505                --always-trust so keep this option around for a long
1506                time. */
1507           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1508           case oTrustModel:
1509             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1510               opt.trust_model=TM_PGP;
1511             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1512               opt.trust_model=TM_CLASSIC;
1513             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1514               opt.trust_model=TM_ALWAYS;
1515             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1516               opt.trust_model=TM_AUTO;
1517             else
1518               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1519             break;
1520           case oForceOwnertrust:
1521             log_info(_("NOTE: %s is not for normal use!\n"),
1522                      "--force-ownertrust");
1523             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1524             if(opt.force_ownertrust==-1)
1525               {
1526                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1527                 opt.force_ownertrust=0;
1528               }
1529             break;
1530           case oLoadExtension:
1531 #ifndef __riscos__
1532 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
1533             if(check_permissions(pargs.r.ret_str,2))
1534               log_info(_("cipher extension \"%s\" not loaded due to "
1535                          "unsafe permissions\n"),pargs.r.ret_str);
1536             else
1537               register_cipher_extension(orig_argc? *orig_argv:NULL,
1538                                         pargs.r.ret_str);
1539 #endif
1540 #else /* __riscos__ */
1541             riscos_not_implemented("load-extension");
1542 #endif /* __riscos__ */
1543             break;
1544           case oRFC1991:
1545             opt.compliance = CO_RFC1991;
1546             opt.force_v4_certs = 0;
1547             opt.disable_mdc = 1;
1548             opt.escape_from = 1;
1549             break;
1550           case oRFC2440:
1551           case oOpenPGP:
1552             /* TODO: When 2440bis becomes a RFC, these may need
1553                changing. */
1554             opt.compliance = CO_RFC2440;
1555             opt.disable_mdc = 1;
1556             opt.allow_non_selfsigned_uid = 1;
1557             opt.allow_freeform_uid = 1;
1558             opt.pgp2_workarounds = 0;
1559             opt.escape_from = 0;
1560             opt.force_v3_sigs = 0;
1561             opt.compress_keys = 0;          /* not mandated  but we do it */
1562             opt.compress_sigs = 0;          /* ditto. */
1563             opt.not_dash_escaped = 0;
1564             opt.def_cipher_algo = 0;
1565             opt.def_digest_algo = 0;
1566             opt.cert_digest_algo = 0;
1567             opt.def_compress_algo = -1;
1568             opt.s2k_mode = 3; /* iterated+salted */
1569             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1570             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1571             break;
1572           case oPGP2:  opt.compliance = CO_PGP2;  break;
1573           case oPGP6:  opt.compliance = CO_PGP6;  break;
1574           case oPGP7:  opt.compliance = CO_PGP7;  break;
1575           case oPGP8:  opt.compliance = CO_PGP8;  break;
1576           case oGnuPG: opt.compliance = CO_GNUPG; break;
1577           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1578           case oCompressSigs: opt.compress_sigs = 1; break;
1579           case oRunAsShmCP:
1580 #ifndef __riscos__
1581 # ifndef USE_SHM_COPROCESSING
1582             /* not possible in the option file,
1583              * but we print the warning here anyway */
1584             log_error("shared memory coprocessing is not available\n");
1585 # endif
1586 #else /* __riscos__ */
1587             riscos_not_implemented("run-as-shm-coprocess");
1588 #endif /* __riscos__ */
1589             break;
1590           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1591           case oForYourEyesOnly: eyes_only = 1; break;
1592           case oNoForYourEyesOnly: eyes_only = 0; break;
1593           case oSetPolicyURL:
1594             add_policy_url(pargs.r.ret_str,0);
1595             add_policy_url(pargs.r.ret_str,1);
1596             break;
1597           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1598           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1599           case oShowPolicyURL:
1600             opt.list_options|=LIST_SHOW_POLICY;
1601             opt.verify_options|=VERIFY_SHOW_POLICY;
1602             break;
1603           case oNoShowPolicyURL:
1604             opt.list_options&=~LIST_SHOW_POLICY;
1605             opt.verify_options&=~VERIFY_SHOW_POLICY;
1606             break;
1607           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
1608           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1609           case oComment: opt.comment_string = pargs.r.ret_str; break;
1610           case oDefaultComment: opt.comment_string = NULL; break;
1611           case oThrowKeyid: opt.throw_keyid = 1; break;
1612           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1613           case oShowPhotos: 
1614             opt.list_options|=LIST_SHOW_PHOTOS;
1615             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1616             break;
1617           case oNoShowPhotos:
1618             opt.list_options&=~LIST_SHOW_PHOTOS;
1619             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1620             break;
1621           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1622           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1623           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1624           case oForceV4Certs: opt.force_v4_certs = 1; break;
1625           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1626           case oForceMDC: opt.force_mdc = 1; break;
1627           case oNoForceMDC: opt.force_mdc = 0; break;
1628           case oDisableMDC: opt.disable_mdc = 1; break;
1629           case oNoDisableMDC: opt.disable_mdc = 0; break;
1630           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1631           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1632           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1633           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1634           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1635           case oEncryptTo: /* store the recipient in the second list */
1636             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1637             sl->flags = 1;
1638             break;
1639           case oHiddenEncryptTo: /* store the recipient in the second list */
1640             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1641             sl->flags = 1|2;
1642             break;
1643           case oRecipient: /* store the recipient */
1644             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1645             any_explicit_recipient = 1;
1646             break;
1647           case oHiddenRecipient: /* store the recipient with a flag */
1648             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1649             sl->flags = 2;
1650             any_explicit_recipient = 1;
1651             break;
1652           case oTextmodeShort: opt.textmode = 2; break;
1653           case oTextmode: opt.textmode=1;  break;
1654           case oNoTextmode: opt.textmode=0;  break;
1655           case oExpert: opt.expert = 1; break;
1656           case oNoExpert: opt.expert = 0; break;
1657           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1658           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1659           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1660           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1661           case oUser: /* store the local users */
1662             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1663             break;
1664           case oCompress: opt.compress = pargs.r.ret_int; break;
1665           case oPasswdFD:
1666             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1667             opt.use_agent = 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-preferred-keyserver",LIST_SHOW_KEYSERVER},
1765                   {"show-validity",LIST_SHOW_VALIDITY},
1766                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1767                   {"show-keyring",LIST_SHOW_KEYRING},
1768                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE},
1769                   {NULL,0}
1770                 };
1771
1772               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1773                 {
1774                   if(configname)
1775                     log_error(_("%s:%d: invalid list options\n"),
1776                               configname,configlineno);
1777                   else
1778                     log_error(_("invalid list options\n"));
1779                 }
1780             }
1781             break;
1782           case oVerifyOptions:
1783             {
1784               struct parse_options vopts[]=
1785                 {
1786                   {"show-photos",VERIFY_SHOW_PHOTOS},
1787                   {"show-policy-url",VERIFY_SHOW_POLICY},
1788                   {"show-notation",VERIFY_SHOW_NOTATION},
1789                   {"show-preferred-keyserver",VERIFY_SHOW_KEYSERVER},
1790                   {"show-validity",VERIFY_SHOW_VALIDITY},
1791                   {"show-long-keyid",VERIFY_SHOW_LONG_KEYID},
1792                   {NULL,0}
1793                 };
1794
1795               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1796                 {
1797                   if(configname)
1798                     log_error(_("%s:%d: invalid verify options\n"),
1799                               configname,configlineno);
1800                   else
1801                     log_error(_("invalid verify options\n"));
1802                 }
1803             }
1804             break;
1805           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1806           case oExecPath:
1807             if(set_exec_path(pargs.r.ret_str,0))
1808               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1809             else
1810               opt.exec_path_set=1;
1811             break;
1812           case oSetNotation:
1813             add_notation_data( pargs.r.ret_str, 0 );
1814             add_notation_data( pargs.r.ret_str, 1 );
1815             break;
1816           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1817           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1818           case oShowNotation:
1819             opt.list_options|=LIST_SHOW_NOTATION;
1820             opt.verify_options|=VERIFY_SHOW_NOTATION;
1821             break;
1822           case oNoShowNotation:
1823             opt.list_options&=~LIST_SHOW_NOTATION;
1824             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1825             break;
1826           case oUtf8Strings: utf8_strings = 1; break;
1827           case oNoUtf8Strings: utf8_strings = 0; break;
1828           case oDisableCipherAlgo:
1829                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1830                 break;
1831           case oDisablePubkeyAlgo:
1832                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1833                 break;
1834           case oNoSigCache: opt.no_sig_cache = 1; break;
1835           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1836           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1837           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1838           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1839           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1840           case oNoLiteral: opt.no_literal = 1; break;
1841           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1842           case oHonorHttpProxy:
1843                 opt.keyserver_options.honor_http_proxy = 1;
1844                 deprecated_warning(configname,configlineno,
1845                                    "--honor-http-proxy",
1846                                    "--keyserver-options ",
1847                                    "honor-http-proxy");
1848                 break;
1849           case oFastListMode: opt.fast_list_mode = 1; break;
1850           case oFixedListMode: opt.fixed_list_mode = 1; break;
1851           case oListOnly: opt.list_only=1; break;
1852           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1853           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1854           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1855           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1856           case oNoRandomSeedFile: use_random_seed = 0; break;
1857           case oAutoKeyRetrieve:
1858           case oNoAutoKeyRetrieve:
1859                 opt.keyserver_options.auto_key_retrieve=
1860                                              (pargs.r_opt==oAutoKeyRetrieve);
1861                 deprecated_warning(configname,configlineno,
1862                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1863                                "--no-auto-key-retrieve","--keyserver-options ",
1864                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1865                                "no-auto-key-retrieve");
1866                 break;
1867           case oShowSessionKey: opt.show_session_key = 1; break;
1868           case oOverrideSessionKey:
1869                 opt.override_session_key = pargs.r.ret_str;
1870                 break;
1871           case oMergeOnly: opt.merge_only = 1; break;
1872           case oAllowSecretKeyImport: /* obsolete */ break;
1873           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1874           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1875           case oEnableSpecialFilenames:
1876             iobuf_enable_special_filenames (1);
1877             break;
1878           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1879           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1880           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1881           case oPreservePermissions: opt.preserve_permissions=1; break;
1882           case oDefaultPreferenceList:
1883             opt.def_preference_list = pargs.r.ret_str;
1884             break;
1885           case oPersonalCipherPreferences:
1886             pers_cipher_list=pargs.r.ret_str;
1887             break;
1888           case oPersonalDigestPreferences:
1889             pers_digest_list=pargs.r.ret_str;
1890             break;
1891           case oPersonalCompressPreferences:
1892             pers_compress_list=pargs.r.ret_str;
1893             break;
1894           case oDisplay: opt.display = pargs.r.ret_str; break;
1895           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1896           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1897           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1898           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1899           case oGroup: add_group(pargs.r.ret_str); break;
1900           case oStrict: opt.strict=1; log_set_strict(1); break;
1901           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1902
1903           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1904           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1905
1906           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1907
1908           default : pargs.err = configfp? 1:2; break;
1909         }
1910     }
1911
1912     if( configfp ) {
1913         fclose( configfp );
1914         configfp = NULL;
1915         m_free(configname); configname = NULL;
1916         goto next_pass;
1917     }
1918     m_free( configname ); configname = NULL;
1919     if( log_get_errorcount(0) )
1920         g10_exit(2);
1921     if( nogreeting )
1922         greeting = 0;
1923
1924     if( greeting ) {
1925         fprintf(stderr, "%s %s; %s\n",
1926                         strusage(11), strusage(13), strusage(14) );
1927         fprintf(stderr, "%s\n", strusage(15) );
1928     }
1929 #ifdef IS_DEVELOPMENT_VERSION
1930     if( !opt.batch ) {
1931         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1932         log_info("It is only intended for test purposes and should NOT be\n");
1933         log_info("used in a production environment or with production keys!\n");
1934     }
1935 #endif
1936
1937     if (opt.verbose > 2)
1938         log_info ("using character set `%s'\n", get_native_charset ());
1939
1940     if( may_coredump && !opt.quiet )
1941         log_info(_("WARNING: program may create a core file!\n"));
1942
1943     if (eyes_only) {
1944       if (opt.set_filename)
1945           log_info(_("WARNING: %s overrides %s\n"),
1946                    "--for-your-eyes-only","--set-filename");
1947
1948       opt.set_filename="_CONSOLE";
1949     }
1950
1951     if (opt.no_literal) {
1952         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1953         if (opt.textmode)
1954             log_error(_("%s not allowed with %s!\n"),
1955                        "--textmode", "--no-literal" );
1956         if (opt.set_filename)
1957             log_error(_("%s makes no sense with %s!\n"),
1958                         eyes_only?"--for-your-eyes-only":"--set-filename",
1959                         "--no-literal" );
1960     }
1961
1962     if (opt.set_filesize)
1963         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1964     if( opt.batch )
1965         tty_batchmode( 1 );
1966
1967     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1968
1969     set_debug();
1970
1971     /* Do these after the switch(), so they can override settings. */
1972     if(PGP2)
1973       {
1974         int unusable=0;
1975
1976         if(cmd==aSign && !detached_sig)
1977           {
1978             log_info(_("you can only make detached or clear signatures "
1979                        "while in --pgp2 mode\n"));
1980             unusable=1;
1981           }
1982         else if(cmd==aSignEncr || cmd==aSignSym)
1983           {
1984             log_info(_("you can't sign and encrypt at the "
1985                        "same time while in --pgp2 mode\n"));
1986             unusable=1;
1987           }
1988         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1989           {
1990             log_info(_("you must use files (and not a pipe) when "
1991                        "working with --pgp2 enabled.\n"));
1992             unusable=1;
1993           }
1994         else if(cmd==aEncr || cmd==aSym)
1995           {
1996             /* Everything else should work without IDEA (except using
1997                a secret key encrypted with IDEA and setting an IDEA
1998                preference, but those have their own error
1999                messages). */
2000
2001             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2002               {
2003                 log_info(_("encrypting a message in --pgp2 mode requires "
2004                            "the IDEA cipher\n"));
2005                 idea_cipher_warn(1);
2006                 unusable=1;
2007               }
2008             else if(cmd==aSym)
2009               {
2010                 /* This only sets IDEA for symmetric encryption
2011                    since it is set via select_algo_from_prefs for
2012                    pk encryption. */
2013                 m_free(def_cipher_string);
2014                 def_cipher_string = m_strdup("idea");
2015               }
2016
2017             /* PGP2 can't handle the output from the textmode
2018                filter, so we disable it for anything that could
2019                create a literal packet (only encryption and
2020                symmetric encryption, since we disable signing
2021                above). */
2022             if(!unusable)
2023               opt.textmode=0;
2024           }
2025
2026         if(unusable)
2027           compliance_failure();
2028         else
2029           {
2030             opt.force_mdc = 0;
2031             opt.disable_mdc = 1;
2032             opt.force_v4_certs = 0;
2033             opt.sk_comments = 0;
2034             opt.escape_from = 1;
2035             opt.force_v3_sigs = 1;
2036             opt.pgp2_workarounds = 1;
2037             opt.ask_sig_expire = 0;
2038             opt.ask_cert_expire = 0;
2039             m_free(def_digest_string);
2040             def_digest_string = m_strdup("md5");
2041             opt.def_compress_algo = 1;
2042           }
2043       }
2044     else if(PGP6)
2045       {
2046         opt.sk_comments=0;
2047         opt.escape_from=1;
2048         opt.force_v3_sigs=1;
2049         opt.ask_sig_expire=0;
2050         opt.force_mdc=0;
2051         opt.disable_mdc=1;
2052       }
2053     else if(PGP7)
2054       {
2055         opt.sk_comments=0;
2056         opt.escape_from=1;
2057         opt.force_v3_sigs=1;
2058         opt.ask_sig_expire=0;
2059       }
2060     else if(PGP8)
2061       {
2062         opt.escape_from=1;
2063       }
2064
2065     /* must do this after dropping setuid, because string_to...
2066      * may try to load an module */
2067     if( def_cipher_string ) {
2068         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2069         if(opt.def_cipher_algo==0 &&
2070            (ascii_strcasecmp(def_cipher_string,"idea")==0
2071             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2072           idea_cipher_warn(1);
2073         m_free(def_cipher_string); def_cipher_string = NULL;
2074         if( check_cipher_algo(opt.def_cipher_algo) )
2075             log_error(_("selected cipher algorithm is invalid\n"));
2076     }
2077     if( def_digest_string ) {
2078         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2079         m_free(def_digest_string); def_digest_string = NULL;
2080         if( check_digest_algo(opt.def_digest_algo) )
2081             log_error(_("selected digest algorithm is invalid\n"));
2082     }
2083     if( def_compress_string ) {
2084         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2085         m_free(def_compress_string); def_compress_string = NULL;
2086         if( check_compress_algo(opt.def_compress_algo) )
2087             log_error(_("selected compression algorithm is invalid\n"));
2088     }
2089     if( cert_digest_string ) {
2090         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2091         m_free(cert_digest_string); cert_digest_string = NULL;
2092         if( check_digest_algo(opt.cert_digest_algo) )
2093             log_error(_("selected certification digest algorithm is invalid\n"));
2094     }
2095     if( s2k_cipher_string ) {
2096         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2097         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2098         if( check_cipher_algo(opt.s2k_cipher_algo) )
2099             log_error(_("selected cipher algorithm is invalid\n"));
2100     }
2101     if( s2k_digest_string ) {
2102         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2103         m_free(s2k_digest_string); s2k_digest_string = NULL;
2104         if( check_digest_algo(opt.s2k_digest_algo) )
2105             log_error(_("selected digest algorithm is invalid\n"));
2106     }
2107     if( opt.completes_needed < 1 )
2108         log_error(_("completes-needed must be greater than 0\n"));
2109     if( opt.marginals_needed < 2 )
2110         log_error(_("marginals-needed must be greater than 1\n"));
2111     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2112         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2113     switch( opt.s2k_mode ) {
2114       case 0:
2115         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2116         break;
2117       case 1: case 3: break;
2118       default:
2119         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2120     }
2121
2122     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2123       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2124
2125     /* This isn't actually needed, but does serve to error out if the
2126        string is invalid. */
2127     if(opt.def_preference_list &&
2128         keygen_set_std_prefs(opt.def_preference_list,0))
2129       log_error(_("invalid default preferences\n"));
2130
2131     /* We provide defaults for the personal digest list */
2132     if(!pers_digest_list)
2133       pers_digest_list="h2";
2134
2135     if(pers_cipher_list &&
2136        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2137       log_error(_("invalid personal cipher preferences\n"));
2138
2139     if(pers_digest_list &&
2140        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2141       log_error(_("invalid personal digest preferences\n"));
2142
2143     if(pers_compress_list &&
2144        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2145       log_error(_("invalid personal compress preferences\n"));
2146
2147     if( log_get_errorcount(0) )
2148         g10_exit(2);
2149
2150     /* Check our chosen algorithms against the list of legal
2151        algorithms. */
2152
2153     if(!GNUPG)
2154       {
2155         const char *badalg=NULL;
2156         preftype_t badtype=PREFTYPE_NONE;
2157
2158         if(opt.def_cipher_algo
2159            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2160           {
2161             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2162             badtype=PREFTYPE_SYM;
2163           }
2164         else if(opt.def_digest_algo
2165                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2166           {
2167             badalg=digest_algo_to_string(opt.def_digest_algo);
2168             badtype=PREFTYPE_HASH;
2169           }
2170         else if(opt.cert_digest_algo
2171                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2172           {
2173             badalg=digest_algo_to_string(opt.cert_digest_algo);
2174             badtype=PREFTYPE_HASH;
2175           }
2176         else if(opt.def_compress_algo!=-1
2177                 && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2178           {
2179             badalg=compress_algo_to_string(opt.def_compress_algo);
2180             badtype=PREFTYPE_ZIP;
2181           }
2182
2183         if(badalg)
2184           {
2185             switch(badtype)
2186               {
2187               case PREFTYPE_SYM:
2188                 log_info(_("you may not use cipher algorithm \"%s\" "
2189                            "while in %s mode\n"),
2190                          badalg,compliance_option_string());
2191                 break;
2192               case PREFTYPE_HASH:
2193                 log_info(_("you may not use digest algorithm \"%s\" "
2194                            "while in %s mode\n"),
2195                          badalg,compliance_option_string());
2196                 break;
2197               case PREFTYPE_ZIP:
2198                 log_info(_("you may not use compression algorithm \"%s\" "
2199                            "while in %s mode\n"),
2200                          badalg,compliance_option_string());
2201                 break;
2202               default:
2203                 BUG();
2204               }
2205
2206             compliance_failure();
2207           }
2208       }
2209
2210     /* set the random seed file */
2211     if( use_random_seed ) {
2212         char *p = make_filename(opt.homedir, "random_seed", NULL );
2213         set_random_seed_file(p);
2214         m_free(p);
2215     }
2216
2217     if( !cmd && opt.fingerprint && !with_fpr ) {
2218         set_cmd( &cmd, aListKeys);
2219     }
2220
2221     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2222         if( cmd == aKModeC ) {
2223             opt.fingerprint = 1;
2224             cmd = aKMode;
2225         }
2226         opt.list_sigs = 0;
2227         if( opt.verbose > 2 )
2228             opt.check_sigs++;
2229         if( opt.verbose > 1 )
2230             opt.list_sigs++;
2231
2232         opt.verbose = opt.verbose > 1;
2233         g10_opt_verbose = opt.verbose;
2234     }
2235
2236     /* Compression algorithm 0 means no compression at all */
2237     if( opt.def_compress_algo == 0)
2238         opt.compress = 0;
2239
2240     /* kludge to let -sat generate a clear text signature */
2241     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2242         cmd = aClearsign;
2243
2244     if( opt.verbose > 1 )
2245         set_packet_list_mode(1);
2246
2247     /* Add the keyrings, but not for some special commands and not in
2248        case of "-kvv userid keyring".  Also avoid adding the secret
2249        keyring for a couple of commands to avoid unneeded access in
2250        case the secrings are stored on a floppy */
2251     if( cmd != aDeArmor && cmd != aEnArmor
2252         && !(cmd == aKMode && argc == 2 ) ) 
2253       {
2254         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2255             && cmd != aVerify && cmd != aVerifyFiles
2256             && cmd != aSym)
2257           {
2258             if (!sec_nrings || default_keyring) /* add default secret rings */
2259               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2260             for (sl = sec_nrings; sl; sl = sl->next)
2261               keydb_add_resource ( sl->d, 0, 1 );
2262           }
2263         if( !nrings || default_keyring )  /* add default ring */
2264             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2265         for(sl = nrings; sl; sl = sl->next )
2266             keydb_add_resource ( sl->d, sl->flags, 0 );
2267       }
2268     FREE_STRLIST(nrings);
2269     FREE_STRLIST(sec_nrings);
2270
2271
2272     if( pwfd != -1 )  /* read the passphrase now. */
2273         read_passphrase_from_fd( pwfd );
2274
2275     fname = argc? *argv : NULL;
2276
2277     switch( cmd ) {
2278       case aPrimegen:
2279       case aPrintMD:
2280       case aPrintMDs:
2281       case aGenRandom:
2282       case aDeArmor:
2283       case aEnArmor:
2284       case aFixTrustDB:
2285         break;
2286       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2287       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2288       default: rc = setup_trustdb(1, trustdb_name ); break;
2289     }
2290     if( rc )
2291         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2292
2293
2294     switch (cmd) {
2295       case aStore: 
2296       case aSym:  
2297       case aSign: 
2298       case aSignSym: 
2299       case aClearsign: 
2300         if (!opt.quiet && any_explicit_recipient)
2301           log_info (_("WARNING: recipients (-r) given "
2302                       "without using public key encryption\n"));
2303         break;
2304       default:
2305         break;
2306     }
2307
2308     switch( cmd ) {
2309       case aStore: /* only store the file */
2310         if( argc > 1 )
2311             wrong_args(_("--store [filename]"));
2312         if( (rc = encode_store(fname)) )
2313             log_error_f( print_fname_stdin(fname),
2314                         "store failed: %s\n", g10_errstr(rc) );
2315         break;
2316       case aSym: /* encrypt the given file only with the symmetric cipher */
2317         if( argc > 1 )
2318             wrong_args(_("--symmetric [filename]"));
2319         if( (rc = encode_symmetric(fname)) )
2320             log_error_f(print_fname_stdin(fname),
2321                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2322         break;
2323
2324       case aEncr: /* encrypt the given file */
2325         if( argc > 1 )
2326             wrong_args(_("--encrypt [filename]"));
2327         if( (rc = encode_crypt(fname,remusr)) )
2328             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2329         break;
2330
2331       case aEncrFiles: /* encrypt the given files */
2332         encode_crypt_files(argc, argv, remusr);
2333         break;
2334           
2335       case aSign: /* sign the given file */
2336         sl = NULL;
2337         if( detached_sig ) { /* sign all files */
2338             for( ; argc; argc--, argv++ )
2339                 add_to_strlist( &sl, *argv );
2340         }
2341         else {
2342             if( argc > 1 )
2343                 wrong_args(_("--sign [filename]"));
2344             if( argc ) {
2345                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2346                 strcpy(sl->d, fname);
2347             }
2348         }
2349         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2350             log_error("signing failed: %s\n", g10_errstr(rc) );
2351         free_strlist(sl);
2352         break;
2353
2354       case aSignEncr: /* sign and encrypt the given file */
2355         if( argc > 1 )
2356             wrong_args(_("--sign --encrypt [filename]"));
2357         if( argc ) {
2358             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2359             strcpy(sl->d, fname);
2360         }
2361         else
2362             sl = NULL;
2363         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2364             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2365         free_strlist(sl);
2366         break;
2367
2368       case aSignSym: /* sign and conventionally encrypt the given file */
2369         if (argc > 1)
2370             wrong_args(_("--sign --symmetric [filename]"));
2371         rc = sign_symencrypt_file (fname, locusr);
2372         if (rc)
2373             log_error("%s: sign+symmetric failed: %s\n",
2374                       print_fname_stdin(fname), g10_errstr(rc) );
2375         break;
2376
2377       case aClearsign: /* make a clearsig */
2378         if( argc > 1 )
2379             wrong_args(_("--clearsign [filename]"));
2380         if( (rc = clearsign_file(fname, locusr, NULL)) )
2381             log_error("%s: clearsign failed: %s\n",
2382                       print_fname_stdin(fname), g10_errstr(rc) );
2383         break;
2384
2385       case aVerify:
2386         if( (rc = verify_signatures( argc, argv ) ))
2387             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2388         break;
2389
2390       case aVerifyFiles:
2391         if( (rc = verify_files( argc, argv ) ))
2392             log_error("verify files failed: %s\n", g10_errstr(rc) );
2393         break;
2394
2395       case aDecrypt:
2396         if( argc > 1 )
2397             wrong_args(_("--decrypt [filename]"));
2398         if( (rc = decrypt_message( fname ) ))
2399             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2400         break;
2401
2402       case aDecryptFiles:
2403         decrypt_messages(argc, argv);
2404         break;
2405             
2406       case aSignKey: /* sign the key given as argument */
2407         if( argc != 1 )
2408             wrong_args(_("--sign-key user-id"));
2409         username = make_username( fname );
2410         keyedit_menu(fname, locusr, NULL, 1 );
2411         m_free(username);
2412         break;
2413
2414       case aLSignKey:
2415         if( argc != 1 )
2416             wrong_args(_("--lsign-key user-id"));
2417         username = make_username( fname );
2418         keyedit_menu(fname, locusr, NULL, 2 );
2419         m_free(username);
2420         break;
2421
2422       case aNRSignKey:
2423         if( argc != 1 )
2424             wrong_args(_("--nrsign-key user-id"));
2425         username = make_username( fname );
2426         keyedit_menu(fname, locusr, NULL, 3 );
2427         m_free(username);
2428         break;
2429
2430       case aNRLSignKey:
2431         if( argc != 1 )
2432             wrong_args(_("--nrlsign-key user-id"));
2433         username = make_username( fname );
2434         keyedit_menu(fname, locusr, NULL, 4 );
2435         m_free(username);
2436         break;
2437
2438       case aEditKey: /* Edit a key signature */
2439         if( !argc )
2440             wrong_args(_("--edit-key user-id [commands]"));
2441         username = make_username( fname );
2442         if( argc > 1 ) {
2443             sl = NULL;
2444             for( argc--, argv++ ; argc; argc--, argv++ )
2445                 append_to_strlist( &sl, *argv );
2446             keyedit_menu( username, locusr, sl, 0 );
2447             free_strlist(sl);
2448         }
2449         else
2450             keyedit_menu(username, locusr, NULL, 0 );
2451         m_free(username);
2452         break;
2453
2454       case aDeleteKeys:
2455       case aDeleteSecretKeys:
2456       case aDeleteSecretAndPublicKeys:
2457         sl = NULL;
2458         /* I'm adding these in reverse order as add_to_strlist2
2459            reverses them again, and it's easier to understand in the
2460            proper order :) */
2461         for( ; argc; argc-- )
2462           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2463         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2464         free_strlist(sl);
2465         break;
2466
2467       case aCheckKeys:
2468         opt.check_sigs = 1;
2469       case aListSigs:
2470         opt.list_sigs = 1;
2471       case aListKeys:
2472         sl = NULL;
2473         for( ; argc; argc--, argv++ )
2474             add_to_strlist2( &sl, *argv, utf8_strings );
2475         public_key_list( sl );
2476         free_strlist(sl);
2477         break;
2478       case aListSecretKeys:
2479         sl = NULL;
2480         for( ; argc; argc--, argv++ )
2481             add_to_strlist2( &sl, *argv, utf8_strings );
2482         secret_key_list( sl );
2483         free_strlist(sl);
2484         break;
2485
2486       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2487         if( argc < 2 ) { /* -kv [userid] */
2488             sl = NULL;
2489             if (argc && **argv)
2490                 add_to_strlist2( &sl, *argv, utf8_strings );
2491             public_key_list( sl );
2492             free_strlist(sl);
2493         }
2494         else if( argc == 2 ) { /* -kv userid keyring */
2495             if( access( argv[1], R_OK ) ) {
2496                 log_error(_("can't open %s: %s\n"),
2497                                print_fname_stdin(argv[1]), strerror(errno));
2498             }
2499             else {
2500                 /* add keyring (default keyrings are not registered in this
2501                  * special case */
2502                 keydb_add_resource( argv[1], 0, 0 );
2503                 sl = NULL;
2504                 if (**argv)
2505                     add_to_strlist2( &sl, *argv, utf8_strings );
2506                 public_key_list( sl );
2507                 free_strlist(sl);
2508             }
2509         }
2510         else
2511             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2512         break;
2513
2514       case aKeygen: /* generate a key */
2515         if( opt.batch ) {
2516             if( argc > 1 )
2517                 wrong_args("--gen-key [parameterfile]");
2518             generate_keypair( argc? *argv : NULL );
2519         }
2520         else {
2521             if( argc )
2522                 wrong_args("--gen-key");
2523             generate_keypair(NULL);
2524         }
2525         break;
2526
2527       case aFastImport:
2528         opt.import_options |= IMPORT_FAST_IMPORT;
2529       case aImport:
2530         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2531         break;
2532
2533       case aExport:
2534       case aExportAll:
2535       case aSendKeys:
2536       case aRecvKeys:
2537         sl = NULL;
2538         for( ; argc; argc--, argv++ )
2539             add_to_strlist2( &sl, *argv, utf8_strings );
2540         if( cmd == aSendKeys )
2541             rc=keyserver_export( sl );
2542         else if( cmd == aRecvKeys )
2543             rc=keyserver_import( sl );
2544         else
2545             rc=export_pubkeys( sl, opt.export_options );
2546         if(rc)
2547           {
2548             if(cmd==aSendKeys)
2549               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
2550             else if(cmd==aRecvKeys)
2551               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
2552             else
2553               log_error(_("key export failed: %s\n"),g10_errstr(rc));
2554           }
2555         free_strlist(sl);
2556         break;
2557
2558      case aSearchKeys:
2559         sl = NULL;
2560         for( ; argc; argc--, argv++ )
2561           append_to_strlist2( &sl, *argv, utf8_strings );
2562
2563         rc=keyserver_search( sl );
2564         if(rc)
2565           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
2566         free_strlist(sl);
2567         break;
2568
2569       case aRefreshKeys:
2570         sl = NULL;
2571         for( ; argc; argc--, argv++ )
2572             add_to_strlist2( &sl, *argv, utf8_strings );
2573         rc=keyserver_refresh(sl);
2574         if(rc)
2575           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
2576         free_strlist(sl);
2577         break;
2578
2579       case aExportSecret:
2580         sl = NULL;
2581         for( ; argc; argc--, argv++ )
2582             add_to_strlist2( &sl, *argv, utf8_strings );
2583         export_seckeys( sl );
2584         free_strlist(sl);
2585         break;
2586
2587       case aExportSecretSub:
2588         sl = NULL;
2589         for( ; argc; argc--, argv++ )
2590             add_to_strlist2( &sl, *argv, utf8_strings );
2591         export_secsubkeys( sl );
2592         free_strlist(sl);
2593         break;
2594
2595       case aGenRevoke:
2596         if( argc != 1 )
2597             wrong_args("--gen-revoke user-id");
2598         username =  make_username(*argv);
2599         gen_revoke( username );
2600         m_free( username );
2601         break;
2602
2603       case aDesigRevoke:
2604         if( argc != 1 )
2605             wrong_args("--desig-revoke user-id");
2606         username =  make_username(*argv);
2607         gen_desig_revoke( username );
2608         m_free( username );
2609         break;
2610
2611       case aDeArmor:
2612         if( argc > 1 )
2613             wrong_args("--dearmor [file]");
2614         rc = dearmor_file( argc? *argv: NULL );
2615         if( rc )
2616             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2617         break;
2618
2619       case aEnArmor:
2620         if( argc > 1 )
2621             wrong_args("--enarmor [file]");
2622         rc = enarmor_file( argc? *argv: NULL );
2623         if( rc )
2624             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2625         break;
2626
2627
2628       case aPrimegen:
2629         {   int mode = argc < 2 ? 0 : atoi(*argv);
2630
2631             if( mode == 1 && argc == 2 ) {
2632                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2633             }
2634             else if( mode == 2 && argc == 3 ) {
2635                 mpi_print( stdout, generate_elg_prime(
2636                                              0, atoi(argv[1]),
2637                                              atoi(argv[2]), NULL,NULL ), 1);
2638             }
2639             else if( mode == 3 && argc == 3 ) {
2640                 MPI *factors;
2641                 mpi_print( stdout, generate_elg_prime(
2642                                              1, atoi(argv[1]),
2643                                              atoi(argv[2]), NULL,&factors ), 1);
2644                 putchar('\n');
2645                 mpi_print( stdout, factors[0], 1 ); /* print q */
2646             }
2647             else if( mode == 4 && argc == 3 ) {
2648                 MPI g = mpi_alloc(1);
2649                 mpi_print( stdout, generate_elg_prime(
2650                                                  0, atoi(argv[1]),
2651                                                  atoi(argv[2]), g, NULL ), 1);
2652                 putchar('\n');
2653                 mpi_print( stdout, g, 1 );
2654                 mpi_free(g);
2655             }
2656             else
2657                 wrong_args("--gen-prime mode bits [qbits] ");
2658             putchar('\n');
2659         }
2660         break;
2661
2662       case aGenRandom:
2663         {
2664             int level = argc ? atoi(*argv):0;
2665             int count = argc > 1 ? atoi(argv[1]): 0;
2666             int endless = !count;
2667
2668             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2669                 wrong_args("--gen-random 0|1|2 [count]");
2670
2671             while( endless || count ) {
2672                 byte *p;
2673                 /* Wee need a multiple of 3, so that in case of
2674                    armored output we get a correct string.  No
2675                    linefolding is done, as it is best to levae this to
2676                    other tools */
2677                 size_t n = !endless && count < 99? count : 99;
2678
2679                 p = get_random_bits( n*8, level, 0);
2680 #ifdef HAVE_DOSISH_SYSTEM
2681                 setmode ( fileno(stdout), O_BINARY );
2682 #endif
2683                 if (opt.armor) {
2684                     char *tmp = make_radix64_string (p, n);
2685                     fputs (tmp, stdout);
2686                     m_free (tmp);
2687                     if (n%3 == 1)
2688                       putchar ('=');
2689                     if (n%3)
2690                       putchar ('=');
2691                 } else {
2692                     fwrite( p, n, 1, stdout );
2693                 }
2694                 m_free(p);
2695                 if( !endless )
2696                     count -= n;
2697             }
2698             if (opt.armor)
2699                 putchar ('\n');
2700         }
2701         break;
2702
2703       case aPrintMD:
2704         if( argc < 1)
2705             wrong_args("--print-md algo [files]");
2706         {
2707             int all_algos = (**argv=='*' && !(*argv)[1]);
2708             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2709
2710             if( !algo && !all_algos )
2711                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2712             else {
2713                 argc--; argv++;
2714                 if( !argc )
2715                     print_mds(NULL, algo);
2716                 else {
2717                     for(; argc; argc--, argv++ )
2718                         print_mds(*argv, algo);
2719                 }
2720             }
2721         }
2722         break;
2723
2724       case aPrintMDs: /* old option */
2725         if( !argc )
2726             print_mds(NULL,0);
2727         else {
2728             for(; argc; argc--, argv++ )
2729                 print_mds(*argv,0);
2730         }
2731         break;
2732
2733       case aListTrustDB:
2734         if( !argc )
2735             list_trustdb(NULL);
2736         else {
2737             for( ; argc; argc--, argv++ )
2738                 list_trustdb( *argv );
2739         }
2740         break;
2741
2742       case aUpdateTrustDB:
2743         if( argc )
2744             wrong_args("--update-trustdb");
2745         update_trustdb();
2746         break;
2747
2748       case aCheckTrustDB:
2749         /* Old versions allowed for arguments - ignore them */
2750         check_trustdb();
2751         break;
2752
2753       case aFixTrustDB:
2754         log_error("this command is not yet implemented.\n");
2755         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2756         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2757         break;
2758
2759       case aListTrustPath:
2760         if( !argc )
2761             wrong_args("--list-trust-path <user-ids>");
2762         for( ; argc; argc--, argv++ ) {
2763             username = make_username( *argv );
2764             list_trust_path( username );
2765             m_free(username);
2766         }
2767         break;
2768
2769       case aExportOwnerTrust:
2770         if( argc )
2771             wrong_args("--export-ownertrust");
2772         export_ownertrust();
2773         break;
2774
2775       case aImportOwnerTrust:
2776         if( argc > 1 )
2777             wrong_args("--import-ownertrust [file]");
2778         import_ownertrust( argc? *argv:NULL );
2779         break;
2780       
2781       case aPipeMode:
2782         if ( argc )
2783             wrong_args ("--pipemode");
2784         run_in_pipemode ();
2785         break;
2786
2787       case aRebuildKeydbCaches:
2788         if (argc)
2789             wrong_args ("--rebuild-keydb-caches");
2790         keydb_rebuild_caches ();
2791         break;
2792
2793       case aListPackets:
2794         opt.list_packets=2;
2795       default:
2796         if( argc > 1 )
2797             wrong_args(_("[filename]"));
2798         /* Issue some output for the unix newbie */
2799         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2800                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2801             log_info(_("Go ahead and type your message ...\n"));
2802
2803         if( !(a = iobuf_open(fname)) )
2804             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2805         else {
2806
2807             if( !opt.no_armor ) {
2808                 if( use_armor_filter( a ) ) {
2809                     memset( &afx, 0, sizeof afx);
2810                     iobuf_push_filter( a, armor_filter, &afx );
2811                 }
2812             }
2813             if( cmd == aListPackets ) {
2814                 set_packet_list_mode(1);
2815                 opt.list_packets=1;
2816             }
2817             rc = proc_packets(NULL, a );
2818             if( rc )
2819                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2820             iobuf_close(a);
2821         }
2822         break;
2823     }
2824
2825     /* cleanup */
2826     FREE_STRLIST(remusr);
2827     FREE_STRLIST(locusr);
2828     g10_exit(0);
2829     return 8; /*NEVER REACHED*/
2830 }
2831
2832
2833 void
2834 g10_exit( int rc )
2835 {
2836     update_random_seed_file();
2837     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2838         m_print_stats("on exit");
2839         random_dump_stats();
2840     }
2841     if( opt.debug )
2842         secmem_dump_stats();
2843     secmem_term();
2844     rc = rc? rc : log_get_errorcount(0)? 2 :
2845                         g10_errors_seen? 1 : 0;
2846     exit(rc );
2847 }
2848
2849
2850 /* Pretty-print hex hashes.  This assumes at least an 80-character
2851    display, but there are a few other similar assumptions in the
2852    display code. */
2853 static void
2854 print_hex( MD_HANDLE md, int algo, const char *fname )
2855 {
2856   int i,n,count,indent=0;
2857   const byte *p;
2858
2859   if(fname)
2860     indent=printf("%s: ",fname);
2861
2862   if(indent>40)
2863     {
2864       printf("\n");
2865       indent=0;
2866     }
2867
2868   if(algo==DIGEST_ALGO_RMD160)
2869     indent+=printf("RMD160 = ");
2870   else if(algo==DIGEST_ALGO_TIGER)
2871     indent+=printf(" TIGER = ");
2872   else if(algo>0)
2873     indent+=printf("%6s = ",digest_algo_to_string(algo));
2874   else
2875     algo=abs(algo);
2876
2877   count=indent;
2878
2879   p = md_read( md, algo );
2880   n = md_digest_length(algo);
2881
2882   count+=printf("%02X",*p++);
2883
2884   for(i=1;i<n;i++,p++)
2885     {
2886       if(n==16)
2887         {
2888           if(count+2>79)
2889             {
2890               printf("\n%*s",indent," ");
2891               count=indent;
2892             }
2893           else
2894             count+=printf(" ");
2895
2896           if(!(i%8))
2897             count+=printf(" ");
2898         }
2899       else if (n==20)
2900         {
2901           if(!(i%2))
2902             {
2903               if(count+4>79)
2904                 {
2905                   printf("\n%*s",indent," ");
2906                   count=indent;
2907                 }
2908               else
2909                 count+=printf(" ");
2910             }
2911
2912           if(!(i%10))
2913             count+=printf(" ");
2914         }
2915       else
2916         {
2917           if(!(i%4))
2918             {
2919               if(count+8>79)
2920                 {
2921                   printf("\n%*s",indent," ");
2922                   count=indent;
2923                 }
2924               else
2925                 count+=printf(" ");
2926             }
2927         }
2928
2929       count+=printf("%02X",*p);
2930     }
2931
2932   printf("\n");
2933 }
2934
2935 static void
2936 print_hashline( MD_HANDLE md, int algo, const char *fname )
2937 {
2938     int i, n;
2939     const byte *p;
2940     
2941     if ( fname ) {
2942         for (p = fname; *p; p++ ) {
2943             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2944                 printf("%%%02X", *p );
2945             else 
2946                 putchar( *p );
2947         }
2948     }
2949     putchar(':');
2950     printf("%d:", algo );
2951     p = md_read( md, algo );
2952     n = md_digest_length(algo);
2953     for(i=0; i < n ; i++, p++ ) 
2954         printf("%02X", *p );
2955     putchar(':');
2956     putchar('\n');
2957 }
2958
2959 static void
2960 print_mds( const char *fname, int algo )
2961 {
2962     FILE *fp;
2963     char buf[1024];
2964     size_t n;
2965     MD_HANDLE md;
2966
2967     if( !fname ) {
2968         fp = stdin;
2969 #ifdef HAVE_DOSISH_SYSTEM
2970         setmode ( fileno(fp) , O_BINARY );
2971 #endif
2972     }
2973     else {
2974         fp = fopen( fname, "rb" );
2975     }
2976     if( !fp ) {
2977         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
2978         return;
2979     }
2980
2981     md = md_open( 0, 0 );
2982     if( algo )
2983         md_enable( md, algo );
2984     else {
2985         md_enable( md, DIGEST_ALGO_MD5 );
2986         md_enable( md, DIGEST_ALGO_SHA1 );
2987         md_enable( md, DIGEST_ALGO_RMD160 );
2988 #ifdef USE_TIGER192
2989         md_enable( md, DIGEST_ALGO_TIGER );
2990 #endif
2991 #ifdef USE_SHA256
2992         md_enable( md, DIGEST_ALGO_SHA256 );
2993 #endif
2994 #ifdef USE_SHA512
2995         md_enable( md, DIGEST_ALGO_SHA384 );
2996         md_enable( md, DIGEST_ALGO_SHA512 );
2997 #endif
2998     }
2999
3000     while( (n=fread( buf, 1, DIM(buf), fp )) )
3001         md_write( md, buf, n );
3002     if( ferror(fp) )
3003         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3004     else {
3005         md_final(md);
3006         if ( opt.with_colons ) {
3007             if ( algo ) 
3008                 print_hashline( md, algo, fname );
3009             else {
3010                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3011                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3012                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3013 #ifdef USE_TIGER192
3014                 print_hashline( md, DIGEST_ALGO_TIGER, fname );
3015 #endif
3016 #ifdef USE_SHA256
3017                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3018 #endif
3019 #ifdef USE_SHA512
3020                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3021                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3022 #endif
3023             }
3024         }
3025         else {
3026             if( algo )
3027                print_hex(md,-algo,fname);
3028             else {
3029                 print_hex( md, DIGEST_ALGO_MD5, fname );
3030                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3031                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3032 #ifdef USE_TIGER192
3033                 print_hex( md, DIGEST_ALGO_TIGER, fname );
3034 #endif
3035 #ifdef USE_SHA256
3036                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3037 #endif
3038 #ifdef USE_SHA512
3039                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3040                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3041 #endif
3042             }
3043         }
3044     }
3045     md_close(md);
3046
3047     if( fp != stdin )
3048         fclose(fp);
3049 }
3050
3051
3052 /****************
3053  * Check the supplied name,value string and add it to the notation
3054  * data to be used for signatures.  which==0 for sig notations, and 1
3055  * for cert notations.
3056 */
3057 static void
3058 add_notation_data( const char *string, int which )
3059 {
3060     const char *s;
3061     STRLIST sl,*notation_data;
3062     int critical=0;
3063     int highbit=0;
3064     int saw_at=0;
3065
3066     if(which)
3067       notation_data=&opt.cert_notation_data;
3068     else
3069       notation_data=&opt.sig_notation_data;
3070
3071     if( *string == '!' ) {
3072         critical = 1;
3073         string++;
3074     }
3075
3076     /* If and when the IETF assigns some official name tags, we'll
3077        have to add them here. */
3078
3079     for( s=string ; *s != '='; s++ )
3080       {
3081         if( *s=='@')
3082           saw_at=1;
3083
3084         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3085           {
3086             log_error(_("a notation name must have only printable characters "
3087                         "or spaces, and end with an '='\n") );
3088             return;
3089           }
3090       }
3091
3092     if(!saw_at && !opt.expert)
3093       {
3094         log_error(
3095                 _("a user notation name must contain the '@' character\n"));
3096         return;
3097       }
3098
3099     /* we only support printable text - therefore we enforce the use
3100      * of only printable characters (an empty value is valid) */
3101     for( s++; *s ; s++ ) {
3102         if ((*s & 0x80))
3103           highbit = 1;
3104         else if (iscntrl(*s)) {
3105             log_error(_("a notation value must not use "
3106                         "any control characters\n") );
3107             return;
3108         }
3109     }
3110
3111     if( highbit )   /* must use UTF8 encoding */
3112         sl = add_to_strlist2( notation_data, string, utf8_strings );
3113     else
3114         sl = add_to_strlist( notation_data, string );
3115
3116     if( critical )
3117         sl->flags |= 1;
3118 }
3119
3120 static void
3121 add_policy_url( const char *string, int which )
3122 {
3123   int i,critical=0;
3124   STRLIST sl;
3125
3126   if(*string=='!')
3127     {
3128       string++;
3129       critical=1;
3130     }
3131
3132   for(i=0;i<strlen(string);i++)
3133     if(string[i]&0x80 || iscntrl(string[i]))
3134       break;
3135
3136   if(i==0 || i<strlen(string))
3137     {
3138       if(which)
3139         log_error(_("the given certification policy URL is invalid\n"));
3140       else
3141         log_error(_("the given signature policy URL is invalid\n"));
3142     }
3143
3144   if(which)
3145     sl=add_to_strlist( &opt.cert_policy_url, string );
3146   else
3147     sl=add_to_strlist( &opt.sig_policy_url, string );
3148
3149   if(critical)
3150     sl->flags |= 1;    
3151 }
3152
3153 static void
3154 add_keyserver_url( const char *string, int which )
3155 {
3156   int i,critical=0;
3157   STRLIST sl;
3158
3159   if(*string=='!')
3160     {
3161       string++;
3162       critical=1;
3163     }
3164
3165   for(i=0;i<strlen(string);i++)
3166     if(string[i]&0x80 || iscntrl(string[i]))
3167       break;
3168
3169   if(i==0 || i<strlen(string))
3170     {
3171       if(which)
3172         BUG();
3173       else
3174         log_error(_("the given signature preferred keyserver "
3175                     "URL is invalid\n"));
3176     }
3177
3178   if(which)
3179     BUG();
3180   else
3181     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3182
3183   if(critical)
3184     sl->flags |= 1;    
3185 }