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