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