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