* parse-packet.c (parse_signature): No need to reserve 8 bytes for the
[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-keyring",LIST_SHOW_KEYRING},
1761                   {"show-validity",LIST_SHOW_VALIDITY},
1762                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
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                   {NULL,0}
1785                 };
1786
1787               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1788                 {
1789                   if(configname)
1790                     log_error(_("%s:%d: invalid verify options\n"),
1791                               configname,configlineno);
1792                   else
1793                     log_error(_("invalid verify options\n"));
1794                 }
1795             }
1796             break;
1797           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1798           case oExecPath:
1799             if(set_exec_path(pargs.r.ret_str,0))
1800               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1801             else
1802               opt.exec_path_set=1;
1803             break;
1804           case oSetNotation:
1805             add_notation_data( pargs.r.ret_str, 0 );
1806             add_notation_data( pargs.r.ret_str, 1 );
1807             break;
1808           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1809           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1810           case oShowNotation:
1811             opt.list_options|=LIST_SHOW_NOTATION;
1812             opt.verify_options|=VERIFY_SHOW_NOTATION;
1813             break;
1814           case oNoShowNotation:
1815             opt.list_options&=~LIST_SHOW_NOTATION;
1816             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1817             break;
1818           case oUtf8Strings: utf8_strings = 1; break;
1819           case oNoUtf8Strings: utf8_strings = 0; break;
1820           case oDisableCipherAlgo:
1821                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1822                 break;
1823           case oDisablePubkeyAlgo:
1824                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1825                 break;
1826           case oNoSigCache: opt.no_sig_cache = 1; break;
1827           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1828           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1829           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1830           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1831           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1832           case oNoLiteral: opt.no_literal = 1; break;
1833           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1834           case oHonorHttpProxy:
1835                 opt.keyserver_options.honor_http_proxy = 1;
1836                 deprecated_warning(configname,configlineno,
1837                                    "--honor-http-proxy",
1838                                    "--keyserver-options ",
1839                                    "honor-http-proxy");
1840                 break;
1841           case oFastListMode: opt.fast_list_mode = 1; break;
1842           case oFixedListMode: opt.fixed_list_mode = 1; break;
1843           case oListOnly: opt.list_only=1; break;
1844           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1845           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1846           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1847           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1848           case oNoRandomSeedFile: use_random_seed = 0; break;
1849           case oAutoKeyRetrieve:
1850           case oNoAutoKeyRetrieve:
1851                 opt.keyserver_options.auto_key_retrieve=
1852                                              (pargs.r_opt==oAutoKeyRetrieve);
1853                 deprecated_warning(configname,configlineno,
1854                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1855                                "--no-auto-key-retrieve","--keyserver-options ",
1856                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1857                                "no-auto-key-retrieve");
1858                 break;
1859           case oShowSessionKey: opt.show_session_key = 1; break;
1860           case oOverrideSessionKey:
1861                 opt.override_session_key = pargs.r.ret_str;
1862                 break;
1863           case oMergeOnly: opt.merge_only = 1; break;
1864           case oAllowSecretKeyImport: /* obsolete */ break;
1865           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1866           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1867           case oEnableSpecialFilenames:
1868             iobuf_enable_special_filenames (1);
1869             break;
1870           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1871           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1872           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1873           case oPreservePermissions: opt.preserve_permissions=1; break;
1874           case oDefaultPreferenceList:
1875             opt.def_preference_list = pargs.r.ret_str;
1876             break;
1877           case oPersonalCipherPreferences:
1878             pers_cipher_list=pargs.r.ret_str;
1879             break;
1880           case oPersonalDigestPreferences:
1881             pers_digest_list=pargs.r.ret_str;
1882             break;
1883           case oPersonalCompressPreferences:
1884             pers_compress_list=pargs.r.ret_str;
1885             break;
1886           case oDisplay: opt.display = pargs.r.ret_str; break;
1887           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1888           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1889           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1890           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1891           case oGroup: add_group(pargs.r.ret_str); break;
1892           case oStrict: opt.strict=1; log_set_strict(1); break;
1893           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1894
1895           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1896           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1897
1898           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1899
1900           default : pargs.err = configfp? 1:2; break;
1901         }
1902     }
1903
1904     if( configfp ) {
1905         fclose( configfp );
1906         configfp = NULL;
1907         m_free(configname); configname = NULL;
1908         goto next_pass;
1909     }
1910     m_free( configname ); configname = NULL;
1911     if( log_get_errorcount(0) )
1912         g10_exit(2);
1913     if( nogreeting )
1914         greeting = 0;
1915
1916     if( greeting ) {
1917         fprintf(stderr, "%s %s; %s\n",
1918                         strusage(11), strusage(13), strusage(14) );
1919         fprintf(stderr, "%s\n", strusage(15) );
1920     }
1921 #ifdef IS_DEVELOPMENT_VERSION
1922     if( !opt.batch ) {
1923         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1924         log_info("It is only intended for test purposes and should NOT be\n");
1925         log_info("used in a production environment or with production keys!\n");
1926     }
1927 #endif
1928
1929     if (opt.verbose > 2)
1930         log_info ("using character set `%s'\n", get_native_charset ());
1931
1932     if( may_coredump && !opt.quiet )
1933         log_info(_("WARNING: program may create a core file!\n"));
1934
1935     if (eyes_only) {
1936       if (opt.set_filename)
1937           log_info(_("WARNING: %s overrides %s\n"),
1938                    "--for-your-eyes-only","--set-filename");
1939
1940       opt.set_filename="_CONSOLE";
1941     }
1942
1943     if (opt.no_literal) {
1944         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1945         if (opt.textmode)
1946             log_error(_("%s not allowed with %s!\n"),
1947                        "--textmode", "--no-literal" );
1948         if (opt.set_filename)
1949             log_error(_("%s makes no sense with %s!\n"),
1950                         eyes_only?"--for-your-eyes-only":"--set-filename",
1951                         "--no-literal" );
1952     }
1953
1954     if (opt.set_filesize)
1955         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1956     if( opt.batch )
1957         tty_batchmode( 1 );
1958
1959     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1960
1961     set_debug();
1962
1963     /* Do these after the switch(), so they can override settings. */
1964     if(PGP2)
1965       {
1966         int unusable=0;
1967
1968         if(cmd==aSign && !detached_sig)
1969           {
1970             log_info(_("you can only make detached or clear signatures "
1971                        "while in --pgp2 mode\n"));
1972             unusable=1;
1973           }
1974         else if(cmd==aSignEncr || cmd==aSignSym)
1975           {
1976             log_info(_("you can't sign and encrypt at the "
1977                        "same time while in --pgp2 mode\n"));
1978             unusable=1;
1979           }
1980         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1981           {
1982             log_info(_("you must use files (and not a pipe) when "
1983                        "working with --pgp2 enabled.\n"));
1984             unusable=1;
1985           }
1986         else if(cmd==aEncr || cmd==aSym)
1987           {
1988             /* Everything else should work without IDEA (except using
1989                a secret key encrypted with IDEA and setting an IDEA
1990                preference, but those have their own error
1991                messages). */
1992
1993             if(check_cipher_algo(CIPHER_ALGO_IDEA))
1994               {
1995                 log_info(_("encrypting a message in --pgp2 mode requires "
1996                            "the IDEA cipher\n"));
1997                 idea_cipher_warn(1);
1998                 unusable=1;
1999               }
2000             else if(cmd==aSym)
2001               {
2002                 /* This only sets IDEA for symmetric encryption
2003                    since it is set via select_algo_from_prefs for
2004                    pk encryption. */
2005                 m_free(def_cipher_string);
2006                 def_cipher_string = m_strdup("idea");
2007               }
2008
2009             /* PGP2 can't handle the output from the textmode
2010                filter, so we disable it for anything that could
2011                create a literal packet (only encryption and
2012                symmetric encryption, since we disable signing
2013                above). */
2014             if(!unusable)
2015               opt.textmode=0;
2016           }
2017
2018         if(unusable)
2019           compliance_failure();
2020         else
2021           {
2022             opt.force_mdc = 0;
2023             opt.disable_mdc = 1;
2024             opt.force_v4_certs = 0;
2025             opt.sk_comments = 0;
2026             opt.escape_from = 1;
2027             opt.force_v3_sigs = 1;
2028             opt.pgp2_workarounds = 1;
2029             opt.ask_sig_expire = 0;
2030             opt.ask_cert_expire = 0;
2031             m_free(def_digest_string);
2032             def_digest_string = m_strdup("md5");
2033             opt.def_compress_algo = 1;
2034           }
2035       }
2036     else if(PGP6)
2037       {
2038         opt.sk_comments=0;
2039         opt.escape_from=1;
2040         opt.force_v3_sigs=1;
2041         opt.ask_sig_expire=0;
2042         opt.force_mdc=0;
2043         opt.disable_mdc=1;
2044       }
2045     else if(PGP7)
2046       {
2047         opt.sk_comments=0;
2048         opt.escape_from=1;
2049         opt.force_v3_sigs=1;
2050         opt.ask_sig_expire=0;
2051       }
2052     else if(PGP8)
2053       {
2054         opt.escape_from=1;
2055       }
2056
2057     /* must do this after dropping setuid, because string_to...
2058      * may try to load an module */
2059     if( def_cipher_string ) {
2060         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2061         if(opt.def_cipher_algo==0 &&
2062            (ascii_strcasecmp(def_cipher_string,"idea")==0
2063             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2064           idea_cipher_warn(1);
2065         m_free(def_cipher_string); def_cipher_string = NULL;
2066         if( check_cipher_algo(opt.def_cipher_algo) )
2067             log_error(_("selected cipher algorithm is invalid\n"));
2068     }
2069     if( def_digest_string ) {
2070         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2071         m_free(def_digest_string); def_digest_string = NULL;
2072         if( check_digest_algo(opt.def_digest_algo) )
2073             log_error(_("selected digest algorithm is invalid\n"));
2074     }
2075     if( def_compress_string ) {
2076         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2077         m_free(def_compress_string); def_compress_string = NULL;
2078         if( check_compress_algo(opt.def_compress_algo) )
2079             log_error(_("selected compression algorithm is invalid\n"));
2080     }
2081     if( cert_digest_string ) {
2082         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2083         m_free(cert_digest_string); cert_digest_string = NULL;
2084         if( check_digest_algo(opt.cert_digest_algo) )
2085             log_error(_("selected certification digest algorithm is invalid\n"));
2086     }
2087     if( s2k_cipher_string ) {
2088         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2089         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2090         if( check_cipher_algo(opt.s2k_cipher_algo) )
2091             log_error(_("selected cipher algorithm is invalid\n"));
2092     }
2093     if( s2k_digest_string ) {
2094         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2095         m_free(s2k_digest_string); s2k_digest_string = NULL;
2096         if( check_digest_algo(opt.s2k_digest_algo) )
2097             log_error(_("selected digest algorithm is invalid\n"));
2098     }
2099     if( opt.completes_needed < 1 )
2100         log_error(_("completes-needed must be greater than 0\n"));
2101     if( opt.marginals_needed < 2 )
2102         log_error(_("marginals-needed must be greater than 1\n"));
2103     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2104         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2105     switch( opt.s2k_mode ) {
2106       case 0:
2107         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2108         break;
2109       case 1: case 3: break;
2110       default:
2111         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2112     }
2113
2114     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2115       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2116
2117     /* This isn't actually needed, but does serve to error out if the
2118        string is invalid. */
2119     if(opt.def_preference_list &&
2120         keygen_set_std_prefs(opt.def_preference_list,0))
2121       log_error(_("invalid default preferences\n"));
2122
2123     /* We provide defaults for the personal digest list */
2124     if(!pers_digest_list)
2125       pers_digest_list="h2";
2126
2127     if(pers_cipher_list &&
2128        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2129       log_error(_("invalid personal cipher preferences\n"));
2130
2131     if(pers_digest_list &&
2132        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2133       log_error(_("invalid personal digest preferences\n"));
2134
2135     if(pers_compress_list &&
2136        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2137       log_error(_("invalid personal compress preferences\n"));
2138
2139     if( log_get_errorcount(0) )
2140         g10_exit(2);
2141
2142     /* Check our chosen algorithms against the list of legal
2143        algorithms. */
2144
2145     if(!GNUPG)
2146       {
2147         const char *badalg=NULL;
2148         preftype_t badtype=PREFTYPE_NONE;
2149
2150         if(opt.def_cipher_algo
2151            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2152           {
2153             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2154             badtype=PREFTYPE_SYM;
2155           }
2156         else if(opt.def_digest_algo
2157                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2158           {
2159             badalg=digest_algo_to_string(opt.def_digest_algo);
2160             badtype=PREFTYPE_HASH;
2161           }
2162         else if(opt.cert_digest_algo
2163                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2164           {
2165             badalg=digest_algo_to_string(opt.cert_digest_algo);
2166             badtype=PREFTYPE_HASH;
2167           }
2168         else if(opt.def_compress_algo!=-1
2169                 && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2170           {
2171             badalg=compress_algo_to_string(opt.def_compress_algo);
2172             badtype=PREFTYPE_ZIP;
2173           }
2174
2175         if(badalg)
2176           {
2177             switch(badtype)
2178               {
2179               case PREFTYPE_SYM:
2180                 log_info(_("you may not use cipher algorithm \"%s\" "
2181                            "while in %s mode\n"),
2182                          badalg,compliance_option_string());
2183                 break;
2184               case PREFTYPE_HASH:
2185                 log_info(_("you may not use digest algorithm \"%s\" "
2186                            "while in %s mode\n"),
2187                          badalg,compliance_option_string());
2188                 break;
2189               case PREFTYPE_ZIP:
2190                 log_info(_("you may not use compression algorithm \"%s\" "
2191                            "while in %s mode\n"),
2192                          badalg,compliance_option_string());
2193                 break;
2194               default:
2195                 BUG();
2196               }
2197
2198             compliance_failure();
2199           }
2200       }
2201
2202     /* set the random seed file */
2203     if( use_random_seed ) {
2204         char *p = make_filename(opt.homedir, "random_seed", NULL );
2205         set_random_seed_file(p);
2206         m_free(p);
2207     }
2208
2209     if( !cmd && opt.fingerprint && !with_fpr ) {
2210         set_cmd( &cmd, aListKeys);
2211     }
2212
2213     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2214         if( cmd == aKModeC ) {
2215             opt.fingerprint = 1;
2216             cmd = aKMode;
2217         }
2218         opt.list_sigs = 0;
2219         if( opt.verbose > 2 )
2220             opt.check_sigs++;
2221         if( opt.verbose > 1 )
2222             opt.list_sigs++;
2223
2224         opt.verbose = opt.verbose > 1;
2225         g10_opt_verbose = opt.verbose;
2226     }
2227
2228     /* Compression algorithm 0 means no compression at all */
2229     if( opt.def_compress_algo == 0)
2230         opt.compress = 0;
2231
2232     /* kludge to let -sat generate a clear text signature */
2233     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2234         cmd = aClearsign;
2235
2236     if( opt.verbose > 1 )
2237         set_packet_list_mode(1);
2238
2239     /* Add the keyrings, but not for some special commands and not in
2240        case of "-kvv userid keyring".  Also avoid adding the secret
2241        keyring for a couple of commands to avoid unneeded access in
2242        case the secrings are stored on a floppy */
2243     if( cmd != aDeArmor && cmd != aEnArmor
2244         && !(cmd == aKMode && argc == 2 ) ) 
2245       {
2246         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2247             && cmd != aVerify && cmd != aVerifyFiles
2248             && cmd != aSym)
2249           {
2250             if (!sec_nrings || default_keyring) /* add default secret rings */
2251               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2252             for (sl = sec_nrings; sl; sl = sl->next)
2253               keydb_add_resource ( sl->d, 0, 1 );
2254           }
2255         if( !nrings || default_keyring )  /* add default ring */
2256             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2257         for(sl = nrings; sl; sl = sl->next )
2258             keydb_add_resource ( sl->d, sl->flags, 0 );
2259       }
2260     FREE_STRLIST(nrings);
2261     FREE_STRLIST(sec_nrings);
2262
2263
2264     if( pwfd != -1 )  /* read the passphrase now. */
2265         read_passphrase_from_fd( pwfd );
2266
2267     fname = argc? *argv : NULL;
2268
2269     switch( cmd ) {
2270       case aPrimegen:
2271       case aPrintMD:
2272       case aPrintMDs:
2273       case aGenRandom:
2274       case aDeArmor:
2275       case aEnArmor:
2276       case aFixTrustDB:
2277         break;
2278       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2279       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2280       default: rc = setup_trustdb(1, trustdb_name ); break;
2281     }
2282     if( rc )
2283         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2284
2285
2286     switch (cmd) {
2287       case aStore: 
2288       case aSym:  
2289       case aSign: 
2290       case aSignSym: 
2291       case aClearsign: 
2292         if (!opt.quiet && any_explicit_recipient)
2293           log_info (_("WARNING: recipients (-r) given "
2294                       "without using public key encryption\n"));
2295         break;
2296       default:
2297         break;
2298     }
2299
2300     switch( cmd ) {
2301       case aStore: /* only store the file */
2302         if( argc > 1 )
2303             wrong_args(_("--store [filename]"));
2304         if( (rc = encode_store(fname)) )
2305             log_error_f( print_fname_stdin(fname),
2306                         "store failed: %s\n", g10_errstr(rc) );
2307         break;
2308       case aSym: /* encrypt the given file only with the symmetric cipher */
2309         if( argc > 1 )
2310             wrong_args(_("--symmetric [filename]"));
2311         if( (rc = encode_symmetric(fname)) )
2312             log_error_f(print_fname_stdin(fname),
2313                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2314         break;
2315
2316       case aEncr: /* encrypt the given file */
2317         if( argc > 1 )
2318             wrong_args(_("--encrypt [filename]"));
2319         if( (rc = encode_crypt(fname,remusr)) )
2320             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2321         break;
2322
2323       case aEncrFiles: /* encrypt the given files */
2324         encode_crypt_files(argc, argv, remusr);
2325         break;
2326           
2327       case aSign: /* sign the given file */
2328         sl = NULL;
2329         if( detached_sig ) { /* sign all files */
2330             for( ; argc; argc--, argv++ )
2331                 add_to_strlist( &sl, *argv );
2332         }
2333         else {
2334             if( argc > 1 )
2335                 wrong_args(_("--sign [filename]"));
2336             if( argc ) {
2337                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2338                 strcpy(sl->d, fname);
2339             }
2340         }
2341         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2342             log_error("signing failed: %s\n", g10_errstr(rc) );
2343         free_strlist(sl);
2344         break;
2345
2346       case aSignEncr: /* sign and encrypt the given file */
2347         if( argc > 1 )
2348             wrong_args(_("--sign --encrypt [filename]"));
2349         if( argc ) {
2350             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2351             strcpy(sl->d, fname);
2352         }
2353         else
2354             sl = NULL;
2355         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2356             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2357         free_strlist(sl);
2358         break;
2359
2360       case aSignSym: /* sign and conventionally encrypt the given file */
2361         if (argc > 1)
2362             wrong_args(_("--sign --symmetric [filename]"));
2363         rc = sign_symencrypt_file (fname, locusr);
2364         if (rc)
2365             log_error("%s: sign+symmetric failed: %s\n",
2366                       print_fname_stdin(fname), g10_errstr(rc) );
2367         break;
2368
2369       case aClearsign: /* make a clearsig */
2370         if( argc > 1 )
2371             wrong_args(_("--clearsign [filename]"));
2372         if( (rc = clearsign_file(fname, locusr, NULL)) )
2373             log_error("%s: clearsign failed: %s\n",
2374                       print_fname_stdin(fname), g10_errstr(rc) );
2375         break;
2376
2377       case aVerify:
2378         if( (rc = verify_signatures( argc, argv ) ))
2379             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2380         break;
2381
2382       case aVerifyFiles:
2383         if( (rc = verify_files( argc, argv ) ))
2384             log_error("verify files failed: %s\n", g10_errstr(rc) );
2385         break;
2386
2387       case aDecrypt:
2388         if( argc > 1 )
2389             wrong_args(_("--decrypt [filename]"));
2390         if( (rc = decrypt_message( fname ) ))
2391             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2392         break;
2393
2394       case aDecryptFiles:
2395         decrypt_messages(argc, argv);
2396         break;
2397             
2398       case aSignKey: /* sign the key given as argument */
2399         if( argc != 1 )
2400             wrong_args(_("--sign-key user-id"));
2401         username = make_username( fname );
2402         keyedit_menu(fname, locusr, NULL, 1 );
2403         m_free(username);
2404         break;
2405
2406       case aLSignKey:
2407         if( argc != 1 )
2408             wrong_args(_("--lsign-key user-id"));
2409         username = make_username( fname );
2410         keyedit_menu(fname, locusr, NULL, 2 );
2411         m_free(username);
2412         break;
2413
2414       case aNRSignKey:
2415         if( argc != 1 )
2416             wrong_args(_("--nrsign-key user-id"));
2417         username = make_username( fname );
2418         keyedit_menu(fname, locusr, NULL, 3 );
2419         m_free(username);
2420         break;
2421
2422       case aNRLSignKey:
2423         if( argc != 1 )
2424             wrong_args(_("--nrlsign-key user-id"));
2425         username = make_username( fname );
2426         keyedit_menu(fname, locusr, NULL, 4 );
2427         m_free(username);
2428         break;
2429
2430       case aEditKey: /* Edit a key signature */
2431         if( !argc )
2432             wrong_args(_("--edit-key user-id [commands]"));
2433         username = make_username( fname );
2434         if( argc > 1 ) {
2435             sl = NULL;
2436             for( argc--, argv++ ; argc; argc--, argv++ )
2437                 append_to_strlist( &sl, *argv );
2438             keyedit_menu( username, locusr, sl, 0 );
2439             free_strlist(sl);
2440         }
2441         else
2442             keyedit_menu(username, locusr, NULL, 0 );
2443         m_free(username);
2444         break;
2445
2446       case aDeleteKeys:
2447       case aDeleteSecretKeys:
2448       case aDeleteSecretAndPublicKeys:
2449         sl = NULL;
2450         /* I'm adding these in reverse order as add_to_strlist2
2451            reverses them again, and it's easier to understand in the
2452            proper order :) */
2453         for( ; argc; argc-- )
2454           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2455         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2456         free_strlist(sl);
2457         break;
2458
2459       case aCheckKeys:
2460         opt.check_sigs = 1;
2461       case aListSigs:
2462         opt.list_sigs = 1;
2463       case aListKeys:
2464         sl = NULL;
2465         for( ; argc; argc--, argv++ )
2466             add_to_strlist2( &sl, *argv, utf8_strings );
2467         public_key_list( sl );
2468         free_strlist(sl);
2469         break;
2470       case aListSecretKeys:
2471         sl = NULL;
2472         for( ; argc; argc--, argv++ )
2473             add_to_strlist2( &sl, *argv, utf8_strings );
2474         secret_key_list( sl );
2475         free_strlist(sl);
2476         break;
2477
2478       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2479         if( argc < 2 ) { /* -kv [userid] */
2480             sl = NULL;
2481             if (argc && **argv)
2482                 add_to_strlist2( &sl, *argv, utf8_strings );
2483             public_key_list( sl );
2484             free_strlist(sl);
2485         }
2486         else if( argc == 2 ) { /* -kv userid keyring */
2487             if( access( argv[1], R_OK ) ) {
2488                 log_error(_("can't open %s: %s\n"),
2489                                print_fname_stdin(argv[1]), strerror(errno));
2490             }
2491             else {
2492                 /* add keyring (default keyrings are not registered in this
2493                  * special case */
2494                 keydb_add_resource( argv[1], 0, 0 );
2495                 sl = NULL;
2496                 if (**argv)
2497                     add_to_strlist2( &sl, *argv, utf8_strings );
2498                 public_key_list( sl );
2499                 free_strlist(sl);
2500             }
2501         }
2502         else
2503             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2504         break;
2505
2506       case aKeygen: /* generate a key */
2507         if( opt.batch ) {
2508             if( argc > 1 )
2509                 wrong_args("--gen-key [parameterfile]");
2510             generate_keypair( argc? *argv : NULL );
2511         }
2512         else {
2513             if( argc )
2514                 wrong_args("--gen-key");
2515             generate_keypair(NULL);
2516         }
2517         break;
2518
2519       case aFastImport:
2520         opt.import_options |= IMPORT_FAST_IMPORT;
2521       case aImport:
2522         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2523         break;
2524
2525       case aExport:
2526       case aExportAll:
2527       case aSendKeys:
2528       case aRecvKeys:
2529         sl = NULL;
2530         for( ; argc; argc--, argv++ )
2531             add_to_strlist2( &sl, *argv, utf8_strings );
2532         if( cmd == aSendKeys )
2533             rc=keyserver_export( sl );
2534         else if( cmd == aRecvKeys )
2535             rc=keyserver_import( sl );
2536         else
2537             rc=export_pubkeys( sl, opt.export_options );
2538         if(rc)
2539           {
2540             if(cmd==aSendKeys)
2541               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
2542             else if(cmd==aRecvKeys)
2543               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
2544             else
2545               log_error(_("key export failed: %s\n"),g10_errstr(rc));
2546           }
2547         free_strlist(sl);
2548         break;
2549
2550      case aSearchKeys:
2551         sl = NULL;
2552         for( ; argc; argc--, argv++ )
2553           append_to_strlist2( &sl, *argv, utf8_strings );
2554
2555         rc=keyserver_search( sl );
2556         if(rc)
2557           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
2558         free_strlist(sl);
2559         break;
2560
2561       case aRefreshKeys:
2562         sl = NULL;
2563         for( ; argc; argc--, argv++ )
2564             add_to_strlist2( &sl, *argv, utf8_strings );
2565         rc=keyserver_refresh(sl);
2566         if(rc)
2567           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
2568         free_strlist(sl);
2569         break;
2570
2571       case aExportSecret:
2572         sl = NULL;
2573         for( ; argc; argc--, argv++ )
2574             add_to_strlist2( &sl, *argv, utf8_strings );
2575         export_seckeys( sl );
2576         free_strlist(sl);
2577         break;
2578
2579       case aExportSecretSub:
2580         sl = NULL;
2581         for( ; argc; argc--, argv++ )
2582             add_to_strlist2( &sl, *argv, utf8_strings );
2583         export_secsubkeys( sl );
2584         free_strlist(sl);
2585         break;
2586
2587       case aGenRevoke:
2588         if( argc != 1 )
2589             wrong_args("--gen-revoke user-id");
2590         username =  make_username(*argv);
2591         gen_revoke( username );
2592         m_free( username );
2593         break;
2594
2595       case aDesigRevoke:
2596         if( argc != 1 )
2597             wrong_args("--desig-revoke user-id");
2598         username =  make_username(*argv);
2599         gen_desig_revoke( username );
2600         m_free( username );
2601         break;
2602
2603       case aDeArmor:
2604         if( argc > 1 )
2605             wrong_args("--dearmor [file]");
2606         rc = dearmor_file( argc? *argv: NULL );
2607         if( rc )
2608             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2609         break;
2610
2611       case aEnArmor:
2612         if( argc > 1 )
2613             wrong_args("--enarmor [file]");
2614         rc = enarmor_file( argc? *argv: NULL );
2615         if( rc )
2616             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2617         break;
2618
2619
2620       case aPrimegen:
2621         {   int mode = argc < 2 ? 0 : atoi(*argv);
2622
2623             if( mode == 1 && argc == 2 ) {
2624                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2625             }
2626             else if( mode == 2 && argc == 3 ) {
2627                 mpi_print( stdout, generate_elg_prime(
2628                                              0, atoi(argv[1]),
2629                                              atoi(argv[2]), NULL,NULL ), 1);
2630             }
2631             else if( mode == 3 && argc == 3 ) {
2632                 MPI *factors;
2633                 mpi_print( stdout, generate_elg_prime(
2634                                              1, atoi(argv[1]),
2635                                              atoi(argv[2]), NULL,&factors ), 1);
2636                 putchar('\n');
2637                 mpi_print( stdout, factors[0], 1 ); /* print q */
2638             }
2639             else if( mode == 4 && argc == 3 ) {
2640                 MPI g = mpi_alloc(1);
2641                 mpi_print( stdout, generate_elg_prime(
2642                                                  0, atoi(argv[1]),
2643                                                  atoi(argv[2]), g, NULL ), 1);
2644                 putchar('\n');
2645                 mpi_print( stdout, g, 1 );
2646                 mpi_free(g);
2647             }
2648             else
2649                 wrong_args("--gen-prime mode bits [qbits] ");
2650             putchar('\n');
2651         }
2652         break;
2653
2654       case aGenRandom:
2655         {
2656             int level = argc ? atoi(*argv):0;
2657             int count = argc > 1 ? atoi(argv[1]): 0;
2658             int endless = !count;
2659
2660             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2661                 wrong_args("--gen-random 0|1|2 [count]");
2662
2663             while( endless || count ) {
2664                 byte *p;
2665                 /* Wee need a multiple of 3, so that in case of
2666                    armored output we get a correct string.  No
2667                    linefolding is done, as it is best to levae this to
2668                    other tools */
2669                 size_t n = !endless && count < 99? count : 99;
2670
2671                 p = get_random_bits( n*8, level, 0);
2672 #ifdef HAVE_DOSISH_SYSTEM
2673                 setmode ( fileno(stdout), O_BINARY );
2674 #endif
2675                 if (opt.armor) {
2676                     char *tmp = make_radix64_string (p, n);
2677                     fputs (tmp, stdout);
2678                     m_free (tmp);
2679                     if (n%3 == 1)
2680                       putchar ('=');
2681                     if (n%3)
2682                       putchar ('=');
2683                 } else {
2684                     fwrite( p, n, 1, stdout );
2685                 }
2686                 m_free(p);
2687                 if( !endless )
2688                     count -= n;
2689             }
2690             if (opt.armor)
2691                 putchar ('\n');
2692         }
2693         break;
2694
2695       case aPrintMD:
2696         if( argc < 1)
2697             wrong_args("--print-md algo [files]");
2698         {
2699             int all_algos = (**argv=='*' && !(*argv)[1]);
2700             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2701
2702             if( !algo && !all_algos )
2703                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2704             else {
2705                 argc--; argv++;
2706                 if( !argc )
2707                     print_mds(NULL, algo);
2708                 else {
2709                     for(; argc; argc--, argv++ )
2710                         print_mds(*argv, algo);
2711                 }
2712             }
2713         }
2714         break;
2715
2716       case aPrintMDs: /* old option */
2717         if( !argc )
2718             print_mds(NULL,0);
2719         else {
2720             for(; argc; argc--, argv++ )
2721                 print_mds(*argv,0);
2722         }
2723         break;
2724
2725       case aListTrustDB:
2726         if( !argc )
2727             list_trustdb(NULL);
2728         else {
2729             for( ; argc; argc--, argv++ )
2730                 list_trustdb( *argv );
2731         }
2732         break;
2733
2734       case aUpdateTrustDB:
2735         if( argc )
2736             wrong_args("--update-trustdb");
2737         update_trustdb();
2738         break;
2739
2740       case aCheckTrustDB:
2741         /* Old versions allowed for arguments - ignore them */
2742         check_trustdb();
2743         break;
2744
2745       case aFixTrustDB:
2746         log_error("this command is not yet implemented.\n");
2747         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2748         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2749         break;
2750
2751       case aListTrustPath:
2752         if( !argc )
2753             wrong_args("--list-trust-path <user-ids>");
2754         for( ; argc; argc--, argv++ ) {
2755             username = make_username( *argv );
2756             list_trust_path( username );
2757             m_free(username);
2758         }
2759         break;
2760
2761       case aExportOwnerTrust:
2762         if( argc )
2763             wrong_args("--export-ownertrust");
2764         export_ownertrust();
2765         break;
2766
2767       case aImportOwnerTrust:
2768         if( argc > 1 )
2769             wrong_args("--import-ownertrust [file]");
2770         import_ownertrust( argc? *argv:NULL );
2771         break;
2772       
2773       case aPipeMode:
2774         if ( argc )
2775             wrong_args ("--pipemode");
2776         run_in_pipemode ();
2777         break;
2778
2779       case aRebuildKeydbCaches:
2780         if (argc)
2781             wrong_args ("--rebuild-keydb-caches");
2782         keydb_rebuild_caches ();
2783         break;
2784
2785       case aListPackets:
2786         opt.list_packets=2;
2787       default:
2788         if( argc > 1 )
2789             wrong_args(_("[filename]"));
2790         /* Issue some output for the unix newbie */
2791         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2792                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2793             log_info(_("Go ahead and type your message ...\n"));
2794
2795         if( !(a = iobuf_open(fname)) )
2796             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2797         else {
2798
2799             if( !opt.no_armor ) {
2800                 if( use_armor_filter( a ) ) {
2801                     memset( &afx, 0, sizeof afx);
2802                     iobuf_push_filter( a, armor_filter, &afx );
2803                 }
2804             }
2805             if( cmd == aListPackets ) {
2806                 set_packet_list_mode(1);
2807                 opt.list_packets=1;
2808             }
2809             rc = proc_packets(NULL, a );
2810             if( rc )
2811                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2812             iobuf_close(a);
2813         }
2814         break;
2815     }
2816
2817     /* cleanup */
2818     FREE_STRLIST(remusr);
2819     FREE_STRLIST(locusr);
2820     g10_exit(0);
2821     return 8; /*NEVER REACHED*/
2822 }
2823
2824
2825 void
2826 g10_exit( int rc )
2827 {
2828     update_random_seed_file();
2829     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2830         m_print_stats("on exit");
2831         random_dump_stats();
2832     }
2833     if( opt.debug )
2834         secmem_dump_stats();
2835     secmem_term();
2836     rc = rc? rc : log_get_errorcount(0)? 2 :
2837                         g10_errors_seen? 1 : 0;
2838     exit(rc );
2839 }
2840
2841
2842 /* Pretty-print hex hashes.  This assumes at least an 80-character
2843    display, but there are a few other similar assumptions in the
2844    display code. */
2845 static void
2846 print_hex( MD_HANDLE md, int algo, const char *fname )
2847 {
2848   int i,n,count,indent=0;
2849   const byte *p;
2850
2851   if(fname)
2852     indent=printf("%s: ",fname);
2853
2854   if(indent>40)
2855     {
2856       printf("\n");
2857       indent=0;
2858     }
2859
2860   if(algo==DIGEST_ALGO_RMD160)
2861     indent+=printf("RMD160 = ");
2862   else if(algo==DIGEST_ALGO_TIGER)
2863     indent+=printf(" TIGER = ");
2864   else if(algo>0)
2865     indent+=printf("%6s = ",digest_algo_to_string(algo));
2866   else
2867     algo=abs(algo);
2868
2869   count=indent;
2870
2871   p = md_read( md, algo );
2872   n = md_digest_length(algo);
2873
2874   count+=printf("%02X",*p++);
2875
2876   for(i=1;i<n;i++,p++)
2877     {
2878       if(n==16)
2879         {
2880           if(count+2>79)
2881             {
2882               printf("\n%*s",indent," ");
2883               count=indent;
2884             }
2885           else
2886             count+=printf(" ");
2887
2888           if(!(i%8))
2889             count+=printf(" ");
2890         }
2891       else if (n==20)
2892         {
2893           if(!(i%2))
2894             {
2895               if(count+4>79)
2896                 {
2897                   printf("\n%*s",indent," ");
2898                   count=indent;
2899                 }
2900               else
2901                 count+=printf(" ");
2902             }
2903
2904           if(!(i%10))
2905             count+=printf(" ");
2906         }
2907       else
2908         {
2909           if(!(i%4))
2910             {
2911               if(count+8>79)
2912                 {
2913                   printf("\n%*s",indent," ");
2914                   count=indent;
2915                 }
2916               else
2917                 count+=printf(" ");
2918             }
2919         }
2920
2921       count+=printf("%02X",*p);
2922     }
2923
2924   printf("\n");
2925 }
2926
2927 static void
2928 print_hashline( MD_HANDLE md, int algo, const char *fname )
2929 {
2930     int i, n;
2931     const byte *p;
2932     
2933     if ( fname ) {
2934         for (p = fname; *p; p++ ) {
2935             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2936                 printf("%%%02X", *p );
2937             else 
2938                 putchar( *p );
2939         }
2940     }
2941     putchar(':');
2942     printf("%d:", algo );
2943     p = md_read( md, algo );
2944     n = md_digest_length(algo);
2945     for(i=0; i < n ; i++, p++ ) 
2946         printf("%02X", *p );
2947     putchar(':');
2948     putchar('\n');
2949 }
2950
2951 static void
2952 print_mds( const char *fname, int algo )
2953 {
2954     FILE *fp;
2955     char buf[1024];
2956     size_t n;
2957     MD_HANDLE md;
2958
2959     if( !fname ) {
2960         fp = stdin;
2961 #ifdef HAVE_DOSISH_SYSTEM
2962         setmode ( fileno(fp) , O_BINARY );
2963 #endif
2964     }
2965     else {
2966         fp = fopen( fname, "rb" );
2967     }
2968     if( !fp ) {
2969         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
2970         return;
2971     }
2972
2973     md = md_open( 0, 0 );
2974     if( algo )
2975         md_enable( md, algo );
2976     else {
2977         md_enable( md, DIGEST_ALGO_MD5 );
2978         md_enable( md, DIGEST_ALGO_SHA1 );
2979         md_enable( md, DIGEST_ALGO_RMD160 );
2980 #ifdef USE_TIGER192
2981         md_enable( md, DIGEST_ALGO_TIGER );
2982 #endif
2983 #ifdef USE_SHA256
2984         md_enable( md, DIGEST_ALGO_SHA256 );
2985 #endif
2986 #ifdef USE_SHA512
2987         md_enable( md, DIGEST_ALGO_SHA384 );
2988         md_enable( md, DIGEST_ALGO_SHA512 );
2989 #endif
2990     }
2991
2992     while( (n=fread( buf, 1, DIM(buf), fp )) )
2993         md_write( md, buf, n );
2994     if( ferror(fp) )
2995         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
2996     else {
2997         md_final(md);
2998         if ( opt.with_colons ) {
2999             if ( algo ) 
3000                 print_hashline( md, algo, fname );
3001             else {
3002                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3003                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3004                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3005 #ifdef USE_TIGER192
3006                 print_hashline( md, DIGEST_ALGO_TIGER, fname );
3007 #endif
3008 #ifdef USE_SHA256
3009                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3010 #endif
3011 #ifdef USE_SHA512
3012                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3013                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3014 #endif
3015             }
3016         }
3017         else {
3018             if( algo )
3019                print_hex(md,-algo,fname);
3020             else {
3021                 print_hex( md, DIGEST_ALGO_MD5, fname );
3022                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3023                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3024 #ifdef USE_TIGER192
3025                 print_hex( md, DIGEST_ALGO_TIGER, fname );
3026 #endif
3027 #ifdef USE_SHA256
3028                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3029 #endif
3030 #ifdef USE_SHA512
3031                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3032                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3033 #endif
3034             }
3035         }
3036     }
3037     md_close(md);
3038
3039     if( fp != stdin )
3040         fclose(fp);
3041 }
3042
3043
3044 /****************
3045  * Check the supplied name,value string and add it to the notation
3046  * data to be used for signatures.  which==0 for sig notations, and 1
3047  * for cert notations.
3048 */
3049 static void
3050 add_notation_data( const char *string, int which )
3051 {
3052     const char *s;
3053     STRLIST sl,*notation_data;
3054     int critical=0;
3055     int highbit=0;
3056     int saw_at=0;
3057
3058     if(which)
3059       notation_data=&opt.cert_notation_data;
3060     else
3061       notation_data=&opt.sig_notation_data;
3062
3063     if( *string == '!' ) {
3064         critical = 1;
3065         string++;
3066     }
3067
3068     /* If and when the IETF assigns some official name tags, we'll
3069        have to add them here. */
3070
3071     for( s=string ; *s != '='; s++ )
3072       {
3073         if( *s=='@')
3074           saw_at=1;
3075
3076         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3077           {
3078             log_error(_("a notation name must have only printable characters "
3079                         "or spaces, and end with an '='\n") );
3080             return;
3081           }
3082       }
3083
3084     if(!saw_at && !opt.expert)
3085       {
3086         log_error(
3087                 _("a user notation name must contain the '@' character\n"));
3088         return;
3089       }
3090
3091     /* we only support printable text - therefore we enforce the use
3092      * of only printable characters (an empty value is valid) */
3093     for( s++; *s ; s++ ) {
3094         if ((*s & 0x80))
3095           highbit = 1;
3096         else if (iscntrl(*s)) {
3097             log_error(_("a notation value must not use "
3098                         "any control characters\n") );
3099             return;
3100         }
3101     }
3102
3103     if( highbit )   /* must use UTF8 encoding */
3104         sl = add_to_strlist2( notation_data, string, utf8_strings );
3105     else
3106         sl = add_to_strlist( notation_data, string );
3107
3108     if( critical )
3109         sl->flags |= 1;
3110 }
3111
3112
3113 static void
3114 add_policy_url( const char *string, int which )
3115 {
3116   int i,critical=0;
3117   STRLIST sl;
3118
3119   if(*string=='!')
3120     {
3121       string++;
3122       critical=1;
3123     }
3124
3125   for(i=0;i<strlen(string);i++)
3126     if(string[i]&0x80 || iscntrl(string[i]))
3127       break;
3128
3129   if(i==0 || i<strlen(string))
3130     {
3131       if(which)
3132         log_error(_("the given certification policy URL is invalid\n"));
3133       else
3134         log_error(_("the given signature policy URL is invalid\n"));
3135     }
3136
3137   if(which)
3138     sl=add_to_strlist( &opt.cert_policy_url, string );
3139   else
3140     sl=add_to_strlist( &opt.sig_policy_url, string );
3141
3142   if(critical)
3143     sl->flags |= 1;    
3144 }