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