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