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