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