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