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