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