* options.h, g10.c (main), keylist.c (list_keyblock_print): Add
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27 #include <unistd.h>
28 #include <assert.h>
29 #ifdef HAVE_DOSISH_SYSTEM
30 #include <fcntl.h> /* for setmode() */
31 #endif
32 #ifdef HAVE_STAT
33 #include <sys/stat.h> /* for stat() */
34 #endif
35
36 #define INCLUDED_BY_MAIN_MODULE 1
37 #include "packet.h"
38 #include "iobuf.h"
39 #include "memory.h"
40 #include "util.h"
41 #include "main.h"
42 #include "options.h"
43 #include "keydb.h"
44 #include "trustdb.h"
45 #include "mpi.h"
46 #include "cipher.h"
47 #include "filter.h"
48 #include "ttyio.h"
49 #include "i18n.h"
50 #include "status.h"
51 #include "g10defs.h"
52 #include "keyserver-internal.h"
53 #include "exec.h"
54
55 enum cmd_and_opt_values { aNull = 0,
56     oArmor        = 'a',
57     aDetachedSign = 'b',
58     aSym          = 'c',
59     aDecrypt      = 'd',
60     aEncr         = 'e',
61     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:
1402             g10_opt_verbose++;
1403             opt.verbose++;
1404             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1405             break;
1406           case oKOption: set_cmd( &cmd, aKMode ); break;
1407
1408           case oBatch: opt.batch = 1; nogreeting = 1; break;
1409           case oUseAgent:
1410 #ifndef __riscos__
1411             opt.use_agent = 1;
1412 #else /* __riscos__ */
1413             opt.use_agent = 0;
1414             riscos_not_implemented("use-agent");
1415 #endif /* __riscos__ */
1416             break;
1417           case oNoUseAgent: opt.use_agent = 0; break;
1418           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1419           case oAnswerYes: opt.answer_yes = 1; break;
1420           case oAnswerNo: opt.answer_no = 1; break;
1421           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1422           case oPrimaryKeyring:
1423             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1424             sl->flags=2;
1425             break;
1426           case oShowKeyring: opt.list_options|=LIST_SHOW_KEYRING; break;
1427           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1428           case oDebugAll: opt.debug = ~0; break;
1429           case oStatusFD:
1430             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1431             break;
1432 #ifdef __riscos__
1433           case oStatusFile:
1434             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1435             break;
1436 #endif /* __riscos__ */
1437           case oAttributeFD:
1438             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1439             break;
1440 #ifdef __riscos__
1441           case oAttributeFile:
1442             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1443             break;
1444 #endif /* __riscos__ */
1445           case oLoggerFD:
1446             log_set_logfile( NULL,
1447                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1448             break;
1449 #ifdef __riscos__
1450           case oLoggerFile:
1451             log_set_logfile( NULL,
1452                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1453             break;
1454 #endif /* __riscos__ */
1455           case oWithFingerprint:
1456             opt.with_fingerprint = 1;
1457             with_fpr=1; /*fall thru*/
1458           case oFingerprint: opt.fingerprint++; break;
1459           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1460           case oOptions:
1461             /* config files may not be nested (silently ignore them) */
1462             if( !configfp ) {
1463                 m_free(configname);
1464                 configname = m_strdup(pargs.r.ret_str);
1465                 goto next_pass;
1466             }
1467             break;
1468           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1469           case oNoDefKeyring: default_keyring = 0; break;
1470           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1471           case oNoGreeting: nogreeting = 1; break;
1472           case oNoVerbose: g10_opt_verbose = 0;
1473                            opt.verbose = 0; opt.list_sigs=0; break;
1474           case oQuickRandom: quick_random_gen(1); break;
1475           case oSKComments: opt.sk_comments=1; break;
1476           case oNoSKComments: opt.sk_comments=0; break;
1477           case oEmitVersion: opt.no_version=0; break;
1478           case oNoEmitVersion: opt.no_version=1; break;
1479           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1480           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1481           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1482           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1483           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1484           case oDefRecipient:
1485                     if( *pargs.r.ret_str )
1486                         opt.def_recipient = make_username(pargs.r.ret_str);
1487                     break;
1488           case oDefRecipientSelf:
1489                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1490                     opt.def_recipient_self = 1;
1491                     break;
1492           case oNoDefRecipient:
1493                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1494                     opt.def_recipient_self = 0;
1495                     break;
1496           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1497           case oHomedir: break;
1498           case oNoBatch: opt.batch = 0; break;
1499           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1500           case oWithColons: opt.with_colons=':'; break;
1501
1502           case oSkipVerify: opt.skip_verify=1; break;
1503           case oCompressKeys: opt.compress_keys = 1; break;
1504           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1505             /* There are many programs (like mutt) that call gpg with
1506                --always-trust so keep this option around for a long
1507                time. */
1508           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1509           case oTrustModel:
1510             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1511               opt.trust_model=TM_PGP;
1512             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1513               opt.trust_model=TM_CLASSIC;
1514             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1515               opt.trust_model=TM_ALWAYS;
1516             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1517               opt.trust_model=TM_AUTO;
1518             else
1519               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1520             break;
1521           case oForceOwnertrust:
1522             log_info(_("NOTE: %s is not for normal use!\n"),
1523                      "--force-ownertrust");
1524             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1525             if(opt.force_ownertrust==-1)
1526               {
1527                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1528                 opt.force_ownertrust=0;
1529               }
1530             break;
1531           case oLoadExtension:
1532 #ifndef __riscos__
1533 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
1534             if(check_permissions(pargs.r.ret_str,2))
1535               log_info(_("cipher extension \"%s\" not loaded due to "
1536                          "unsafe permissions\n"),pargs.r.ret_str);
1537             else
1538               register_cipher_extension(orig_argc? *orig_argv:NULL,
1539                                         pargs.r.ret_str);
1540 #endif
1541 #else /* __riscos__ */
1542             riscos_not_implemented("load-extension");
1543 #endif /* __riscos__ */
1544             break;
1545           case oRFC1991:
1546             opt.compliance = CO_RFC1991;
1547             opt.force_v4_certs = 0;
1548             opt.escape_from = 1;
1549             break;
1550           case oRFC2440:
1551           case oOpenPGP:
1552             /* TODO: When 2440bis becomes a RFC, these may need
1553                changing. */
1554             opt.compliance = CO_RFC2440;
1555             opt.allow_non_selfsigned_uid = 1;
1556             opt.allow_freeform_uid = 1;
1557             opt.pgp2_workarounds = 0;
1558             opt.escape_from = 0;
1559             opt.force_v3_sigs = 0;
1560             opt.compress_keys = 0;          /* not mandated  but we do it */
1561             opt.compress_sigs = 0;          /* ditto. */
1562             opt.not_dash_escaped = 0;
1563             opt.def_cipher_algo = 0;
1564             opt.def_digest_algo = 0;
1565             opt.cert_digest_algo = 0;
1566             opt.def_compress_algo = -1;
1567             opt.s2k_mode = 3; /* iterated+salted */
1568             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1569             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1570             break;
1571           case oPGP2:  opt.compliance = CO_PGP2;  break;
1572           case oPGP6:  opt.compliance = CO_PGP6;  break;
1573           case oPGP7:  opt.compliance = CO_PGP7;  break;
1574           case oPGP8:  opt.compliance = CO_PGP8;  break;
1575           case oGnuPG: opt.compliance = CO_GNUPG; break;
1576           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1577           case oCompressSigs: opt.compress_sigs = 1; break;
1578           case oRunAsShmCP:
1579 #ifndef __riscos__
1580 # ifndef USE_SHM_COPROCESSING
1581             /* not possible in the option file,
1582              * but we print the warning here anyway */
1583             log_error("shared memory coprocessing is not available\n");
1584 # endif
1585 #else /* __riscos__ */
1586             riscos_not_implemented("run-as-shm-coprocess");
1587 #endif /* __riscos__ */
1588             break;
1589           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1590           case oForYourEyesOnly: eyes_only = 1; break;
1591           case oNoForYourEyesOnly: eyes_only = 0; break;
1592           case oSetPolicyURL:
1593             add_policy_url(pargs.r.ret_str,0);
1594             add_policy_url(pargs.r.ret_str,1);
1595             break;
1596           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1597           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1598           case oShowPolicyURL:
1599             opt.list_options|=LIST_SHOW_POLICY;
1600             opt.verify_options|=VERIFY_SHOW_POLICY;
1601             break;
1602           case oNoShowPolicyURL:
1603             opt.list_options&=~LIST_SHOW_POLICY;
1604             opt.verify_options&=~VERIFY_SHOW_POLICY;
1605             break;
1606           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
1607           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1608           case oComment: add_to_strlist(&opt.comments,pargs.r.ret_str); break;
1609           case oDefaultComment:
1610             deprecated_warning(configname,configlineno,
1611                                "--default-comment","--no-comments","");
1612             /* fall through */
1613           case oNoComments:
1614             free_strlist(opt.comments);
1615             opt.comments=NULL;
1616             break;
1617           case oThrowKeyid: opt.throw_keyid = 1; break;
1618           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1619           case oShowPhotos: 
1620             opt.list_options|=LIST_SHOW_PHOTOS;
1621             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1622             break;
1623           case oNoShowPhotos:
1624             opt.list_options&=~LIST_SHOW_PHOTOS;
1625             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1626             break;
1627           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1628           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1629           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1630           case oForceV4Certs: opt.force_v4_certs = 1; break;
1631           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1632           case oForceMDC: opt.force_mdc = 1; break;
1633           case oNoForceMDC: opt.force_mdc = 0; break;
1634           case oDisableMDC: opt.disable_mdc = 1; break;
1635           case oNoDisableMDC: opt.disable_mdc = 0; break;
1636           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1637           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1638           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1639           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1640           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1641           case oEncryptTo: /* store the recipient in the second list */
1642             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1643             sl->flags = 1;
1644             break;
1645           case oHiddenEncryptTo: /* store the recipient in the second list */
1646             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1647             sl->flags = 1|2;
1648             break;
1649           case oRecipient: /* store the recipient */
1650             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1651             any_explicit_recipient = 1;
1652             break;
1653           case oHiddenRecipient: /* store the recipient with a flag */
1654             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1655             sl->flags = 2;
1656             any_explicit_recipient = 1;
1657             break;
1658           case oTextmodeShort: opt.textmode = 2; break;
1659           case oTextmode: opt.textmode=1;  break;
1660           case oNoTextmode: opt.textmode=0;  break;
1661           case oExpert: opt.expert = 1; break;
1662           case oNoExpert: opt.expert = 0; break;
1663           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1664           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1665           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1666           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1667           case oUser: /* store the local users */
1668             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1669             break;
1670           case oCompress: opt.compress = pargs.r.ret_int; break;
1671           case oPasswdFD:
1672             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1673             opt.use_agent = 0;
1674             break;
1675 #ifdef __riscos__
1676           case oPasswdFile:
1677             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1678             break;
1679 #endif /* __riscos__ */
1680           case oCommandFD:
1681             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1682             break;
1683 #ifdef __riscos__
1684           case oCommandFile:
1685             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1686             break;
1687 #endif /* __riscos__ */
1688           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1689           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1690           case oCompressAlgo:
1691             /* If it is all digits, stick a Z in front of it for
1692                later.  This is for backwards compatibility with
1693                versions that took the compress algorithm number. */
1694             {
1695               char *pt=pargs.r.ret_str;
1696               while(*pt)
1697                 {
1698                   if(!isdigit(*pt))
1699                     break;
1700
1701                   pt++;
1702                 }
1703
1704               if(*pt=='\0')
1705                 {
1706                   def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
1707                   strcpy(def_compress_string,"Z");
1708                   strcat(def_compress_string,pargs.r.ret_str);
1709                 }
1710               else
1711                 def_compress_string = m_strdup(pargs.r.ret_str);
1712             }
1713             break;
1714           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1715           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1716           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1717           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1718           case oCharset:
1719             if( set_native_charset( pargs.r.ret_str ) )
1720                 log_error(_("%s is not a valid character set\n"),
1721                                                     pargs.r.ret_str);
1722             break;
1723           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1724           case oEscapeFrom: opt.escape_from = 1; break;
1725           case oNoEscapeFrom: opt.escape_from = 0; break;
1726           case oLockOnce: opt.lock_once = 1; break;
1727           case oLockNever: disable_dotlock(); break;
1728           case oLockMultiple:
1729 #ifndef __riscos__
1730             opt.lock_once = 0;
1731 #else /* __riscos__ */
1732             riscos_not_implemented("lock-multiple");
1733 #endif /* __riscos__ */
1734             break;
1735           case oKeyServer:
1736             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1737             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1738               log_error(_("could not parse keyserver URI\n"));
1739             break;
1740           case oKeyServerOptions:
1741             parse_keyserver_options(pargs.r.ret_str);
1742             break;
1743           case oImportOptions:
1744             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1745               {
1746                 if(configname)
1747                   log_error(_("%s:%d: invalid import options\n"),
1748                             configname,configlineno);
1749                 else
1750                   log_error(_("invalid import options\n"));
1751               }
1752             break;
1753           case oExportOptions:
1754             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1755               {
1756                 if(configname)
1757                   log_error(_("%s:%d: invalid export options\n"),
1758                             configname,configlineno);
1759                 else
1760                   log_error(_("invalid export options\n"));
1761               }
1762             break;
1763           case oListOptions:
1764             {
1765               struct parse_options lopts[]=
1766                 {
1767                   {"show-photos",LIST_SHOW_PHOTOS},
1768                   {"show-policy-url",LIST_SHOW_POLICY},
1769                   {"show-notation",LIST_SHOW_NOTATION},
1770                   {"show-keyserver-url",LIST_SHOW_KEYSERVER},
1771                   {"show-validity",LIST_SHOW_VALIDITY},
1772                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1773                   {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS},
1774                   {"show-keyring",LIST_SHOW_KEYRING},
1775                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE},
1776                   {NULL,0}
1777                 };
1778
1779               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1780                 {
1781                   if(configname)
1782                     log_error(_("%s:%d: invalid list options\n"),
1783                               configname,configlineno);
1784                   else
1785                     log_error(_("invalid list options\n"));
1786                 }
1787             }
1788             break;
1789           case oVerifyOptions:
1790             {
1791               struct parse_options vopts[]=
1792                 {
1793                   {"show-photos",VERIFY_SHOW_PHOTOS},
1794                   {"show-policy-url",VERIFY_SHOW_POLICY},
1795                   {"show-notation",VERIFY_SHOW_NOTATION},
1796                   {"show-keyserver-url",VERIFY_SHOW_KEYSERVER},
1797                   {"show-validity",VERIFY_SHOW_VALIDITY},
1798                   {"show-long-keyid",VERIFY_SHOW_LONG_KEYID},
1799                   {NULL,0}
1800                 };
1801
1802               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1803                 {
1804                   if(configname)
1805                     log_error(_("%s:%d: invalid verify options\n"),
1806                               configname,configlineno);
1807                   else
1808                     log_error(_("invalid verify options\n"));
1809                 }
1810             }
1811             break;
1812           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1813           case oExecPath:
1814             if(set_exec_path(pargs.r.ret_str,0))
1815               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1816             else
1817               opt.exec_path_set=1;
1818             break;
1819           case oSetNotation:
1820             add_notation_data( pargs.r.ret_str, 0 );
1821             add_notation_data( pargs.r.ret_str, 1 );
1822             break;
1823           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1824           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1825           case oShowNotation:
1826             opt.list_options|=LIST_SHOW_NOTATION;
1827             opt.verify_options|=VERIFY_SHOW_NOTATION;
1828             break;
1829           case oNoShowNotation:
1830             opt.list_options&=~LIST_SHOW_NOTATION;
1831             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1832             break;
1833           case oUtf8Strings: utf8_strings = 1; break;
1834           case oNoUtf8Strings: utf8_strings = 0; break;
1835           case oDisableCipherAlgo:
1836                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1837                 break;
1838           case oDisablePubkeyAlgo:
1839                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1840                 break;
1841           case oNoSigCache: opt.no_sig_cache = 1; break;
1842           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1843           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1844           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1845           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1846           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1847           case oNoLiteral: opt.no_literal = 1; break;
1848           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1849           case oHonorHttpProxy:
1850                 opt.keyserver_options.honor_http_proxy = 1;
1851                 deprecated_warning(configname,configlineno,
1852                                    "--honor-http-proxy",
1853                                    "--keyserver-options ",
1854                                    "honor-http-proxy");
1855                 break;
1856           case oFastListMode: opt.fast_list_mode = 1; break;
1857           case oFixedListMode: opt.fixed_list_mode = 1; break;
1858           case oListOnly: opt.list_only=1; break;
1859           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1860           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1861           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1862           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1863           case oNoRandomSeedFile: use_random_seed = 0; break;
1864           case oAutoKeyRetrieve:
1865           case oNoAutoKeyRetrieve:
1866                 opt.keyserver_options.auto_key_retrieve=
1867                                              (pargs.r_opt==oAutoKeyRetrieve);
1868                 deprecated_warning(configname,configlineno,
1869                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1870                                "--no-auto-key-retrieve","--keyserver-options ",
1871                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1872                                "no-auto-key-retrieve");
1873                 break;
1874           case oShowSessionKey: opt.show_session_key = 1; break;
1875           case oOverrideSessionKey:
1876                 opt.override_session_key = pargs.r.ret_str;
1877                 break;
1878           case oMergeOnly: opt.merge_only = 1; break;
1879           case oAllowSecretKeyImport: /* obsolete */ break;
1880           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1881           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1882           case oEnableSpecialFilenames:
1883             iobuf_enable_special_filenames (1);
1884             break;
1885           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1886           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1887           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1888           case oPreservePermissions: opt.preserve_permissions=1; break;
1889           case oDefaultPreferenceList:
1890             opt.def_preference_list = pargs.r.ret_str;
1891             break;
1892           case oPersonalCipherPreferences:
1893             pers_cipher_list=pargs.r.ret_str;
1894             break;
1895           case oPersonalDigestPreferences:
1896             pers_digest_list=pargs.r.ret_str;
1897             break;
1898           case oPersonalCompressPreferences:
1899             pers_compress_list=pargs.r.ret_str;
1900             break;
1901           case oDisplay: opt.display = pargs.r.ret_str; break;
1902           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1903           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1904           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1905           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1906           case oGroup: add_group(pargs.r.ret_str); break;
1907           case oStrict: opt.strict=1; log_set_strict(1); break;
1908           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1909           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1910           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1911           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1912           case oMultifile: multifile=1; break;
1913
1914           default : pargs.err = configfp? 1:2; break;
1915         }
1916     }
1917
1918     if( configfp ) {
1919         fclose( configfp );
1920         configfp = NULL;
1921         m_free(configname); configname = NULL;
1922         goto next_pass;
1923     }
1924     m_free( configname ); configname = NULL;
1925     if( log_get_errorcount(0) )
1926         g10_exit(2);
1927     if( nogreeting )
1928         greeting = 0;
1929
1930     if( greeting ) {
1931         fprintf(stderr, "%s %s; %s\n",
1932                         strusage(11), strusage(13), strusage(14) );
1933         fprintf(stderr, "%s\n", strusage(15) );
1934     }
1935 #ifdef IS_DEVELOPMENT_VERSION
1936     if( !opt.batch ) {
1937         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1938         log_info("It is only intended for test purposes and should NOT be\n");
1939         log_info("used in a production environment or with production keys!\n");
1940     }
1941 #endif
1942
1943     if (opt.verbose > 2)
1944         log_info ("using character set `%s'\n", get_native_charset ());
1945
1946     if( may_coredump && !opt.quiet )
1947         log_info(_("WARNING: program may create a core file!\n"));
1948
1949     if (eyes_only) {
1950       if (opt.set_filename)
1951           log_info(_("WARNING: %s overrides %s\n"),
1952                    "--for-your-eyes-only","--set-filename");
1953
1954       opt.set_filename="_CONSOLE";
1955     }
1956
1957     if (opt.no_literal) {
1958         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1959         if (opt.textmode)
1960             log_error(_("%s not allowed with %s!\n"),
1961                        "--textmode", "--no-literal" );
1962         if (opt.set_filename)
1963             log_error(_("%s makes no sense with %s!\n"),
1964                         eyes_only?"--for-your-eyes-only":"--set-filename",
1965                         "--no-literal" );
1966     }
1967
1968     if (opt.set_filesize)
1969         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1970     if( opt.batch )
1971         tty_batchmode( 1 );
1972
1973     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1974
1975     set_debug();
1976
1977     /* Do these after the switch(), so they can override settings. */
1978     if(PGP2)
1979       {
1980         int unusable=0;
1981
1982         if(cmd==aSign && !detached_sig)
1983           {
1984             log_info(_("you can only make detached or clear signatures "
1985                        "while in --pgp2 mode\n"));
1986             unusable=1;
1987           }
1988         else if(cmd==aSignEncr || cmd==aSignSym)
1989           {
1990             log_info(_("you can't sign and encrypt at the "
1991                        "same time while in --pgp2 mode\n"));
1992             unusable=1;
1993           }
1994         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1995           {
1996             log_info(_("you must use files (and not a pipe) when "
1997                        "working with --pgp2 enabled.\n"));
1998             unusable=1;
1999           }
2000         else if(cmd==aEncr || cmd==aSym)
2001           {
2002             /* Everything else should work without IDEA (except using
2003                a secret key encrypted with IDEA and setting an IDEA
2004                preference, but those have their own error
2005                messages). */
2006
2007             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2008               {
2009                 log_info(_("encrypting a message in --pgp2 mode requires "
2010                            "the IDEA cipher\n"));
2011                 idea_cipher_warn(1);
2012                 unusable=1;
2013               }
2014             else if(cmd==aSym)
2015               {
2016                 /* This only sets IDEA for symmetric encryption
2017                    since it is set via select_algo_from_prefs for
2018                    pk encryption. */
2019                 m_free(def_cipher_string);
2020                 def_cipher_string = m_strdup("idea");
2021               }
2022
2023             /* PGP2 can't handle the output from the textmode
2024                filter, so we disable it for anything that could
2025                create a literal packet (only encryption and
2026                symmetric encryption, since we disable signing
2027                above). */
2028             if(!unusable)
2029               opt.textmode=0;
2030           }
2031
2032         if(unusable)
2033           compliance_failure();
2034         else
2035           {
2036             opt.force_v4_certs = 0;
2037             opt.sk_comments = 0;
2038             opt.escape_from = 1;
2039             opt.force_v3_sigs = 1;
2040             opt.pgp2_workarounds = 1;
2041             opt.ask_sig_expire = 0;
2042             opt.ask_cert_expire = 0;
2043             m_free(def_digest_string);
2044             def_digest_string = m_strdup("md5");
2045             opt.def_compress_algo = 1;
2046           }
2047       }
2048     else if(PGP6)
2049       {
2050         opt.sk_comments=0;
2051         opt.escape_from=1;
2052         opt.force_v3_sigs=1;
2053         opt.ask_sig_expire=0;
2054       }
2055     else if(PGP7)
2056       {
2057         opt.sk_comments=0;
2058         opt.escape_from=1;
2059         opt.force_v3_sigs=1;
2060         opt.ask_sig_expire=0;
2061       }
2062     else if(PGP8)
2063       {
2064         opt.escape_from=1;
2065       }
2066
2067     /* must do this after dropping setuid, because string_to...
2068      * may try to load an module */
2069     if( def_cipher_string ) {
2070         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2071         if(opt.def_cipher_algo==0 &&
2072            (ascii_strcasecmp(def_cipher_string,"idea")==0
2073             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2074           idea_cipher_warn(1);
2075         m_free(def_cipher_string); def_cipher_string = NULL;
2076         if( check_cipher_algo(opt.def_cipher_algo) )
2077             log_error(_("selected cipher algorithm is invalid\n"));
2078     }
2079     if( def_digest_string ) {
2080         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2081         m_free(def_digest_string); def_digest_string = NULL;
2082         if( check_digest_algo(opt.def_digest_algo) )
2083             log_error(_("selected digest algorithm is invalid\n"));
2084     }
2085     if( def_compress_string ) {
2086         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2087         m_free(def_compress_string); def_compress_string = NULL;
2088         if( check_compress_algo(opt.def_compress_algo) )
2089             log_error(_("selected compression algorithm is invalid\n"));
2090     }
2091     if( cert_digest_string ) {
2092         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2093         m_free(cert_digest_string); cert_digest_string = NULL;
2094         if( check_digest_algo(opt.cert_digest_algo) )
2095             log_error(_("selected certification digest algorithm is invalid\n"));
2096     }
2097     if( s2k_cipher_string ) {
2098         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2099         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2100         if( check_cipher_algo(opt.s2k_cipher_algo) )
2101             log_error(_("selected cipher algorithm is invalid\n"));
2102     }
2103     if( s2k_digest_string ) {
2104         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2105         m_free(s2k_digest_string); s2k_digest_string = NULL;
2106         if( check_digest_algo(opt.s2k_digest_algo) )
2107             log_error(_("selected digest algorithm is invalid\n"));
2108     }
2109     if( opt.completes_needed < 1 )
2110         log_error(_("completes-needed must be greater than 0\n"));
2111     if( opt.marginals_needed < 2 )
2112         log_error(_("marginals-needed must be greater than 1\n"));
2113     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2114         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2115     switch( opt.s2k_mode ) {
2116       case 0:
2117         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2118         break;
2119       case 1: case 3: break;
2120       default:
2121         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2122     }
2123
2124     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2125       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2126
2127     /* This isn't actually needed, but does serve to error out if the
2128        string is invalid. */
2129     if(opt.def_preference_list &&
2130         keygen_set_std_prefs(opt.def_preference_list,0))
2131       log_error(_("invalid default preferences\n"));
2132
2133     /* We provide defaults for the personal digest list */
2134     if(!pers_digest_list)
2135       pers_digest_list="h2";
2136
2137     if(pers_cipher_list &&
2138        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2139       log_error(_("invalid personal cipher preferences\n"));
2140
2141     if(pers_digest_list &&
2142        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2143       log_error(_("invalid personal digest preferences\n"));
2144
2145     if(pers_compress_list &&
2146        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2147       log_error(_("invalid personal compress preferences\n"));
2148
2149     /* We don't support all possible commands with multifile yet */
2150     if(multifile)
2151       {
2152         char *cmdname;
2153
2154         switch(cmd)
2155           {
2156           case aSign:
2157             cmdname="--sign";
2158             break;
2159           case aClearsign:
2160             cmdname="--clearsign";
2161             break;
2162           case aDetachedSign:
2163             cmdname="--detach-sign";
2164             break;
2165           case aSym:
2166             cmdname="--symmetric";
2167             break;
2168           case aStore:
2169             cmdname="--store";
2170             break;
2171           default:
2172             cmdname=NULL;
2173             break;
2174           }
2175
2176         if(cmdname)
2177           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2178       }
2179
2180     if( log_get_errorcount(0) )
2181         g10_exit(2);
2182
2183     /* Check our chosen algorithms against the list of legal
2184        algorithms. */
2185
2186     if(!GNUPG)
2187       {
2188         const char *badalg=NULL;
2189         preftype_t badtype=PREFTYPE_NONE;
2190
2191         if(opt.def_cipher_algo
2192            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2193           {
2194             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2195             badtype=PREFTYPE_SYM;
2196           }
2197         else if(opt.def_digest_algo
2198                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2199           {
2200             badalg=digest_algo_to_string(opt.def_digest_algo);
2201             badtype=PREFTYPE_HASH;
2202           }
2203         else if(opt.cert_digest_algo
2204                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2205           {
2206             badalg=digest_algo_to_string(opt.cert_digest_algo);
2207             badtype=PREFTYPE_HASH;
2208           }
2209         else if(opt.def_compress_algo!=-1
2210                 && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2211           {
2212             badalg=compress_algo_to_string(opt.def_compress_algo);
2213             badtype=PREFTYPE_ZIP;
2214           }
2215
2216         if(badalg)
2217           {
2218             switch(badtype)
2219               {
2220               case PREFTYPE_SYM:
2221                 log_info(_("you may not use cipher algorithm \"%s\" "
2222                            "while in %s mode\n"),
2223                          badalg,compliance_option_string());
2224                 break;
2225               case PREFTYPE_HASH:
2226                 log_info(_("you may not use digest algorithm \"%s\" "
2227                            "while in %s mode\n"),
2228                          badalg,compliance_option_string());
2229                 break;
2230               case PREFTYPE_ZIP:
2231                 log_info(_("you may not use compression algorithm \"%s\" "
2232                            "while in %s mode\n"),
2233                          badalg,compliance_option_string());
2234                 break;
2235               default:
2236                 BUG();
2237               }
2238
2239             compliance_failure();
2240           }
2241       }
2242
2243     /* set the random seed file */
2244     if( use_random_seed ) {
2245         char *p = make_filename(opt.homedir, "random_seed", NULL );
2246         set_random_seed_file(p);
2247         m_free(p);
2248     }
2249
2250     if( !cmd && opt.fingerprint && !with_fpr ) {
2251         set_cmd( &cmd, aListKeys);
2252     }
2253
2254     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2255         if( cmd == aKModeC ) {
2256             opt.fingerprint = 1;
2257             cmd = aKMode;
2258         }
2259         opt.list_sigs = 0;
2260         if( opt.verbose > 2 )
2261             opt.check_sigs++;
2262         if( opt.verbose > 1 )
2263             opt.list_sigs++;
2264
2265         opt.verbose = opt.verbose > 1;
2266         g10_opt_verbose = opt.verbose;
2267     }
2268
2269     /* Compression algorithm 0 means no compression at all */
2270     if( opt.def_compress_algo == 0)
2271         opt.compress = 0;
2272
2273     /* kludge to let -sat generate a clear text signature */
2274     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2275         cmd = aClearsign;
2276
2277     if( opt.verbose > 1 )
2278         set_packet_list_mode(1);
2279
2280     /* Add the keyrings, but not for some special commands and not in
2281        case of "-kvv userid keyring".  Also avoid adding the secret
2282        keyring for a couple of commands to avoid unneeded access in
2283        case the secrings are stored on a floppy */
2284     if( cmd != aDeArmor && cmd != aEnArmor
2285         && !(cmd == aKMode && argc == 2 ) ) 
2286       {
2287         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2288             && cmd != aVerify && cmd != aSym)
2289           {
2290             if (!sec_nrings || default_keyring) /* add default secret rings */
2291               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2292             for (sl = sec_nrings; sl; sl = sl->next)
2293               keydb_add_resource ( sl->d, 0, 1 );
2294           }
2295         if( !nrings || default_keyring )  /* add default ring */
2296             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2297         for(sl = nrings; sl; sl = sl->next )
2298             keydb_add_resource ( sl->d, sl->flags, 0 );
2299       }
2300     FREE_STRLIST(nrings);
2301     FREE_STRLIST(sec_nrings);
2302
2303
2304     if( pwfd != -1 )  /* read the passphrase now. */
2305         read_passphrase_from_fd( pwfd );
2306
2307     fname = argc? *argv : NULL;
2308
2309     switch( cmd ) {
2310       case aPrimegen:
2311       case aPrintMD:
2312       case aPrintMDs:
2313       case aGenRandom:
2314       case aDeArmor:
2315       case aEnArmor:
2316       case aFixTrustDB:
2317         break;
2318       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2319       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2320       default: rc = setup_trustdb(1, trustdb_name ); break;
2321     }
2322     if( rc )
2323         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2324
2325
2326     switch (cmd) {
2327       case aStore: 
2328       case aSym:  
2329       case aSign: 
2330       case aSignSym: 
2331       case aClearsign: 
2332         if (!opt.quiet && any_explicit_recipient)
2333           log_info (_("WARNING: recipients (-r) given "
2334                       "without using public key encryption\n"));
2335         break;
2336       default:
2337         break;
2338     }
2339
2340     switch( cmd ) {
2341       case aStore: /* only store the file */
2342         if( argc > 1 )
2343             wrong_args(_("--store [filename]"));
2344         if( (rc = encode_store(fname)) )
2345             log_error_f( print_fname_stdin(fname),
2346                         "store failed: %s\n", g10_errstr(rc) );
2347         break;
2348       case aSym: /* encrypt the given file only with the symmetric cipher */
2349         if( argc > 1 )
2350             wrong_args(_("--symmetric [filename]"));
2351         if( (rc = encode_symmetric(fname)) )
2352             log_error_f(print_fname_stdin(fname),
2353                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2354         break;
2355
2356       case aEncr: /* encrypt the given file */
2357         if(multifile)
2358           encode_crypt_files(argc, argv, remusr);
2359         else
2360           {
2361             if( argc > 1 )
2362               wrong_args(_("--encrypt [filename]"));
2363             if( (rc = encode_crypt(fname,remusr)) )
2364               log_error("%s: encryption failed: %s\n",
2365                         print_fname_stdin(fname), g10_errstr(rc) );
2366           }
2367         break;
2368           
2369       case aSign: /* sign the given file */
2370         sl = NULL;
2371         if( detached_sig ) { /* sign all files */
2372             for( ; argc; argc--, argv++ )
2373                 add_to_strlist( &sl, *argv );
2374         }
2375         else {
2376             if( argc > 1 )
2377                 wrong_args(_("--sign [filename]"));
2378             if( argc ) {
2379                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2380                 strcpy(sl->d, fname);
2381             }
2382         }
2383         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2384             log_error("signing failed: %s\n", g10_errstr(rc) );
2385         free_strlist(sl);
2386         break;
2387
2388       case aSignEncr: /* sign and encrypt the given file */
2389         if( argc > 1 )
2390             wrong_args(_("--sign --encrypt [filename]"));
2391         if( argc ) {
2392             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2393             strcpy(sl->d, fname);
2394         }
2395         else
2396             sl = NULL;
2397         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2398             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2399         free_strlist(sl);
2400         break;
2401
2402       case aSignSym: /* sign and conventionally encrypt the given file */
2403         if (argc > 1)
2404             wrong_args(_("--sign --symmetric [filename]"));
2405         rc = sign_symencrypt_file (fname, locusr);
2406         if (rc)
2407             log_error("%s: sign+symmetric failed: %s\n",
2408                       print_fname_stdin(fname), g10_errstr(rc) );
2409         break;
2410
2411       case aClearsign: /* make a clearsig */
2412         if( argc > 1 )
2413             wrong_args(_("--clearsign [filename]"));
2414         if( (rc = clearsign_file(fname, locusr, NULL)) )
2415             log_error("%s: clearsign failed: %s\n",
2416                       print_fname_stdin(fname), g10_errstr(rc) );
2417         break;
2418
2419       case aVerify:
2420         if(multifile)
2421           {
2422             if( (rc = verify_files( argc, argv ) ))
2423               log_error("verify files failed: %s\n", g10_errstr(rc) );
2424           }
2425         else
2426           {
2427             if( (rc = verify_signatures( argc, argv ) ))
2428               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2429           }
2430         break;
2431
2432       case aDecrypt:
2433         if(multifile)
2434           decrypt_messages(argc, argv);
2435         else
2436           {
2437             if( argc > 1 )
2438               wrong_args(_("--decrypt [filename]"));
2439             if( (rc = decrypt_message( fname ) ))
2440               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2441           }
2442         break;
2443             
2444       case aSignKey: /* sign the key given as argument */
2445         if( argc != 1 )
2446             wrong_args(_("--sign-key user-id"));
2447         username = make_username( fname );
2448         keyedit_menu(fname, locusr, NULL, 1 );
2449         m_free(username);
2450         break;
2451
2452       case aLSignKey:
2453         if( argc != 1 )
2454             wrong_args(_("--lsign-key user-id"));
2455         username = make_username( fname );
2456         keyedit_menu(fname, locusr, NULL, 2 );
2457         m_free(username);
2458         break;
2459
2460       case aNRSignKey:
2461         if( argc != 1 )
2462             wrong_args(_("--nrsign-key user-id"));
2463         username = make_username( fname );
2464         keyedit_menu(fname, locusr, NULL, 3 );
2465         m_free(username);
2466         break;
2467
2468       case aNRLSignKey:
2469         if( argc != 1 )
2470             wrong_args(_("--nrlsign-key user-id"));
2471         username = make_username( fname );
2472         keyedit_menu(fname, locusr, NULL, 4 );
2473         m_free(username);
2474         break;
2475
2476       case aEditKey: /* Edit a key signature */
2477         if( !argc )
2478             wrong_args(_("--edit-key user-id [commands]"));
2479         username = make_username( fname );
2480         if( argc > 1 ) {
2481             sl = NULL;
2482             for( argc--, argv++ ; argc; argc--, argv++ )
2483                 append_to_strlist( &sl, *argv );
2484             keyedit_menu( username, locusr, sl, 0 );
2485             free_strlist(sl);
2486         }
2487         else
2488             keyedit_menu(username, locusr, NULL, 0 );
2489         m_free(username);
2490         break;
2491
2492       case aDeleteKeys:
2493       case aDeleteSecretKeys:
2494       case aDeleteSecretAndPublicKeys:
2495         sl = NULL;
2496         /* I'm adding these in reverse order as add_to_strlist2
2497            reverses them again, and it's easier to understand in the
2498            proper order :) */
2499         for( ; argc; argc-- )
2500           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2501         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2502         free_strlist(sl);
2503         break;
2504
2505       case aCheckKeys:
2506         opt.check_sigs = 1;
2507       case aListSigs:
2508         opt.list_sigs = 1;
2509       case aListKeys:
2510         sl = NULL;
2511         for( ; argc; argc--, argv++ )
2512             add_to_strlist2( &sl, *argv, utf8_strings );
2513         public_key_list( sl );
2514         free_strlist(sl);
2515         break;
2516       case aListSecretKeys:
2517         sl = NULL;
2518         for( ; argc; argc--, argv++ )
2519             add_to_strlist2( &sl, *argv, utf8_strings );
2520         secret_key_list( sl );
2521         free_strlist(sl);
2522         break;
2523
2524       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2525         if( argc < 2 ) { /* -kv [userid] */
2526             sl = NULL;
2527             if (argc && **argv)
2528                 add_to_strlist2( &sl, *argv, utf8_strings );
2529             public_key_list( sl );
2530             free_strlist(sl);
2531         }
2532         else if( argc == 2 ) { /* -kv userid keyring */
2533             if( access( argv[1], R_OK ) ) {
2534                 log_error(_("can't open %s: %s\n"),
2535                                print_fname_stdin(argv[1]), strerror(errno));
2536             }
2537             else {
2538                 /* add keyring (default keyrings are not registered in this
2539                  * special case */
2540                 keydb_add_resource( argv[1], 0, 0 );
2541                 sl = NULL;
2542                 if (**argv)
2543                     add_to_strlist2( &sl, *argv, utf8_strings );
2544                 public_key_list( sl );
2545                 free_strlist(sl);
2546             }
2547         }
2548         else
2549             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2550         break;
2551
2552       case aKeygen: /* generate a key */
2553         if( opt.batch ) {
2554             if( argc > 1 )
2555                 wrong_args("--gen-key [parameterfile]");
2556             generate_keypair( argc? *argv : NULL );
2557         }
2558         else {
2559             if( argc )
2560                 wrong_args("--gen-key");
2561             generate_keypair(NULL);
2562         }
2563         break;
2564
2565       case aFastImport:
2566         opt.import_options |= IMPORT_FAST_IMPORT;
2567       case aImport:
2568         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2569         break;
2570
2571       case aExport:
2572       case aExportAll:
2573       case aSendKeys:
2574       case aRecvKeys:
2575         sl = NULL;
2576         for( ; argc; argc--, argv++ )
2577             add_to_strlist2( &sl, *argv, utf8_strings );
2578         if( cmd == aSendKeys )
2579             rc=keyserver_export( sl );
2580         else if( cmd == aRecvKeys )
2581             rc=keyserver_import( sl );
2582         else
2583             rc=export_pubkeys( sl, opt.export_options );
2584         if(rc)
2585           {
2586             if(cmd==aSendKeys)
2587               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
2588             else if(cmd==aRecvKeys)
2589               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
2590             else
2591               log_error(_("key export failed: %s\n"),g10_errstr(rc));
2592           }
2593         free_strlist(sl);
2594         break;
2595
2596      case aSearchKeys:
2597         sl = NULL;
2598         for( ; argc; argc--, argv++ )
2599           append_to_strlist2( &sl, *argv, utf8_strings );
2600
2601         rc=keyserver_search( sl );
2602         if(rc)
2603           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
2604         free_strlist(sl);
2605         break;
2606
2607       case aRefreshKeys:
2608         sl = NULL;
2609         for( ; argc; argc--, argv++ )
2610             add_to_strlist2( &sl, *argv, utf8_strings );
2611         rc=keyserver_refresh(sl);
2612         if(rc)
2613           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
2614         free_strlist(sl);
2615         break;
2616
2617       case aExportSecret:
2618         sl = NULL;
2619         for( ; argc; argc--, argv++ )
2620             add_to_strlist2( &sl, *argv, utf8_strings );
2621         export_seckeys( sl );
2622         free_strlist(sl);
2623         break;
2624
2625       case aExportSecretSub:
2626         sl = NULL;
2627         for( ; argc; argc--, argv++ )
2628             add_to_strlist2( &sl, *argv, utf8_strings );
2629         export_secsubkeys( sl );
2630         free_strlist(sl);
2631         break;
2632
2633       case aGenRevoke:
2634         if( argc != 1 )
2635             wrong_args("--gen-revoke user-id");
2636         username =  make_username(*argv);
2637         gen_revoke( username );
2638         m_free( username );
2639         break;
2640
2641       case aDesigRevoke:
2642         if( argc != 1 )
2643             wrong_args("--desig-revoke user-id");
2644         username =  make_username(*argv);
2645         gen_desig_revoke( username );
2646         m_free( username );
2647         break;
2648
2649       case aDeArmor:
2650         if( argc > 1 )
2651             wrong_args("--dearmor [file]");
2652         rc = dearmor_file( argc? *argv: NULL );
2653         if( rc )
2654             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2655         break;
2656
2657       case aEnArmor:
2658         if( argc > 1 )
2659             wrong_args("--enarmor [file]");
2660         rc = enarmor_file( argc? *argv: NULL );
2661         if( rc )
2662             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2663         break;
2664
2665
2666       case aPrimegen:
2667         {   int mode = argc < 2 ? 0 : atoi(*argv);
2668
2669             if( mode == 1 && argc == 2 ) {
2670                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2671             }
2672             else if( mode == 2 && argc == 3 ) {
2673                 mpi_print( stdout, generate_elg_prime(
2674                                              0, atoi(argv[1]),
2675                                              atoi(argv[2]), NULL,NULL ), 1);
2676             }
2677             else if( mode == 3 && argc == 3 ) {
2678                 MPI *factors;
2679                 mpi_print( stdout, generate_elg_prime(
2680                                              1, atoi(argv[1]),
2681                                              atoi(argv[2]), NULL,&factors ), 1);
2682                 putchar('\n');
2683                 mpi_print( stdout, factors[0], 1 ); /* print q */
2684             }
2685             else if( mode == 4 && argc == 3 ) {
2686                 MPI g = mpi_alloc(1);
2687                 mpi_print( stdout, generate_elg_prime(
2688                                                  0, atoi(argv[1]),
2689                                                  atoi(argv[2]), g, NULL ), 1);
2690                 putchar('\n');
2691                 mpi_print( stdout, g, 1 );
2692                 mpi_free(g);
2693             }
2694             else
2695                 wrong_args("--gen-prime mode bits [qbits] ");
2696             putchar('\n');
2697         }
2698         break;
2699
2700       case aGenRandom:
2701         {
2702             int level = argc ? atoi(*argv):0;
2703             int count = argc > 1 ? atoi(argv[1]): 0;
2704             int endless = !count;
2705
2706             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2707                 wrong_args("--gen-random 0|1|2 [count]");
2708
2709             while( endless || count ) {
2710                 byte *p;
2711                 /* Wee need a multiple of 3, so that in case of
2712                    armored output we get a correct string.  No
2713                    linefolding is done, as it is best to levae this to
2714                    other tools */
2715                 size_t n = !endless && count < 99? count : 99;
2716
2717                 p = get_random_bits( n*8, level, 0);
2718 #ifdef HAVE_DOSISH_SYSTEM
2719                 setmode ( fileno(stdout), O_BINARY );
2720 #endif
2721                 if (opt.armor) {
2722                     char *tmp = make_radix64_string (p, n);
2723                     fputs (tmp, stdout);
2724                     m_free (tmp);
2725                     if (n%3 == 1)
2726                       putchar ('=');
2727                     if (n%3)
2728                       putchar ('=');
2729                 } else {
2730                     fwrite( p, n, 1, stdout );
2731                 }
2732                 m_free(p);
2733                 if( !endless )
2734                     count -= n;
2735             }
2736             if (opt.armor)
2737                 putchar ('\n');
2738         }
2739         break;
2740
2741       case aPrintMD:
2742         if( argc < 1)
2743             wrong_args("--print-md algo [files]");
2744         {
2745             int all_algos = (**argv=='*' && !(*argv)[1]);
2746             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2747
2748             if( !algo && !all_algos )
2749                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2750             else {
2751                 argc--; argv++;
2752                 if( !argc )
2753                     print_mds(NULL, algo);
2754                 else {
2755                     for(; argc; argc--, argv++ )
2756                         print_mds(*argv, algo);
2757                 }
2758             }
2759         }
2760         break;
2761
2762       case aPrintMDs: /* old option */
2763         if( !argc )
2764             print_mds(NULL,0);
2765         else {
2766             for(; argc; argc--, argv++ )
2767                 print_mds(*argv,0);
2768         }
2769         break;
2770
2771       case aListTrustDB:
2772         if( !argc )
2773             list_trustdb(NULL);
2774         else {
2775             for( ; argc; argc--, argv++ )
2776                 list_trustdb( *argv );
2777         }
2778         break;
2779
2780       case aUpdateTrustDB:
2781         if( argc )
2782             wrong_args("--update-trustdb");
2783         update_trustdb();
2784         break;
2785
2786       case aCheckTrustDB:
2787         /* Old versions allowed for arguments - ignore them */
2788         check_trustdb();
2789         break;
2790
2791       case aFixTrustDB:
2792         log_error("this command is not yet implemented.\n");
2793         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2794         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2795         break;
2796
2797       case aListTrustPath:
2798         if( !argc )
2799             wrong_args("--list-trust-path <user-ids>");
2800         for( ; argc; argc--, argv++ ) {
2801             username = make_username( *argv );
2802             list_trust_path( username );
2803             m_free(username);
2804         }
2805         break;
2806
2807       case aExportOwnerTrust:
2808         if( argc )
2809             wrong_args("--export-ownertrust");
2810         export_ownertrust();
2811         break;
2812
2813       case aImportOwnerTrust:
2814         if( argc > 1 )
2815             wrong_args("--import-ownertrust [file]");
2816         import_ownertrust( argc? *argv:NULL );
2817         break;
2818       
2819       case aPipeMode:
2820         if ( argc )
2821             wrong_args ("--pipemode");
2822         run_in_pipemode ();
2823         break;
2824
2825       case aRebuildKeydbCaches:
2826         if (argc)
2827             wrong_args ("--rebuild-keydb-caches");
2828         keydb_rebuild_caches ();
2829         break;
2830
2831       case aListPackets:
2832         opt.list_packets=2;
2833       default:
2834         if( argc > 1 )
2835             wrong_args(_("[filename]"));
2836         /* Issue some output for the unix newbie */
2837         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2838                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2839             log_info(_("Go ahead and type your message ...\n"));
2840
2841         if( !(a = iobuf_open(fname)) )
2842             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2843         else {
2844
2845             if( !opt.no_armor ) {
2846                 if( use_armor_filter( a ) ) {
2847                     memset( &afx, 0, sizeof afx);
2848                     iobuf_push_filter( a, armor_filter, &afx );
2849                 }
2850             }
2851             if( cmd == aListPackets ) {
2852                 set_packet_list_mode(1);
2853                 opt.list_packets=1;
2854             }
2855             rc = proc_packets(NULL, a );
2856             if( rc )
2857                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2858             iobuf_close(a);
2859         }
2860         break;
2861     }
2862
2863     /* cleanup */
2864     FREE_STRLIST(remusr);
2865     FREE_STRLIST(locusr);
2866     g10_exit(0);
2867     return 8; /*NEVER REACHED*/
2868 }
2869
2870
2871 void
2872 g10_exit( int rc )
2873 {
2874     update_random_seed_file();
2875     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2876         m_print_stats("on exit");
2877         random_dump_stats();
2878     }
2879     if( opt.debug )
2880         secmem_dump_stats();
2881     secmem_term();
2882     rc = rc? rc : log_get_errorcount(0)? 2 :
2883                         g10_errors_seen? 1 : 0;
2884     exit(rc );
2885 }
2886
2887
2888 /* Pretty-print hex hashes.  This assumes at least an 80-character
2889    display, but there are a few other similar assumptions in the
2890    display code. */
2891 static void
2892 print_hex( MD_HANDLE md, int algo, const char *fname )
2893 {
2894   int i,n,count,indent=0;
2895   const byte *p;
2896
2897   if(fname)
2898     indent=printf("%s: ",fname);
2899
2900   if(indent>40)
2901     {
2902       printf("\n");
2903       indent=0;
2904     }
2905
2906   if(algo==DIGEST_ALGO_RMD160)
2907     indent+=printf("RMD160 = ");
2908   else if(algo>0)
2909     indent+=printf("%6s = ",digest_algo_to_string(algo));
2910   else
2911     algo=abs(algo);
2912
2913   count=indent;
2914
2915   p = md_read( md, algo );
2916   n = md_digest_length(algo);
2917
2918   count+=printf("%02X",*p++);
2919
2920   for(i=1;i<n;i++,p++)
2921     {
2922       if(n==16)
2923         {
2924           if(count+2>79)
2925             {
2926               printf("\n%*s",indent," ");
2927               count=indent;
2928             }
2929           else
2930             count+=printf(" ");
2931
2932           if(!(i%8))
2933             count+=printf(" ");
2934         }
2935       else if (n==20)
2936         {
2937           if(!(i%2))
2938             {
2939               if(count+4>79)
2940                 {
2941                   printf("\n%*s",indent," ");
2942                   count=indent;
2943                 }
2944               else
2945                 count+=printf(" ");
2946             }
2947
2948           if(!(i%10))
2949             count+=printf(" ");
2950         }
2951       else
2952         {
2953           if(!(i%4))
2954             {
2955               if(count+8>79)
2956                 {
2957                   printf("\n%*s",indent," ");
2958                   count=indent;
2959                 }
2960               else
2961                 count+=printf(" ");
2962             }
2963         }
2964
2965       count+=printf("%02X",*p);
2966     }
2967
2968   printf("\n");
2969 }
2970
2971 static void
2972 print_hashline( MD_HANDLE md, int algo, const char *fname )
2973 {
2974     int i, n;
2975     const byte *p;
2976     
2977     if ( fname ) {
2978         for (p = fname; *p; p++ ) {
2979             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2980                 printf("%%%02X", *p );
2981             else 
2982                 putchar( *p );
2983         }
2984     }
2985     putchar(':');
2986     printf("%d:", algo );
2987     p = md_read( md, algo );
2988     n = md_digest_length(algo);
2989     for(i=0; i < n ; i++, p++ ) 
2990         printf("%02X", *p );
2991     putchar(':');
2992     putchar('\n');
2993 }
2994
2995 static void
2996 print_mds( const char *fname, int algo )
2997 {
2998     FILE *fp;
2999     char buf[1024];
3000     size_t n;
3001     MD_HANDLE md;
3002
3003     if( !fname ) {
3004         fp = stdin;
3005 #ifdef HAVE_DOSISH_SYSTEM
3006         setmode ( fileno(fp) , O_BINARY );
3007 #endif
3008     }
3009     else {
3010         fp = fopen( fname, "rb" );
3011     }
3012     if( !fp ) {
3013         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3014         return;
3015     }
3016
3017     md = md_open( 0, 0 );
3018     if( algo )
3019         md_enable( md, algo );
3020     else {
3021         md_enable( md, DIGEST_ALGO_MD5 );
3022         md_enable( md, DIGEST_ALGO_SHA1 );
3023         md_enable( md, DIGEST_ALGO_RMD160 );
3024 #ifdef USE_SHA256
3025         md_enable( md, DIGEST_ALGO_SHA256 );
3026 #endif
3027 #ifdef USE_SHA512
3028         md_enable( md, DIGEST_ALGO_SHA384 );
3029         md_enable( md, DIGEST_ALGO_SHA512 );
3030 #endif
3031     }
3032
3033     while( (n=fread( buf, 1, DIM(buf), fp )) )
3034         md_write( md, buf, n );
3035     if( ferror(fp) )
3036         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3037     else {
3038         md_final(md);
3039         if ( opt.with_colons ) {
3040             if ( algo ) 
3041                 print_hashline( md, algo, fname );
3042             else {
3043                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3044                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3045                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3046 #ifdef USE_SHA256
3047                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3048 #endif
3049 #ifdef USE_SHA512
3050                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3051                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3052 #endif
3053             }
3054         }
3055         else {
3056             if( algo )
3057                print_hex(md,-algo,fname);
3058             else {
3059                 print_hex( md, DIGEST_ALGO_MD5, fname );
3060                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3061                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3062 #ifdef USE_SHA256
3063                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3064 #endif
3065 #ifdef USE_SHA512
3066                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3067                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3068 #endif
3069             }
3070         }
3071     }
3072     md_close(md);
3073
3074     if( fp != stdin )
3075         fclose(fp);
3076 }
3077
3078
3079 /****************
3080  * Check the supplied name,value string and add it to the notation
3081  * data to be used for signatures.  which==0 for sig notations, and 1
3082  * for cert notations.
3083 */
3084 static void
3085 add_notation_data( const char *string, int which )
3086 {
3087     const char *s;
3088     STRLIST sl,*notation_data;
3089     int critical=0;
3090     int highbit=0;
3091     int saw_at=0;
3092
3093     if(which)
3094       notation_data=&opt.cert_notation_data;
3095     else
3096       notation_data=&opt.sig_notation_data;
3097
3098     if( *string == '!' ) {
3099         critical = 1;
3100         string++;
3101     }
3102
3103     /* If and when the IETF assigns some official name tags, we'll
3104        have to add them here. */
3105
3106     for( s=string ; *s != '='; s++ )
3107       {
3108         if( *s=='@')
3109           saw_at=1;
3110
3111         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3112           {
3113             log_error(_("a notation name must have only printable characters "
3114                         "or spaces, and end with an '='\n") );
3115             return;
3116           }
3117       }
3118
3119     if(!saw_at && !opt.expert)
3120       {
3121         log_error(
3122                 _("a user notation name must contain the '@' character\n"));
3123         return;
3124       }
3125
3126     /* we only support printable text - therefore we enforce the use
3127      * of only printable characters (an empty value is valid) */
3128     for( s++; *s ; s++ ) {
3129         if ((*s & 0x80))
3130           highbit = 1;
3131         else if (iscntrl(*s)) {
3132             log_error(_("a notation value must not use "
3133                         "any control characters\n") );
3134             return;
3135         }
3136     }
3137
3138     if( highbit )   /* must use UTF8 encoding */
3139         sl = add_to_strlist2( notation_data, string, utf8_strings );
3140     else
3141         sl = add_to_strlist( notation_data, string );
3142
3143     if( critical )
3144         sl->flags |= 1;
3145 }
3146
3147 static void
3148 add_policy_url( const char *string, int which )
3149 {
3150   int i,critical=0;
3151   STRLIST sl;
3152
3153   if(*string=='!')
3154     {
3155       string++;
3156       critical=1;
3157     }
3158
3159   for(i=0;i<strlen(string);i++)
3160     if(string[i]&0x80 || iscntrl(string[i]))
3161       break;
3162
3163   if(i==0 || i<strlen(string))
3164     {
3165       if(which)
3166         log_error(_("the given certification policy URL is invalid\n"));
3167       else
3168         log_error(_("the given signature policy URL is invalid\n"));
3169     }
3170
3171   if(which)
3172     sl=add_to_strlist( &opt.cert_policy_url, string );
3173   else
3174     sl=add_to_strlist( &opt.sig_policy_url, string );
3175
3176   if(critical)
3177     sl->flags |= 1;    
3178 }
3179
3180 static void
3181 add_keyserver_url( const char *string, int which )
3182 {
3183   int i,critical=0;
3184   STRLIST sl;
3185
3186   if(*string=='!')
3187     {
3188       string++;
3189       critical=1;
3190     }
3191
3192   for(i=0;i<strlen(string);i++)
3193     if(string[i]&0x80 || iscntrl(string[i]))
3194       break;
3195
3196   if(i==0 || i<strlen(string))
3197     {
3198       if(which)
3199         BUG();
3200       else
3201         log_error(_("the given signature preferred"
3202                     " keyserver URL is invalid\n"));
3203     }
3204
3205   if(which)
3206     BUG();
3207   else
3208     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3209
3210   if(critical)
3211     sl->flags |= 1;    
3212 }