* g10.c (main): Add --require-secmem/--no-require-secmem to cause gpg to
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2004 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <errno.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <ctype.h>
28 #include <unistd.h>
29 #include <assert.h>
30 #ifdef HAVE_DOSISH_SYSTEM
31 #include <fcntl.h> /* for setmode() */
32 #endif
33 #ifdef HAVE_STAT
34 #include <sys/stat.h> /* for stat() */
35 #endif
36 #include <fcntl.h>
37
38 #define INCLUDED_BY_MAIN_MODULE 1
39 #include "packet.h"
40 #include "iobuf.h"
41 #include "memory.h"
42 #include "util.h"
43 #include "main.h"
44 #include "options.h"
45 #include "keydb.h"
46 #include "trustdb.h"
47 #include "mpi.h"
48 #include "cipher.h"
49 #include "filter.h"
50 #include "ttyio.h"
51 #include "i18n.h"
52 #include "status.h"
53 #include "g10defs.h"
54 #include "keyserver-internal.h"
55 #include "exec.h"
56 #include "cardglue.h"
57 #ifdef ENABLE_CARD_SUPPORT
58 #include "ccid-driver.h"
59 #endif
60
61 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
62 #define MY_O_BINARY  O_BINARY
63 #ifndef S_IRGRP
64 # define S_IRGRP 0
65 # define S_IWGRP 0
66 #endif
67 #else
68 #define MY_O_BINARY  0
69 #endif
70
71
72 enum cmd_and_opt_values
73   {
74     aNull = 0,
75     oArmor        = 'a',
76     aDetachedSign = 'b',
77     aSym          = 'c',
78     aDecrypt      = 'd',
79     aEncr         = 'e',
80     oInteractive  = 'i',
81     oKOption      = 'k',
82     oDryRun       = 'n',
83     oOutput       = 'o',
84     oQuiet        = 'q',
85     oRecipient    = 'r',
86     oHiddenRecipient = 'R',
87     aSign         = 's',
88     oTextmodeShort= 't',
89     oUser         = 'u',
90     oVerbose      = 'v',
91     oCompress     = 'z',
92     oSetNotation  = 'N',
93     aListSecretKeys = 'K',
94     oBatch        = 500,
95     oMaxOutput,
96     oSigNotation,
97     oCertNotation,
98     oShowNotation,
99     oNoShowNotation,
100     aEncrFiles,
101     aEncrSym,
102     aDecryptFiles,
103     aClearsign,
104     aStore,
105     aKeygen,
106     aSignEncr,
107     aSignEncrSym,
108     aSignSym,
109     aSignKey,
110     aLSignKey,
111     aListConfig,
112     aGPGConfList,
113     aListPackets,
114     aEditKey,
115     aDeleteKeys,
116     aDeleteSecretKeys,
117     aDeleteSecretAndPublicKeys,
118     aKMode,
119     aKModeC,
120     aImport,
121     aFastImport,
122     aVerify,
123     aVerifyFiles,
124     aListKeys,
125     aListSigs,
126     aSendKeys,
127     aRecvKeys,
128     aSearchKeys,
129     aExport,
130     aExportSecret,
131     aExportSecretSub,
132     aCheckKeys,
133     aGenRevoke,
134     aDesigRevoke,
135     aPrimegen,
136     aPrintMD,
137     aPrintMDs,
138     aCheckTrustDB,
139     aUpdateTrustDB,
140     aFixTrustDB,
141     aListTrustDB,
142     aListTrustPath,
143     aExportOwnerTrust,
144     aListOwnerTrust,
145     aImportOwnerTrust,
146     aDeArmor,
147     aEnArmor,
148     aGenRandom,
149     aPipeMode,
150     aRebuildKeydbCaches,
151     aRefreshKeys,
152     aCardStatus,
153     aCardEdit,
154     aChangePIN,
155
156     oTextmode,
157     oNoTextmode,
158     oExpert,
159     oNoExpert,
160     oAskSigExpire,
161     oNoAskSigExpire,
162     oAskCertExpire,
163     oNoAskCertExpire,
164     oAskCertLevel,
165     oNoAskCertLevel,
166     oFingerprint,
167     oWithFingerprint,
168     oAnswerYes,
169     oAnswerNo,
170     oDefCertLevel,
171     oMinCertLevel,
172     oKeyring,
173     oPrimaryKeyring,
174     oSecretKeyring,
175     oShowKeyring,
176     oDefaultKey,
177     oDefRecipient,
178     oDefRecipientSelf,
179     oNoDefRecipient,
180     oOptions,
181     oDebug,
182     oDebugAll,
183     oDebugCCIDDriver,
184     oStatusFD,
185     oStatusFile,
186     oAttributeFD,
187     oAttributeFile,
188     oSKComments,
189     oNoSKComments,
190     oEmitVersion,
191     oNoEmitVersion,
192     oCompletesNeeded,
193     oMarginalsNeeded,
194     oMaxCertDepth,
195     oLoadExtension,
196     oGnuPG,
197     oRFC1991,
198     oRFC2440,
199     oOpenPGP,
200     oPGP2,
201     oPGP6,
202     oPGP7,
203     oPGP8,
204     oCipherAlgo,
205     oDigestAlgo,
206     oCertDigestAlgo,
207     oCompressAlgo,
208     oCompressLevel,
209     oBZ2CompressLevel,
210     oBZ2DecompressLowmem,
211     oPasswdFD,
212     oPasswdFile,
213     oCommandFD,
214     oCommandFile,
215     oQuickRandom,
216     oNoVerbose,
217     oTrustDBName,
218     oNoSecmemWarn,
219     oRequireSecmem,
220     oNoRequireSecmem,
221     oNoPermissionWarn,
222     oNoMDCWarn,
223     oNoArmor,
224     oNoDefKeyring,
225     oNoGreeting,
226     oNoTTY,
227     oNoOptions,
228     oNoBatch,
229     oHomedir,
230     oWithColons,
231     oWithKeyData,
232     oSkipVerify,
233     oCompressKeys,
234     oCompressSigs,
235     oAlwaysTrust,
236     oTrustModel,
237     oForceOwnertrust,
238     oRunAsShmCP,
239     oSetFilename,
240     oForYourEyesOnly,
241     oNoForYourEyesOnly,
242     oSetPolicyURL,
243     oSigPolicyURL,
244     oCertPolicyURL,
245     oShowPolicyURL,
246     oNoShowPolicyURL,
247     oSigKeyserverURL,
248     oUseEmbeddedFilename,
249     oNoUseEmbeddedFilename,
250     oComment,
251     oDefaultComment,
252     oNoComments,
253     oThrowKeyids,
254     oNoThrowKeyids,
255     oShowPhotos,
256     oNoShowPhotos,
257     oPhotoViewer,
258     oForceV3Sigs,
259     oNoForceV3Sigs,
260     oForceV4Certs,
261     oNoForceV4Certs,
262     oForceMDC,
263     oNoForceMDC,
264     oDisableMDC,
265     oNoDisableMDC,
266     oS2KMode,
267     oS2KDigest,
268     oS2KCipher,
269     oSimpleSKChecksum,                          
270     oDisplayCharset,
271     oNotDashEscaped,
272     oEscapeFrom,
273     oNoEscapeFrom,
274     oLockOnce,
275     oLockMultiple,
276     oLockNever,
277     oKeyServer,
278     oKeyServerOptions,
279     oImportOptions,
280     oExportOptions,
281     oListOptions,
282     oVerifyOptions,
283     oTempDir,
284     oExecPath,
285     oEncryptTo,
286     oHiddenEncryptTo,
287     oNoEncryptTo,
288     oLoggerFD,
289     oLoggerFile,
290     oUtf8Strings,
291     oNoUtf8Strings,
292     oDisableCipherAlgo,
293     oDisablePubkeyAlgo,
294     oAllowNonSelfsignedUID,
295     oNoAllowNonSelfsignedUID,
296     oAllowFreeformUID,
297     oNoAllowFreeformUID,
298     oAllowSecretKeyImport,                      
299     oEnableSpecialFilenames,
300     oNoLiteral,
301     oSetFilesize,
302     oHonorHttpProxy,
303     oFastListMode,
304     oListOnly,
305     oIgnoreTimeConflict,
306     oIgnoreValidFrom,
307     oIgnoreCrcError,
308     oIgnoreMDCError,
309     oShowSessionKey,
310     oOverrideSessionKey,
311     oNoRandomSeedFile,
312     oAutoKeyRetrieve,
313     oNoAutoKeyRetrieve,
314     oUseAgent,
315     oNoUseAgent,
316     oGpgAgentInfo,
317     oMergeOnly,
318     oTryAllSecrets,
319     oTrustedKey,
320     oNoExpensiveTrustChecks,
321     oFixedListMode,
322     oNoSigCache,
323     oNoSigCreateCheck,
324     oAutoCheckTrustDB,
325     oNoAutoCheckTrustDB,
326     oPreservePermissions,
327     oDefaultPreferenceList,
328     oPersonalCipherPreferences,
329     oPersonalDigestPreferences,
330     oPersonalCompressPreferences,
331     oDisplay,
332     oTTYname,
333     oTTYtype,
334     oLCctype,
335     oLCmessages,
336     oGroup,
337     oUnGroup,
338     oNoGroups,
339     oStrict,
340     oNoStrict,
341     oMangleDosFilenames,
342     oNoMangleDosFilenames,
343     oEnableProgressFilter,
344     oMultifile,
345     oKeyidFormat,
346
347     oReaderPort,
348     octapiDriver,
349     opcscDriver,
350     oDisableCCID,
351
352     aTest
353   };
354
355
356 static ARGPARSE_OPTS opts[] = {
357
358     { 300, NULL, 0, N_("@Commands:\n ") },
359
360     { aSign, "sign",      256, N_("|[file]|make a signature")},
361     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
362     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
363     { aEncr, "encrypt",   256, N_("encrypt data")},
364     { aEncrFiles, "encrypt-files", 256, "@"},
365     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
366     { aStore, "store",     256, "@"},
367     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
368     { aDecryptFiles, "decrypt-files", 256, "@"},
369     { aVerify, "verify"   , 256, N_("verify a signature")},
370     { aVerifyFiles, "verify-files" , 256, "@" },
371     { aListKeys, "list-keys", 256, N_("list keys")},
372     { aListKeys, "list-public-keys", 256, "@" },
373     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
374     { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
375     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
376     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
377     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
378     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
379     { aDeleteSecretKeys, "delete-secret-keys",256,
380                                     N_("remove keys from the secret keyring")},
381     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
382     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
383     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
384     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
385     { aDesigRevoke, "desig-revoke",256, "@" },
386     { aExport, "export"           , 256, N_("export keys") },
387     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
388     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
389     { aSearchKeys, "search-keys" , 256,
390                                     N_("search for keys on a key server") },
391     { aRefreshKeys, "refresh-keys", 256,
392                                     N_("update all keys from a keyserver")},
393     { aExportSecret, "export-secret-keys" , 256, "@" },
394     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
395     { aImport, "import",      256     , N_("import/merge keys")},
396     { aFastImport, "fast-import",  256 , "@"},
397 #ifdef ENABLE_CARD_SUPPORT
398     { aCardStatus,  "card-status", 256, N_("print the card status")},
399     { aCardEdit,   "card-edit",  256, N_("change data on a card")},
400     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
401 #endif
402     { aListConfig, "list-config", 256, "@"},
403     { aGPGConfList, "gpgconf-list", 256, "@" },
404     { aListPackets, "list-packets",256, "@"},
405     { aExportOwnerTrust, "export-ownertrust", 256, "@"},
406     { aImportOwnerTrust, "import-ownertrust", 256, "@"},
407     { aUpdateTrustDB,
408               "update-trustdb",0 , N_("update the trust database")},
409     { aCheckTrustDB, "check-trustdb", 0, "@"},
410     { aFixTrustDB, "fix-trustdb", 0, "@"},
411     { aDeArmor, "dearmor", 256, "@"},
412     { aDeArmor, "dearmour", 256, "@"},
413     { aEnArmor, "enarmor", 256, "@"},
414     { aEnArmor, "enarmour", 256, "@"},
415     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
416     { aPrimegen, "gen-prime" , 256, "@" },
417     { aGenRandom, "gen-random" , 256, "@" },
418
419     { 301, NULL, 0, N_("@\nOptions:\n ") },
420
421     { oArmor, "armor",     0, N_("create ascii armored output")},
422     { oArmor, "armour",     0, "@" },
423     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
424     { oHiddenRecipient, "hidden-recipient", 2, "@" },
425     { oRecipient, "remote-user", 2, "@"},  /* old option name */
426     { oDefRecipient, "default-recipient", 2, "@"},
427     { oDefRecipientSelf, "default-recipient-self", 0, "@"},
428     { oNoDefRecipient, "no-default-recipient", 0, "@" },
429     { oTempDir, "temp-directory", 2, "@" },
430     { oExecPath, "exec-path", 2, "@" },
431     { oEncryptTo, "encrypt-to", 2, "@" },
432     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
433     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
434     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
435     { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
436     { oCompressLevel, "compress-level", 1, "@" },
437     { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
438     { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
439     { oTextmodeShort, NULL,   0, "@"},
440     { oTextmode, "textmode",  0, N_("use canonical text mode")},
441     { oNoTextmode, "no-textmode",  0, "@"},
442     { oExpert, "expert",   0, "@"},
443     { oNoExpert, "no-expert",   0, "@"},
444     { oAskSigExpire, "ask-sig-expire",   0, "@"},
445     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
446     { oAskCertExpire, "ask-cert-expire",   0, "@"},
447     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
448     { oAskCertLevel, "ask-cert-level",   0, "@"},
449     { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
450     { oOutput, "output",    2, N_("use as output file")},
451     { oMaxOutput, "max-output", 16|4, "@" },
452     { oVerbose, "verbose",   0, N_("verbose") },
453     { oQuiet,   "quiet",   0, "@"},
454     { oNoTTY, "no-tty", 0, "@"},
455     { oForceV3Sigs, "force-v3-sigs", 0, "@"},
456     { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
457     { oForceV4Certs, "force-v4-certs", 0, "@"},
458     { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
459     { oForceMDC, "force-mdc", 0, "@"},
460     { oNoForceMDC, "no-force-mdc", 0, "@" },
461     { oDisableMDC, "disable-mdc", 0, "@"},
462     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
463     { oDryRun, "dry-run",   0, N_("do not make any changes") },
464     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
465     { oUseAgent, "use-agent",0, "@"},
466     { oNoUseAgent, "no-use-agent",0, "@"},
467     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
468     { oBatch, "batch", 0, "@"},
469     { oAnswerYes, "yes", 0, "@"},
470     { oAnswerNo, "no", 0, "@"},
471     { oKeyring, "keyring", 2, "@"},
472     { oPrimaryKeyring, "primary-keyring",2, "@" },
473     { oSecretKeyring, "secret-keyring", 2, "@"},
474     { oShowKeyring, "show-keyring", 0, "@"},
475     { oDefaultKey, "default-key", 2, "@"},
476     { oKeyServer, "keyserver", 2, "@"},
477     { oKeyServerOptions, "keyserver-options",2,"@"},
478     { oImportOptions, "import-options",2,"@"},
479     { oExportOptions, "export-options",2,"@"},
480     { oListOptions, "list-options",2,"@"},
481     { oVerifyOptions, "verify-options",2,"@"},
482     { oDisplayCharset, "display-charset", 2, "@"},
483     { oDisplayCharset, "charset", 2, "@"},
484     { oOptions, "options", 2, "@"},
485     { oDebug, "debug"     ,4|16, "@"},
486     { oDebugAll, "debug-all" ,0, "@"},
487     { oStatusFD, "status-fd" ,1, "@"},
488     { oStatusFile, "status-file" ,2, "@"},
489     { oAttributeFD, "attribute-fd" ,1, "@" },
490     { oAttributeFile, "attribute-file" ,2, "@" },
491     { oNoSKComments, "no-sk-comments", 0,   "@"},
492     { oSKComments, "sk-comments", 0,   "@"},
493     { oCompletesNeeded, "completes-needed", 1, "@"},
494     { oMarginalsNeeded, "marginals-needed", 1, "@"},
495     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
496     { oTrustedKey, "trusted-key", 2, "@"},
497     { oLoadExtension, "load-extension", 2, "@"},
498     { oGnuPG, "gnupg",   0, "@"},
499     { oGnuPG, "no-pgp2", 0, "@"},
500     { oGnuPG, "no-pgp6", 0, "@"},
501     { oGnuPG, "no-pgp7", 0, "@"},
502     { oGnuPG, "no-pgp8", 0, "@"},
503     { oRFC1991, "rfc1991",   0, "@"},
504     { oRFC2440, "rfc2440", 0, "@" },
505     { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
506     { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
507     { oPGP6, "pgp6", 0, "@"},
508     { oPGP7, "pgp7", 0, "@"},
509     { oPGP8, "pgp8", 0, "@"},
510     { oS2KMode, "s2k-mode", 1, "@"},
511     { oS2KDigest, "s2k-digest-algo", 2, "@"},
512     { oS2KCipher, "s2k-cipher-algo", 2, "@"},
513     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
514     { oCipherAlgo, "cipher-algo", 2, "@"},
515     { oDigestAlgo, "digest-algo", 2, "@"},
516     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
517     { oCompressAlgo,"compress-algo", 2, "@"},
518     { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
519     { oThrowKeyids, "throw-keyid", 0, "@"},
520     { oThrowKeyids, "throw-keyids", 0, "@"},
521     { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
522     { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
523     { oShowPhotos,   "show-photos", 0, "@" },
524     { oNoShowPhotos, "no-show-photos", 0, "@" },
525     { oPhotoViewer,  "photo-viewer", 2, "@" },
526     { oSetNotation,  "set-notation", 2, "@" },
527     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
528     { oSigNotation,  "sig-notation", 2, "@" },
529     { oCertNotation, "cert-notation", 2, "@" },
530
531     { 302, NULL, 0, N_(
532   "@\n(See the man page for a complete listing of all commands and options)\n"
533                       )},
534
535     { 303, NULL, 0, N_("@\nExamples:\n\n"
536     " -se -r Bob [file]          sign and encrypt for user Bob\n"
537     " --clearsign [file]         make a clear text signature\n"
538     " --detach-sign [file]       make a detached signature\n"
539     " --list-keys [names]        show keys\n"
540     " --fingerprint [names]      show fingerprints\n"  ) },
541
542   /* hidden options */
543     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
544     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
545     { aListTrustDB, "list-trustdb",0 , "@"},
546     /* Not yet used */
547     /* { aListTrustPath, "list-trust-path",0, "@"}, */
548     { aPipeMode,  "pipemode", 0, "@" },
549     { oKOption, NULL,    0, "@"},
550     { oPasswdFD, "passphrase-fd",1, "@" },
551     { oPasswdFile, "passphrase-file",2, "@" },
552     { oCommandFD, "command-fd",1, "@" },
553     { oCommandFile, "command-file",2, "@" },
554     { oQuickRandom, "quick-random", 0, "@"},
555     { oNoVerbose, "no-verbose", 0, "@"},
556     { oTrustDBName, "trustdb-name", 2, "@" },
557     { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
558     { oRequireSecmem,"require-secmem", 0, "@" },
559     { oNoRequireSecmem,"no-require-secmem", 0, "@" },
560     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
561     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
562     { oNoArmor, "no-armor",   0, "@"},
563     { oNoArmor, "no-armour",   0, "@"},
564     { oNoDefKeyring, "no-default-keyring", 0, "@" },
565     { oNoGreeting, "no-greeting", 0, "@" },
566     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
567     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
568     { oNoBatch, "no-batch", 0, "@" },
569     { oWithColons, "with-colons", 0, "@"},
570     { oWithKeyData,"with-key-data", 0, "@"},
571     { aListKeys, "list-key", 0, "@" }, /* alias */
572     { aListSigs, "list-sig", 0, "@" }, /* alias */
573     { aCheckKeys, "check-sig",0, "@" }, /* alias */
574     { oSkipVerify, "skip-verify",0, "@" },
575     { oCompressKeys, "compress-keys",0, "@"},
576     { oCompressSigs, "compress-sigs",0, "@"},
577     { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
578     { oDefCertLevel, "default-cert-level", 1, "@"},
579     { oMinCertLevel, "min-cert-level", 1, "@"},
580     { oAlwaysTrust, "always-trust", 0, "@"},
581     { oTrustModel, "trust-model", 2, "@"},
582     { oForceOwnertrust, "force-ownertrust", 2, "@"},
583     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
584     { oSetFilename, "set-filename", 2, "@" },
585     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
586     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
587     { oSetPolicyURL, "set-policy-url", 2, "@" },
588     { oSigPolicyURL, "sig-policy-url", 2, "@" },
589     { oCertPolicyURL, "cert-policy-url", 2, "@" },
590     { oShowPolicyURL, "show-policy-url", 0, "@" },
591     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
592     { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
593     { oShowNotation, "show-notation", 0, "@" },
594     { oNoShowNotation, "no-show-notation", 0, "@" },
595     { oComment, "comment", 2, "@" },
596     { oDefaultComment, "default-comment", 0, "@" },
597     { oNoComments, "no-comments", 0, "@" },
598     { oEmitVersion, "emit-version", 0, "@"},
599     { oNoEmitVersion, "no-emit-version", 0, "@"},
600     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
601     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
602     { oEscapeFrom, "escape-from-lines", 0, "@" },
603     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
604     { oLockOnce, "lock-once", 0, "@" },
605     { oLockMultiple, "lock-multiple", 0, "@" },
606     { oLockNever, "lock-never", 0, "@" },
607     { oLoggerFD, "logger-fd",1, "@" },
608     { oLoggerFile, "logger-file",2, "@" },
609     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
610     { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
611     { oUtf8Strings, "utf8-strings", 0, "@" },
612     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
613     { oWithFingerprint, "with-fingerprint", 0, "@" },
614     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
615     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
616     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
617     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
618     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
619     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
620     { oNoLiteral, "no-literal", 0, "@" },
621     { oSetFilesize, "set-filesize", 20, "@" },
622     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
623     { oFastListMode,"fast-list-mode", 0, "@" },
624     { oFixedListMode,"fixed-list-mode", 0, "@" },
625     { oListOnly, "list-only", 0, "@"},
626     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
627     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
628     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
629     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
630     { oShowSessionKey, "show-session-key", 0, "@" },
631     { oOverrideSessionKey, "override-session-key", 2, "@" },
632     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
633     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
634     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
635     { oNoSigCache,         "no-sig-cache", 0, "@" },
636     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
637     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
638     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
639     { oMergeOnly,         "merge-only", 0, "@" },
640     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
641     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
642     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
643     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
644     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
645     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
646     { oPreservePermissions, "preserve-permissions", 0, "@"},
647     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
648     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
649     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
650     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
651     /* Aliases.  I constantly mistype these, and assume other people
652        do as well. */
653     { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
654     { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
655     { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
656     { oDisplay,    "display",     2, "@" },
657     { oTTYname,    "ttyname",     2, "@" },
658     { oTTYtype,    "ttytype",     2, "@" },
659     { oLCctype,    "lc-ctype",    2, "@" },
660     { oLCmessages, "lc-messages", 2, "@" },
661     { oGroup,      "group",       2, "@" },
662     { oUnGroup,    "ungroup",     2, "@" },
663     { oNoGroups,   "no-groups",    0, "@" },
664     { oStrict,     "strict",      0, "@" },
665     { oNoStrict,   "no-strict",   0, "@" },
666     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
667     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
668     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
669     { oMultifile, "multifile", 0, "@" },
670     { oKeyidFormat, "keyid-format", 2, "@" },
671
672     { oReaderPort, "reader-port",    2, "@"},
673     { octapiDriver, "ctapi-driver",  2, "@"},
674     { opcscDriver, "pcsc-driver",    2, "@"},
675     { oDisableCCID, "disable-ccid", 0, "@"},
676 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
677     { oDebugCCIDDriver, "debug-ccid-driver", 0, "@"},
678 #endif
679
680     {0,NULL,0,NULL}
681 };
682
683
684 #ifdef ENABLE_SELINUX_HACKS
685 #define ALWAYS_ADD_KEYRINGS 1
686 #else
687 #define ALWAYS_ADD_KEYRINGS 0
688 #endif
689
690
691 int g10_errors_seen = 0;
692
693 static int utf8_strings = 0;
694 static int maybe_setuid = 1;
695
696 static char *build_list( const char *text, char letter,
697                          const char *(*mapf)(int), int (*chkf)(int) );
698 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
699                         enum cmd_and_opt_values new_cmd );
700 static void print_mds( const char *fname, int algo );
701 static void add_notation_data( const char *string, int which );
702 static void add_policy_url( const char *string, int which );
703 static void add_keyserver_url( const char *string, int which );
704
705 const char *
706 strusage( int level )
707 {
708   static char *digests, *pubkeys, *ciphers, *zips;
709     const char *p;
710     switch( level ) {
711       case 11: p = "gpg (GnuPG)";
712         break;
713       case 13: p = VERSION; break;
714       case 17: p = PRINTABLE_OS_NAME; break;
715       case 19: p =
716             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
717         break;
718
719 #ifdef IS_DEVELOPMENT_VERSION
720       case 20:
721         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
722         break;
723       case 21:
724         p="It is only intended for test purposes and should NOT be";
725         break;
726       case 22:
727         p="used in a production environment or with production keys!";
728         break;
729 #endif
730
731       case 1:
732       case 40:  p =
733             _("Usage: gpg [options] [files] (-h for help)");
734         break;
735       case 41:  p =
736             _("Syntax: gpg [options] [files]\n"
737               "sign, check, encrypt or decrypt\n"
738               "default operation depends on the input data\n");
739         break;
740
741       case 31: p = "\nHome: "; break;
742 #ifndef __riscos__
743       case 32: p = opt.homedir; break;
744 #else /* __riscos__ */
745       case 32: p = make_filename(opt.homedir, NULL); break;
746 #endif /* __riscos__ */
747       case 33: p = _("\nSupported algorithms:\n"); break;
748       case 34:
749         if( !pubkeys )
750             pubkeys = build_list(_("Pubkey: "), 0, pubkey_algo_to_string,
751                                                         check_pubkey_algo );
752         p = pubkeys;
753         break;
754       case 35:
755         if( !ciphers )
756             ciphers = build_list(_("Cipher: "), 'S', cipher_algo_to_string,
757                                                         check_cipher_algo );
758         p = ciphers;
759         break;
760       case 36:
761         if( !digests )
762             digests = build_list(_("Hash: "), 'H', digest_algo_to_string,
763                                                         check_digest_algo );
764         p = digests;
765         break;
766       case 37:
767         if( !zips )
768             zips = build_list(_("Compression: "),'Z',compress_algo_to_string,
769                                                         check_compress_algo);
770         p = zips;
771         break;
772
773       default:  p = default_strusage(level);
774     }
775     return p;
776 }
777
778
779 static char *
780 build_list( const char *text, char letter,
781             const char * (*mapf)(int), int (*chkf)(int) )
782 {
783     int i;
784     const char *s;
785     size_t n=strlen(text)+2;
786     char *list, *p, *line=NULL;
787
788     if( maybe_setuid )
789         secmem_init( 0 );    /* drop setuid */
790
791     for(i=0; i <= 110; i++ )
792         if( !chkf(i) && (s=mapf(i)) )
793             n += strlen(s) + 7 + 2;
794     list = m_alloc( 21 + n ); *list = 0;
795     for(p=NULL, i=0; i <= 110; i++ ) {
796         if( !chkf(i) && (s=mapf(i)) ) {
797             if( !p ) {
798                 p = stpcpy( list, text );
799                 line=p;
800             }
801             else
802                 p = stpcpy( p, ", ");
803
804             if(strlen(line)>60) {
805               int spaces=strlen(text);
806
807               list=m_realloc(list,n+spaces+1);
808               /* realloc could move the block, so find the end again */
809               p=list;
810               while(*p)
811                 p++;
812
813               p=stpcpy(p, "\n");
814               line=p;
815               for(;spaces;spaces--)
816                 p=stpcpy(p, " ");
817             }
818
819             p = stpcpy(p, s );
820             if(opt.verbose && letter)
821               {
822                 char num[8];
823                 sprintf(num," (%c%d)",letter,i);
824                 p = stpcpy(p,num);
825               }
826         }
827     }
828     if( p )
829         p = stpcpy(p, "\n" );
830     return list;
831 }
832
833
834 static void
835 i18n_init(void)
836 {
837 #ifdef USE_SIMPLE_GETTEXT
838     set_gettext_file( PACKAGE );
839 #else
840 #ifdef ENABLE_NLS
841     setlocale( LC_ALL, "" );
842     bindtextdomain( PACKAGE, G10_LOCALEDIR );
843     textdomain( PACKAGE );
844 #endif
845 #endif
846 }
847
848 static void
849 wrong_args( const char *text)
850 {
851     fputs(_("usage: gpg [options] "),stderr);
852     fputs(text,stderr);
853     putc('\n',stderr);
854     g10_exit(2);
855 }
856
857
858 static char *
859 make_username( const char *string )
860 {
861     char *p;
862     if( utf8_strings )
863         p = m_strdup(string);
864     else
865         p = native_to_utf8( string );
866     return p;
867 }
868
869
870 static void
871 set_debug(void)
872 {
873     if( opt.debug & DBG_MEMORY_VALUE )
874         memory_debug_mode = 1;
875     if( opt.debug & DBG_MEMSTAT_VALUE )
876         memory_stat_debug_mode = 1;
877     if( opt.debug & DBG_MPI_VALUE )
878         mpi_debug_mode = 1;
879     if( opt.debug & DBG_CIPHER_VALUE )
880         g10c_debug_mode = 1;
881     if( opt.debug & DBG_IOBUF_VALUE )
882         iobuf_debug_mode = 1;
883
884 }
885
886
887 /* We need the home directory also in some other directories, so make
888    sure that both variables are always in sync. */
889 static void
890 set_homedir (char *dir)
891 {
892   if (!dir)
893     dir = "";
894   g10_opt_homedir = opt.homedir = dir;
895 }
896
897
898 /* We set the screen dimensions for UI purposes.  Do not allow screens
899    smaller than 80x24 for the sake of simplicity. */
900 static void
901 set_screen_dimensions(void)
902 {
903 #ifndef _WIN32
904   char *str;
905
906   str=getenv("COLUMNS");
907   if(str)
908     opt.screen_columns=atoi(str);
909
910   str=getenv("LINES");
911   if(str)
912     opt.screen_lines=atoi(str);
913 #endif
914
915   if(opt.screen_columns<80 || opt.screen_columns>255)
916     opt.screen_columns=80;
917
918   if(opt.screen_lines<24 || opt.screen_lines>255)
919     opt.screen_lines=24;
920 }
921
922
923 /* Helper to open a file FNAME either for reading or writing to be
924    used with --status-file etc functions.  Not generally useful but it
925    avoids the riscos specific functions and well some Windows people
926    might like it too.  Prints an error message and returns -1 on
927    error. On success the file descriptor is returned.  */
928 static int
929 open_info_file (const char *fname, int for_write)
930 {
931 #ifdef __riscos__
932   return riscos_fdopenfile (fname, for_write);
933 #elif defined (ENABLE_SELINUX_HACKS)
934   /* We can't allow these even when testing for a secured filename
935      because files to be secured might not yet been secured.  This is
936      similar to the option file but in that case it is unlikely that
937      sensitive information may be retrieved by means of error
938      messages.  */
939   return -1;
940 #else 
941   int fd;
942
943 /*   if (is_secured_filename (fname)) */
944 /*     { */
945 /*       fd = -1; */
946 /*       errno = EPERM; */
947 /*     } */
948 /*   else */
949 /*     { */
950       do
951         {
952           if (for_write)
953             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
954                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
955           else
956             fd = open (fname, O_RDONLY | MY_O_BINARY);
957         }
958       while (fd == -1 && errno == EINTR);
959 /*     } */
960   if ( fd == -1)
961     log_error ( for_write? _("can't create `%s': %s\n")
962                          : _("can't open `%s': %s\n"), fname, strerror(errno));
963   
964   return fd;
965 #endif
966 }
967
968 static void
969 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
970 {
971     enum cmd_and_opt_values cmd = *ret_cmd;
972
973     if( !cmd || cmd == new_cmd )
974         cmd = new_cmd;
975     else if( cmd == aSign && new_cmd == aEncr )
976         cmd = aSignEncr;
977     else if( cmd == aEncr && new_cmd == aSign )
978         cmd = aSignEncr;
979     else if( cmd == aSign && new_cmd == aSym )
980         cmd = aSignSym;
981     else if( cmd == aSym && new_cmd == aSign )
982         cmd = aSignSym;
983     else if( cmd == aSym && new_cmd == aEncr )
984         cmd = aEncrSym;
985     else if( cmd == aEncr && new_cmd == aSym )
986         cmd = aEncrSym;
987     else if( cmd == aKMode && new_cmd == aSym )
988         cmd = aKModeC;
989     else if (cmd == aSignEncr && new_cmd == aSym)
990         cmd = aSignEncrSym;
991     else if (cmd == aSignSym && new_cmd == aEncr)
992         cmd = aSignEncrSym;
993     else if (cmd == aEncrSym && new_cmd == aSign)
994         cmd = aSignEncrSym;
995     else if(    ( cmd == aSign     && new_cmd == aClearsign )
996              || ( cmd == aClearsign && new_cmd == aSign )  )
997         cmd = aClearsign;
998     else {
999         log_error(_("conflicting commands\n"));
1000         g10_exit(2);
1001     }
1002
1003     *ret_cmd = cmd;
1004 }
1005
1006
1007 static void
1008 add_group(char *string)
1009 {
1010   char *name,*value;
1011   struct groupitem *item;
1012
1013   /* Break off the group name */
1014   name=strsep(&string,"=");
1015   if(string==NULL)
1016     {
1017       log_error(_("no = sign found in group definition `%s'\n"),name);
1018       return;
1019     }
1020
1021   trim_trailing_ws(name,strlen(name));
1022
1023   /* Does this group already exist? */
1024   for(item=opt.grouplist;item;item=item->next)
1025     if(strcasecmp(item->name,name)==0)
1026       break;
1027
1028   if(!item)
1029     {
1030       item=m_alloc(sizeof(struct groupitem));
1031       item->name=name;
1032       item->next=opt.grouplist;
1033       item->values=NULL;
1034       opt.grouplist=item;
1035     }
1036
1037   /* Break apart the values */
1038   while ((value= strsep(&string," \t")))
1039     {
1040       if (*value)
1041         add_to_strlist2(&item->values,value,utf8_strings);
1042     }
1043 }
1044
1045
1046 static void
1047 rm_group(char *name)
1048 {
1049   struct groupitem *item,*last=NULL;
1050
1051   trim_trailing_ws(name,strlen(name));
1052
1053   for(item=opt.grouplist;item;last=item,item=item->next)
1054     {
1055       if(strcasecmp(item->name,name)==0)
1056         {
1057           if(last)
1058             last->next=item->next;
1059           else
1060             opt.grouplist=item->next;
1061
1062           free_strlist(item->values);
1063           m_free(item);
1064           break;
1065         }
1066     }
1067 }
1068
1069
1070 /* We need to check three things.
1071
1072    0) The homedir.  It must be x00, a directory, and owned by the
1073    user.
1074
1075    1) The options/gpg.conf file.  Okay unless it or its containing
1076    directory is group or other writable or not owned by us.  Disable
1077    exec in this case.
1078
1079    2) Extensions.  Same as #1.
1080
1081    Returns true if the item is unsafe. */
1082 static int
1083 check_permissions(const char *path,int item)
1084 {
1085 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1086   static int homedir_cache=-1;
1087   char *tmppath,*dir;
1088   struct stat statbuf,dirbuf;
1089   int homedir=0,ret=0,checkonly=0;
1090   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1091
1092   if(opt.no_perm_warn)
1093     return 0;
1094
1095   assert(item==0 || item==1 || item==2);
1096
1097   /* extensions may attach a path */
1098   if(item==2 && path[0]!=DIRSEP_C)
1099     {
1100       if(strchr(path,DIRSEP_C))
1101         tmppath=make_filename(path,NULL);
1102       else
1103         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
1104     }
1105   else
1106     tmppath=m_strdup(path);
1107
1108   /* If the item is located in the homedir, but isn't the homedir,
1109      don't continue if we already checked the homedir itself.  This is
1110      to avoid user confusion with an extra options file warning which
1111      could be rectified if the homedir itself had proper
1112      permissions. */
1113   if(item!=0 && homedir_cache>-1
1114      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1115     {
1116       ret=homedir_cache;
1117       goto end;
1118     }
1119
1120   /* It's okay if the file or directory doesn't exist */
1121   if(stat(tmppath,&statbuf)!=0)
1122     {
1123       ret=0;
1124       goto end;
1125     }
1126
1127   /* Now check the enclosing directory.  Theoretically, we could walk
1128      this test up to the root directory /, but for the sake of sanity,
1129      I'm stopping at one level down. */
1130   dir=make_dirname(tmppath);
1131
1132   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1133     {
1134       /* Weird error */
1135       ret=1;
1136       goto end;
1137     }
1138
1139   m_free(dir);
1140
1141   /* Assume failure */
1142   ret=1;
1143
1144   if(item==0)
1145     {
1146       /* The homedir must be x00, a directory, and owned by the user. */
1147
1148       if(S_ISDIR(statbuf.st_mode))
1149         {
1150           if(statbuf.st_uid==getuid())
1151             {
1152               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1153                 ret=0;
1154               else
1155                 perm=1;
1156             }
1157           else
1158             own=1;
1159
1160           homedir_cache=ret;
1161         }
1162     }
1163   else if(item==1 || item==2)
1164     {
1165       /* The options or extension file.  Okay unless it or its
1166          containing directory is group or other writable or not owned
1167          by us or root. */
1168
1169       if(S_ISREG(statbuf.st_mode))
1170         {
1171           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1172             {
1173               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1174                 {
1175                   /* it's not writable, so make sure the enclosing
1176                      directory is also not writable */
1177                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1178                     {
1179                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1180                         ret=0;
1181                       else
1182                         enc_dir_perm=1;
1183                     }
1184                   else
1185                     enc_dir_own=1;
1186                 }
1187               else
1188                 {
1189                   /* it's writable, so the enclosing directory had
1190                      better not let people get to it. */
1191                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1192                     {
1193                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1194                         ret=0;
1195                       else
1196                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1197                     }
1198                   else
1199                     enc_dir_own=1;
1200                 }
1201             }
1202           else
1203             own=1;
1204         }
1205     }
1206   else
1207     BUG();
1208
1209   if(!checkonly)
1210     {
1211       if(own)
1212         {
1213           if(item==0)
1214             log_info(_("WARNING: unsafe ownership on"
1215                        " homedir `%s'\n"),tmppath);
1216           else if(item==1)
1217             log_info(_("WARNING: unsafe ownership on"
1218                        " configuration file `%s'\n"),tmppath);
1219           else
1220             log_info(_("WARNING: unsafe ownership on"
1221                        " extension `%s'\n"),tmppath);
1222         }
1223       if(perm)
1224         {
1225           if(item==0)
1226             log_info(_("WARNING: unsafe permissions on"
1227                        " homedir `%s'\n"),tmppath);
1228           else if(item==1)
1229             log_info(_("WARNING: unsafe permissions on"
1230                        " configuration file `%s'\n"),tmppath);
1231           else
1232             log_info(_("WARNING: unsafe permissions on"
1233                        " extension `%s'\n"),tmppath);
1234         }
1235       if(enc_dir_own)
1236         {
1237           if(item==0)
1238             log_info(_("WARNING: unsafe enclosing directory ownership on"
1239                        " homedir `%s'\n"),tmppath);
1240           else if(item==1)
1241             log_info(_("WARNING: unsafe enclosing directory ownership on"
1242                        " configuration file `%s'\n"),tmppath);
1243           else
1244             log_info(_("WARNING: unsafe enclosing directory ownership on"
1245                        " extension `%s'\n"),tmppath);
1246         }
1247       if(enc_dir_perm)
1248         {
1249           if(item==0)
1250             log_info(_("WARNING: unsafe enclosing directory permissions on"
1251                        " homedir `%s'\n"),tmppath);
1252           else if(item==1)
1253             log_info(_("WARNING: unsafe enclosing directory permissions on"
1254                        " configuration file `%s'\n"),tmppath);
1255           else
1256             log_info(_("WARNING: unsafe enclosing directory permissions on"
1257                        " extension `%s'\n"),tmppath);
1258         }
1259     }
1260
1261  end:
1262   m_free(tmppath);
1263
1264   if(homedir)
1265     homedir_cache=ret;
1266
1267   return ret;
1268
1269 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1270
1271   return 0;
1272 }
1273
1274
1275 static void
1276 print_algo_numbers(int (*checker)(int))
1277 {
1278   int i,first=1;
1279
1280   for(i=0;i<=110;i++)
1281     {
1282       if(!checker(i))
1283         {
1284           if(first)
1285             first=0;
1286           else
1287             printf(";");
1288           printf("%d",i);
1289         }
1290     }
1291 }
1292
1293
1294 /* In the future, we can do all sorts of interesting configuration
1295    output here.  For now, just give "group" as the Enigmail folks need
1296    it, and pubkey, cipher, hash, and compress as they may be useful
1297    for frontends. */
1298 static void
1299 list_config(char *items)
1300 {
1301   int show_all=(items==NULL);
1302   char *name=NULL;
1303
1304   if(!opt.with_colons)
1305     return;
1306
1307   while(show_all || (name=strsep(&items," ")))
1308     {
1309       int any=0;
1310
1311       if(show_all || ascii_strcasecmp(name,"group")==0)
1312         {
1313           struct groupitem *iter;
1314
1315           for(iter=opt.grouplist;iter;iter=iter->next)
1316             {
1317               STRLIST sl;
1318
1319               printf("cfg:group:");
1320               print_string(stdout,iter->name,strlen(iter->name),':');
1321               printf(":");
1322
1323               for(sl=iter->values;sl;sl=sl->next)
1324                 {
1325                   print_string2(stdout,sl->d,strlen(sl->d),':',';');
1326                   if(sl->next)
1327                     printf(";");
1328                 }
1329
1330               printf("\n");
1331             }
1332
1333           any=1;
1334         }
1335
1336       if(show_all || ascii_strcasecmp(name,"version")==0)
1337         {
1338           printf("cfg:version:");
1339           print_string(stdout,VERSION,strlen(VERSION),':');
1340           printf("\n");
1341           any=1;
1342         }
1343
1344       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1345         {
1346           printf("cfg:pubkey:");
1347           print_algo_numbers(check_pubkey_algo);
1348           printf("\n");
1349           any=1;
1350         }
1351
1352       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1353         {
1354           printf("cfg:cipher:");
1355           print_algo_numbers(check_cipher_algo);
1356           printf("\n");
1357           any=1;
1358         }
1359
1360       if(show_all
1361          || ascii_strcasecmp(name,"digest")==0
1362          || ascii_strcasecmp(name,"hash")==0)
1363         {
1364           printf("cfg:digest:");
1365           print_algo_numbers(check_digest_algo);
1366           printf("\n");
1367           any=1;
1368         }
1369
1370       if(show_all || ascii_strcasecmp(name,"compress")==0)
1371         {
1372           printf("cfg:compress:");
1373           print_algo_numbers(check_compress_algo);
1374           printf("\n");
1375           any=1;
1376         }
1377
1378       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1379         {
1380 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1381           char *p, *p2, *list = ccid_get_reader_list ();
1382
1383           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1384             {
1385               *p2 = 0;
1386               printf("cfg:ccid-reader-id:%s\n", p);
1387             }
1388           free (list);
1389 #endif
1390           any=1;
1391         }
1392
1393       if(show_all)
1394         break;
1395
1396       if(!any)
1397         log_error(_("unknown configuration item `%s'\n"),name);
1398     }
1399 }
1400
1401
1402 /* List options and default values in the GPG Conf format.  This is a
1403    new tool distributed with gnupg 1.9.x but we also want some limited
1404    support in older gpg versions.  The output is the name of the
1405    configuration file and a list of options available for editing by
1406    gpgconf.  */
1407 static void
1408 gpgconf_list (const char *configfile)
1409 {
1410   /* The following definitions are taken from gnupg/tools/gpgconf-comp.c.  */
1411 #define GC_OPT_FLAG_NONE        0UL
1412 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1413
1414   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1415           GC_OPT_FLAG_DEFAULT,configfile?configfile:"/dev/null");
1416   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1417   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1418   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1419   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1420 }
1421
1422
1423 static int
1424 parse_subpacket_list(char *list)
1425 {
1426   char *tok;
1427   byte subpackets[128],i;
1428   int count=0;
1429
1430   if(!list)
1431     {
1432       /* No arguments means all subpackets */
1433       memset(subpackets+1,1,sizeof(subpackets)-1);
1434       count=127;
1435     }
1436   else
1437     {
1438       memset(subpackets,0,sizeof(subpackets));
1439
1440       /* Merge with earlier copy */
1441       if(opt.show_subpackets)
1442         {
1443           byte *in;
1444
1445           for(in=opt.show_subpackets;*in;in++)
1446             {
1447               if(*in>127 || *in<1)
1448                 BUG();
1449
1450               if(!subpackets[*in])
1451                 count++;
1452               subpackets[*in]=1;
1453             }
1454         }
1455
1456       while((tok=strsep(&list," ,")))
1457         {
1458           if(!*tok)
1459             continue;
1460
1461           i=atoi(tok);
1462           if(i>127 || i<1)
1463             return 0;
1464
1465           if(!subpackets[i])
1466             count++;
1467           subpackets[i]=1;
1468         }
1469     }
1470
1471   m_free(opt.show_subpackets);
1472   opt.show_subpackets=m_alloc(count+1);
1473   opt.show_subpackets[count--]=0;
1474
1475   for(i=1;i<128 && count>=0;i++)
1476     if(subpackets[i])
1477       opt.show_subpackets[count--]=i;
1478
1479   return 1;
1480 }
1481
1482
1483 static int
1484 parse_list_options(char *str)
1485 {
1486   char *subpackets=""; /* something that isn't NULL */
1487   struct parse_options lopts[]=
1488     {
1489       {"show-photos",LIST_SHOW_PHOTOS,NULL},
1490       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL},
1491       {"show-notations",LIST_SHOW_NOTATIONS,NULL},
1492       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL},
1493       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL},
1494       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL},
1495       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL},
1496       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL},
1497       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL},
1498       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL},
1499       {"show-keyring",LIST_SHOW_KEYRING,NULL},
1500       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL},
1501       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL},
1502       {NULL,0,NULL}
1503     };
1504
1505   /* C99 allows for non-constant initializers, but we'd like to
1506      compile everywhere, so fill in the show-sig-subpackets argument
1507      here.  Note that if the parse_options array changes, we'll have
1508      to change the subscript here. */
1509   lopts[12].value=&subpackets;
1510
1511   if(parse_options(str,&opt.list_options,lopts,1))
1512     {
1513       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1514         {
1515           /* Unset so users can pass multiple lists in. */
1516           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1517           if(!parse_subpacket_list(subpackets))
1518             return 0;
1519         }
1520       else if(subpackets==NULL && opt.show_subpackets)
1521         {
1522           /* User did 'no-show-subpackets' */
1523           m_free(opt.show_subpackets);
1524           opt.show_subpackets=NULL;
1525         }
1526
1527       return 1;
1528     }
1529   else
1530     return 0;
1531 }
1532
1533
1534 /* Collapses argc/argv into a single string that must be freed */
1535 static char *
1536 collapse_args(int argc,char *argv[])
1537 {
1538   char *str=NULL;
1539   int i,first=1,len=0;
1540
1541   for(i=0;i<argc;i++)
1542     {
1543       len+=strlen(argv[i])+2;
1544       str=m_realloc(str,len);
1545       if(first)
1546         {
1547           str[0]='\0';
1548           first=0;
1549         }
1550       else
1551         strcat(str," ");
1552
1553       strcat(str,argv[i]);
1554     }
1555
1556   return str;
1557 }
1558
1559 static void
1560 parse_trust_model(const char *model)
1561 {
1562   if(ascii_strcasecmp(model,"pgp")==0)
1563     opt.trust_model=TM_PGP;
1564   else if(ascii_strcasecmp(model,"classic")==0)
1565     opt.trust_model=TM_CLASSIC;
1566   else if(ascii_strcasecmp(model,"always")==0)
1567     opt.trust_model=TM_ALWAYS;
1568   else if(ascii_strcasecmp(model,"direct")==0)
1569     opt.trust_model=TM_DIRECT;
1570   else if(ascii_strcasecmp(model,"auto")==0)
1571     opt.trust_model=TM_AUTO;
1572   else
1573     log_error("unknown trust model `%s'\n",model);
1574 }
1575
1576 int
1577 main( int argc, char **argv )
1578 {
1579     ARGPARSE_ARGS pargs;
1580     IOBUF a;
1581     int rc=0;
1582     int orig_argc;
1583     char **orig_argv;
1584     const char *fname;
1585     char *username;
1586     int may_coredump;
1587     STRLIST sl, remusr= NULL, locusr=NULL;
1588     STRLIST nrings=NULL, sec_nrings=NULL;
1589     armor_filter_context_t afx;
1590     int detached_sig = 0;
1591     FILE *configfp = NULL;
1592     char *configname = NULL;
1593     char *save_configname = NULL;
1594     unsigned configlineno;
1595     int parse_debug = 0;
1596     int default_config = 1;
1597     int default_keyring = 1;
1598     int greeting = 0;
1599     int nogreeting = 0;
1600     int use_random_seed = 1;
1601     enum cmd_and_opt_values cmd = 0;
1602     const char *trustdb_name = NULL;
1603     char *def_cipher_string = NULL;
1604     char *def_digest_string = NULL;
1605     char *compress_algo_string = NULL;
1606     char *cert_digest_string = NULL;
1607     char *s2k_cipher_string = NULL;
1608     char *s2k_digest_string = NULL;
1609     char *pers_cipher_list = NULL;
1610     char *pers_digest_list = NULL;
1611     char *pers_compress_list = NULL;
1612     int eyes_only=0;
1613     int multifile=0;
1614     int pwfd = -1;
1615     int with_fpr = 0; /* make an option out of --fingerprint */
1616     int any_explicit_recipient = 0;
1617     int require_secmem=0,got_secmem=0;
1618 #ifdef USE_SHM_COPROCESSING
1619     ulong requested_shm_size=0;
1620 #endif
1621
1622 #ifdef __riscos__
1623     opt.lock_once = 1;
1624 #endif /* __riscos__ */
1625
1626     trap_unaligned();
1627     secmem_set_flags( secmem_get_flags() | 2 ); /* suspend warnings */
1628     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1629      * when adding any stuff between here and the call to
1630      * secmem_init()  somewhere after the option parsing
1631      */
1632     log_set_name("gpg");
1633     secure_random_alloc(); /* put random number into secure memory */
1634     may_coredump = disable_core_dumps();
1635     init_signals();
1636     create_dotlock(NULL); /* register locking cleanup */
1637     i18n_init();
1638     opt.command_fd = -1; /* no command fd */
1639     opt.compress_level = -1; /* defaults to standard compress level */
1640     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1641     /* note: if you change these lines, look at oOpenPGP */
1642     opt.def_cipher_algo = 0;
1643     opt.def_digest_algo = 0;
1644     opt.cert_digest_algo = 0;
1645     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1646     opt.s2k_mode = 3; /* iterated+salted */
1647 #ifdef USE_CAST5
1648     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1649 #else
1650     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1651 #endif
1652     opt.completes_needed = 1;
1653     opt.marginals_needed = 3;
1654     opt.max_cert_depth = 5;
1655     opt.pgp2_workarounds = 1;
1656     opt.force_v3_sigs = 1;
1657     opt.escape_from = 1;
1658     opt.import_options=IMPORT_SK2PK;
1659     opt.export_options=EXPORT_ATTRIBUTES;
1660     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1661     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1662     opt.keyserver_options.options=
1663       KEYSERVER_INCLUDE_SUBKEYS|KEYSERVER_INCLUDE_REVOKED|KEYSERVER_TRY_DNS_SRV|KEYSERVER_HONOR_KEYSERVER_URL;
1664     opt.verify_options=
1665       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1666     opt.trust_model=TM_AUTO;
1667     opt.mangle_dos_filenames=0;
1668     opt.min_cert_level=2;
1669     set_screen_dimensions();
1670     opt.keyid_format=KF_SHORT;
1671 #if defined (_WIN32)
1672     set_homedir ( read_w32_registry_string( NULL,
1673                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1674 #else
1675     set_homedir ( getenv("GNUPGHOME") );
1676 #endif
1677     if( !*opt.homedir )
1678         set_homedir ( GNUPG_HOMEDIR );
1679
1680 #ifdef ENABLE_CARD_SUPPORT
1681 # ifdef _WIN32
1682     opt.pcsc_driver = "winscard.dll"; 
1683 #else
1684     opt.pcsc_driver = "libpcsclite.so"; 
1685 #endif
1686 #endif /*ENABLE_CARD_SUPPORT*/
1687
1688     /* check whether we have a config file on the commandline */
1689     orig_argc = argc;
1690     orig_argv = argv;
1691     pargs.argc = &argc;
1692     pargs.argv = &argv;
1693     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1694     while( arg_parse( &pargs, opts) ) {
1695         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1696             parse_debug++;
1697         else if( pargs.r_opt == oOptions ) {
1698             /* yes there is one, so we do not try the default one, but
1699              * read the option file when it is encountered at the commandline
1700              */
1701             default_config = 0;
1702         }
1703         else if( pargs.r_opt == oNoOptions )
1704             default_config = 0; /* --no-options */
1705         else if( pargs.r_opt == oHomedir )
1706             set_homedir ( pargs.r.ret_str );
1707         else if( pargs.r_opt == oNoPermissionWarn )
1708             opt.no_perm_warn=1;
1709         else if (pargs.r_opt == oStrict )
1710           {
1711             opt.strict=1;
1712             log_set_strict(1);
1713           }
1714         else if (pargs.r_opt == oNoStrict )
1715           {
1716             opt.strict=0;
1717             log_set_strict(0);
1718           }
1719 #ifdef USE_SHM_COPROCESSING
1720         else if( pargs.r_opt == oRunAsShmCP ) {
1721             /* does not make sense in a options file, we do it here,
1722              * so that we are the able to drop setuid as soon as possible */
1723             opt.shm_coprocess = 1;
1724             requested_shm_size = pargs.r.ret_ulong;
1725         }
1726         else if ( pargs.r_opt == oStatusFD ) {
1727             /* this is needed to ensure that the status-fd filedescriptor is
1728              * initialized when init_shm_coprocessing() is called */
1729             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1730         }
1731 #endif
1732     }
1733
1734 #ifdef HAVE_DOSISH_SYSTEM
1735     if ( strchr (opt.homedir,'\\') ) {
1736         char *d, *buf = m_alloc (strlen (opt.homedir)+1);
1737         const char *s = opt.homedir;
1738         for (d=buf,s=opt.homedir; *s; s++)
1739             *d++ = *s == '\\'? '/': *s;
1740         *d = 0;
1741         set_homedir (buf);
1742     }
1743 #endif
1744 #ifdef USE_SHM_COPROCESSING
1745     if( opt.shm_coprocess ) {
1746         init_shm_coprocessing(requested_shm_size, 1 );
1747     }
1748 #endif
1749     /* initialize the secure memory. */
1750     got_secmem=secmem_init( 32768 );
1751     maybe_setuid = 0;
1752     /* Okay, we are now working under our real uid */
1753
1754 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1755     /* There should be no way to get to this spot while still carrying
1756        setuid privs.  Just in case, bomb out if we are. */
1757     if(getuid()!=geteuid())
1758       BUG();
1759 #endif
1760
1761     set_native_charset (NULL); /* Try to auto set the character set */
1762
1763     /* Try for a version specific config file first */
1764     if( default_config )
1765       {
1766         char *name=m_strdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1767         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1768
1769         do
1770           {
1771             if(configname)
1772               {
1773                 char *tok;
1774
1775                 m_free(configname);
1776                 configname=NULL;
1777
1778                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1779                   *tok='\0';
1780                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1781                   *tok='\0';
1782                 else
1783                   break;
1784               }
1785
1786             configname = make_filename(opt.homedir,name,NULL);
1787           }
1788         while(access(configname,R_OK));
1789
1790         m_free(name);
1791
1792         if(!configname)
1793           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1794         if (!access (configname, R_OK))
1795           { /* Print a warning when both config files are present. */
1796             char *p = make_filename(opt.homedir, "options", NULL );
1797             if (!access (p, R_OK))
1798               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1799             m_free (p);
1800           }
1801         else
1802           { /* Keep on using the old default one. */
1803             m_free (configname);
1804             configname = make_filename(opt.homedir, "options", NULL );
1805           }
1806       }
1807     argc = orig_argc;
1808     argv = orig_argv;
1809     pargs.argc = &argc;
1810     pargs.argv = &argv;
1811     pargs.flags=  1;  /* do not remove the args */
1812
1813     /* By this point we have a homedir, and cannot change it. */
1814     check_permissions(opt.homedir,0);
1815
1816   next_pass:
1817     if( configname ) {
1818       if(check_permissions(configname,1))
1819         {
1820           /* If any options file is unsafe, then disable any external
1821              programs for keyserver calls or photo IDs.  Since the
1822              external program to call is set in the options file, a
1823              unsafe options file can lead to an arbitrary program
1824              being run. */
1825
1826           opt.exec_disable=1;
1827         }
1828
1829         configlineno = 0;
1830         configfp = fopen( configname, "r" );
1831         if (configfp && is_secured_file (fileno (configfp)))
1832           {
1833             fclose (configfp);
1834             configfp = NULL;
1835             errno = EPERM;
1836           }
1837         if( !configfp ) {
1838             if( default_config ) {
1839                 if( parse_debug )
1840                     log_info(_("NOTE: no default option file `%s'\n"),
1841                                                             configname );
1842             }
1843             else {
1844                 log_error(_("option file `%s': %s\n"),
1845                                     configname, strerror(errno) );
1846                 g10_exit(2);
1847             }
1848             m_free(configname); configname = NULL;
1849         }
1850         if( parse_debug && configname )
1851             log_info(_("reading options from `%s'\n"), configname );
1852         default_config = 0;
1853     }
1854
1855     while( optfile_parse( configfp, configname, &configlineno,
1856                                                 &pargs, opts) )
1857       {
1858         switch( pargs.r_opt )
1859           {
1860           case aCheckKeys: 
1861           case aListConfig:
1862           case aGPGConfList:
1863           case aListPackets:
1864           case aImport: 
1865           case aFastImport: 
1866           case aSendKeys: 
1867           case aRecvKeys: 
1868           case aSearchKeys:
1869           case aRefreshKeys:
1870           case aExport: 
1871             set_cmd (&cmd, pargs.r_opt);
1872             break;
1873           case aListKeys: set_cmd( &cmd, aListKeys); break;
1874           case aListSigs: set_cmd( &cmd, aListSigs); break;
1875           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1876           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1877           case aDeleteSecretKeys:
1878             set_cmd( &cmd, aDeleteSecretKeys);
1879             greeting=1;
1880             break;
1881           case aDeleteSecretAndPublicKeys:
1882             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1883             greeting=1; 
1884             break;
1885           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1886
1887           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1888           case aSym: set_cmd( &cmd, aSym); break;
1889
1890           case aDecryptFiles: multifile=1; /* fall through */
1891           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1892
1893           case aEncrFiles: multifile=1; /* fall through */
1894           case aEncr: set_cmd( &cmd, aEncr); break;
1895
1896           case aVerifyFiles: multifile=1; /* fall through */
1897           case aVerify: set_cmd( &cmd, aVerify); break;
1898
1899           case aSign: set_cmd( &cmd, aSign );  break;
1900           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1901           case aSignKey: set_cmd( &cmd, aSignKey); break;
1902           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1903           case aStore: set_cmd( &cmd, aStore); break;
1904           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1905           case aClearsign: set_cmd( &cmd, aClearsign); break;
1906           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1907           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1908           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1909           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1910           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1911           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1912           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1913           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1914           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1915           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1916           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1917           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1918           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1919           case aListOwnerTrust:
1920             deprecated_warning(configname,configlineno,
1921                                "--list-ownertrust","--export-ownertrust","");
1922           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1923           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1924           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1925           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1926
1927 #ifdef ENABLE_CARD_SUPPORT
1928           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1929           case aCardEdit: set_cmd (&cmd, aCardEdit); break;
1930           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1931           case oReaderPort:
1932             card_set_reader_port (pargs.r.ret_str);
1933             break;
1934           case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
1935           case opcscDriver: opt.pcsc_driver = pargs.r.ret_str; break;
1936           case oDisableCCID: opt.disable_ccid = 1; break;
1937 #endif /* ENABLE_CARD_SUPPORT*/
1938
1939           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1940           case oOutput: opt.outfile = pargs.r.ret_str; break;
1941           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
1942           case oQuiet: opt.quiet = 1; break;
1943           case oNoTTY: tty_no_terminal(1); break;
1944           case oDryRun: opt.dry_run = 1; break;
1945           case oInteractive: opt.interactive = 1; break;
1946           case oVerbose:
1947             g10_opt_verbose++;
1948             opt.verbose++;
1949             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
1950             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
1951             break;
1952           case oKOption: set_cmd( &cmd, aKMode ); break;
1953
1954           case oBatch: opt.batch = 1; nogreeting = 1; break;
1955           case oUseAgent:
1956 #ifndef __riscos__
1957             opt.use_agent = 1;
1958 #else /* __riscos__ */
1959             opt.use_agent = 0;
1960             riscos_not_implemented("use-agent");
1961 #endif /* __riscos__ */
1962             break;
1963           case oNoUseAgent: opt.use_agent = 0; break;
1964           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1965           case oAnswerYes: opt.answer_yes = 1; break;
1966           case oAnswerNo: opt.answer_no = 1; break;
1967           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1968           case oPrimaryKeyring:
1969             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1970             sl->flags=2;
1971             break;
1972           case oShowKeyring:
1973             deprecated_warning(configname,configlineno,"--show-keyring",
1974                                "--list-options ","show-keyring");
1975             opt.list_options|=LIST_SHOW_KEYRING;
1976             break;
1977           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1978           case oDebugAll: opt.debug = ~0; break;
1979           case oDebugCCIDDriver: 
1980 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1981             ccid_set_debug_level (1);
1982 #endif
1983             break;
1984           case oStatusFD:
1985             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1986             break;
1987           case oStatusFile:
1988             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
1989             break;
1990           case oAttributeFD:
1991             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1992             break;
1993           case oAttributeFile:
1994             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
1995             break;
1996           case oLoggerFD:
1997             log_set_logfile( NULL,
1998                              iobuf_translate_file_handle (pargs.r.ret_int, 1));
1999             break;
2000           case oLoggerFile:
2001             log_set_logfile( NULL, open_info_file (pargs.r.ret_str, 1) );
2002             break;
2003
2004           case oWithFingerprint:
2005             opt.with_fingerprint = 1;
2006             with_fpr=1; /*fall thru*/
2007           case oFingerprint: opt.fingerprint++; break;
2008           case oSecretKeyring:
2009             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2010             break;
2011           case oOptions:
2012             /* config files may not be nested (silently ignore them) */
2013             if( !configfp ) {
2014                 m_free(configname);
2015                 configname = m_strdup(pargs.r.ret_str);
2016                 goto next_pass;
2017             }
2018             break;
2019           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2020           case oNoDefKeyring: default_keyring = 0; break;
2021           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2022           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2023           case oNoGreeting: nogreeting = 1; break;
2024           case oNoVerbose: g10_opt_verbose = 0;
2025                            opt.verbose = 0; opt.list_sigs=0; break;
2026           case oQuickRandom: quick_random_gen(1); break;
2027           case oSKComments: opt.sk_comments=1; break;
2028           case oNoSKComments: opt.sk_comments=0; break;
2029           case oEmitVersion: opt.no_version=0; break;
2030           case oNoEmitVersion: opt.no_version=1; break;
2031           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2032           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2033           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2034           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2035           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2036           case oDefRecipient:
2037                     if( *pargs.r.ret_str )
2038                         opt.def_recipient = make_username(pargs.r.ret_str);
2039                     break;
2040           case oDefRecipientSelf:
2041                     m_free(opt.def_recipient); opt.def_recipient = NULL;
2042                     opt.def_recipient_self = 1;
2043                     break;
2044           case oNoDefRecipient:
2045                     m_free(opt.def_recipient); opt.def_recipient = NULL;
2046                     opt.def_recipient_self = 0;
2047                     break;
2048           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2049           case oHomedir: break;
2050           case oNoBatch: opt.batch = 0; break;
2051           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2052           case oWithColons: opt.with_colons=':'; break;
2053
2054           case oSkipVerify: opt.skip_verify=1; break;
2055           case oCompressKeys: opt.compress_keys = 1; break;
2056           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2057             /* There are many programs (like mutt) that call gpg with
2058                --always-trust so keep this option around for a long
2059                time. */
2060           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2061           case oTrustModel:
2062             parse_trust_model(pargs.r.ret_str);
2063             break;
2064           case oForceOwnertrust:
2065             log_info(_("NOTE: %s is not for normal use!\n"),
2066                      "--force-ownertrust");
2067             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2068             if(opt.force_ownertrust==-1)
2069               {
2070                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2071                 opt.force_ownertrust=0;
2072               }
2073             break;
2074           case oLoadExtension:
2075 #ifndef __riscos__
2076 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2077             if(check_permissions(pargs.r.ret_str,2))
2078               log_info(_("cipher extension `%s' not loaded due to"
2079                          " unsafe permissions\n"),pargs.r.ret_str);
2080             else
2081               register_cipher_extension(orig_argc? *orig_argv:NULL,
2082                                         pargs.r.ret_str);
2083 #endif
2084 #else /* __riscos__ */
2085             riscos_not_implemented("load-extension");
2086 #endif /* __riscos__ */
2087             break;
2088           case oRFC1991:
2089             opt.compliance = CO_RFC1991;
2090             opt.force_v4_certs = 0;
2091             opt.escape_from = 1;
2092             break;
2093           case oRFC2440:
2094           case oOpenPGP:
2095             /* TODO: When 2440bis becomes a RFC, these may need
2096                changing. */
2097             opt.compliance = CO_RFC2440;
2098             opt.allow_non_selfsigned_uid = 1;
2099             opt.allow_freeform_uid = 1;
2100             opt.pgp2_workarounds = 0;
2101             opt.escape_from = 0;
2102             opt.force_v3_sigs = 0;
2103             opt.compress_keys = 0;          /* not mandated  but we do it */
2104             opt.compress_sigs = 0;          /* ditto. */
2105             opt.not_dash_escaped = 0;
2106             opt.def_cipher_algo = 0;
2107             opt.def_digest_algo = 0;
2108             opt.cert_digest_algo = 0;
2109             opt.compress_algo = -1;
2110             opt.s2k_mode = 3; /* iterated+salted */
2111             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2112             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2113             break;
2114           case oPGP2:  opt.compliance = CO_PGP2;  break;
2115           case oPGP6:  opt.compliance = CO_PGP6;  break;
2116           case oPGP7:  opt.compliance = CO_PGP7;  break;
2117           case oPGP8:  opt.compliance = CO_PGP8;  break;
2118           case oGnuPG: opt.compliance = CO_GNUPG; break;
2119           case oCompressSigs: opt.compress_sigs = 1; break;
2120           case oRunAsShmCP:
2121 #ifndef __riscos__
2122 # ifndef USE_SHM_COPROCESSING
2123             /* not possible in the option file,
2124              * but we print the warning here anyway */
2125             log_error("shared memory coprocessing is not available\n");
2126 # endif
2127 #else /* __riscos__ */
2128             riscos_not_implemented("run-as-shm-coprocess");
2129 #endif /* __riscos__ */
2130             break;
2131           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
2132           case oForYourEyesOnly: eyes_only = 1; break;
2133           case oNoForYourEyesOnly: eyes_only = 0; break;
2134           case oSetPolicyURL:
2135             add_policy_url(pargs.r.ret_str,0);
2136             add_policy_url(pargs.r.ret_str,1);
2137             break;
2138           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2139           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2140           case oShowPolicyURL:
2141             deprecated_warning(configname,configlineno,"--show-policy-url",
2142                                "--list-options ","show-policy-urls");
2143             deprecated_warning(configname,configlineno,"--show-policy-url",
2144                                "--verify-options ","show-policy-urls");
2145             opt.list_options|=LIST_SHOW_POLICY_URLS;
2146             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2147             break;
2148           case oNoShowPolicyURL:
2149             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2150                                "--list-options ","no-show-policy-urls");
2151             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2152                                "--verify-options ","no-show-policy-urls");
2153             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2154             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2155             break;
2156           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2157           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
2158           case oNoUseEmbeddedFilename: opt.use_embedded_filename = 0; break;
2159           case oComment:
2160             if(pargs.r.ret_str[0])
2161               append_to_strlist(&opt.comments,pargs.r.ret_str);
2162             break;
2163           case oDefaultComment:
2164             deprecated_warning(configname,configlineno,
2165                                "--default-comment","--no-comments","");
2166             /* fall through */
2167           case oNoComments:
2168             free_strlist(opt.comments);
2169             opt.comments=NULL;
2170             break;
2171           case oThrowKeyids: opt.throw_keyid = 1; break;
2172           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2173           case oShowPhotos:
2174             deprecated_warning(configname,configlineno,"--show-photos",
2175                                "--list-options ","show-photos");
2176             deprecated_warning(configname,configlineno,"--show-photos",
2177                                "--verify-options ","show-photos");
2178             opt.list_options|=LIST_SHOW_PHOTOS;
2179             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2180             break;
2181           case oNoShowPhotos:
2182             deprecated_warning(configname,configlineno,"--no-show-photos",
2183                                "--list-options ","no-show-photos");
2184             deprecated_warning(configname,configlineno,"--no-show-photos",
2185                                "--verify-options ","no-show-photos");
2186             opt.list_options&=~LIST_SHOW_PHOTOS;
2187             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2188             break;
2189           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2190           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2191           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2192           case oForceV4Certs: opt.force_v4_certs = 1; break;
2193           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2194           case oForceMDC: opt.force_mdc = 1; break;
2195           case oNoForceMDC: opt.force_mdc = 0; break;
2196           case oDisableMDC: opt.disable_mdc = 1; break;
2197           case oNoDisableMDC: opt.disable_mdc = 0; break;
2198           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2199           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
2200           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
2201           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2202           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2203           case oEncryptTo: /* store the recipient in the second list */
2204             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2205             sl->flags = 1;
2206             break;
2207           case oHiddenEncryptTo: /* store the recipient in the second list */
2208             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2209             sl->flags = 1|2;
2210             break;
2211           case oRecipient: /* store the recipient */
2212             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2213             any_explicit_recipient = 1;
2214             break;
2215           case oHiddenRecipient: /* store the recipient with a flag */
2216             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2217             sl->flags = 2;
2218             any_explicit_recipient = 1;
2219             break;
2220           case oTextmodeShort: opt.textmode = 2; break;
2221           case oTextmode: opt.textmode=1;  break;
2222           case oNoTextmode: opt.textmode=0;  break;
2223           case oExpert: opt.expert = 1; break;
2224           case oNoExpert: opt.expert = 0; break;
2225           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2226           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2227           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2228           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2229           case oAskCertLevel: opt.ask_cert_level = 1; break;
2230           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2231           case oUser: /* store the local users */
2232             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2233             break;
2234           case oCompress:
2235             /* this is the -z command line option */
2236             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2237             break;
2238           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2239           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2240           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2241           case oPasswdFD:
2242             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2243             opt.use_agent = 0;
2244             break;
2245           case oPasswdFile:
2246             pwfd = open_info_file (pargs.r.ret_str, 0);
2247             break;
2248           case oCommandFD:
2249             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2250             break;
2251           case oCommandFile:
2252             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2253             break;
2254           case oCipherAlgo: 
2255             def_cipher_string = m_strdup(pargs.r.ret_str);
2256             break;
2257           case oDigestAlgo:
2258             def_digest_string = m_strdup(pargs.r.ret_str);
2259             break;
2260           case oCompressAlgo:
2261             /* If it is all digits, stick a Z in front of it for
2262                later.  This is for backwards compatibility with
2263                versions that took the compress algorithm number. */
2264             {
2265               char *pt=pargs.r.ret_str;
2266               while(*pt)
2267                 {
2268                   if(!isdigit(*pt))
2269                     break;
2270
2271                   pt++;
2272                 }
2273
2274               if(*pt=='\0')
2275                 {
2276                   compress_algo_string=m_alloc(strlen(pargs.r.ret_str)+2);
2277                   strcpy(compress_algo_string,"Z");
2278                   strcat(compress_algo_string,pargs.r.ret_str);
2279                 }
2280               else
2281                 compress_algo_string = m_strdup(pargs.r.ret_str);
2282             }
2283             break;
2284           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
2285           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
2286           case oRequireSecmem: require_secmem=1; break;
2287           case oNoRequireSecmem: require_secmem=0; break;
2288           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2289           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2290           case oDisplayCharset:
2291             if( set_native_charset( pargs.r.ret_str ) )
2292                 log_error(_("`%s' is not a valid character set\n"),
2293                           pargs.r.ret_str);
2294             break;
2295           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2296           case oEscapeFrom: opt.escape_from = 1; break;
2297           case oNoEscapeFrom: opt.escape_from = 0; break;
2298           case oLockOnce: opt.lock_once = 1; break;
2299           case oLockNever: disable_dotlock(); break;
2300           case oLockMultiple:
2301 #ifndef __riscos__
2302             opt.lock_once = 0;
2303 #else /* __riscos__ */
2304             riscos_not_implemented("lock-multiple");
2305 #endif /* __riscos__ */
2306             break;
2307           case oKeyServer:
2308             opt.keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2309                                               configname,configlineno);
2310             if(!opt.keyserver)
2311               log_error(_("could not parse keyserver URL\n"));
2312             break;
2313           case oKeyServerOptions:
2314             if(!parse_keyserver_options(pargs.r.ret_str))
2315               {
2316                 if(configname)
2317                   log_error(_("%s:%d: invalid keyserver options\n"),
2318                             configname,configlineno);
2319                 else
2320                   log_error(_("invalid keyserver options\n"));
2321               }
2322             break;
2323           case oImportOptions:
2324             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2325               {
2326                 if(configname)
2327                   log_error(_("%s:%d: invalid import options\n"),
2328                             configname,configlineno);
2329                 else
2330                   log_error(_("invalid import options\n"));
2331               }
2332             break;
2333           case oExportOptions:
2334             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2335               {
2336                 if(configname)
2337                   log_error(_("%s:%d: invalid export options\n"),
2338                             configname,configlineno);
2339                 else
2340                   log_error(_("invalid export options\n"));
2341               }
2342             break;
2343           case oListOptions:
2344             if(!parse_list_options(pargs.r.ret_str))
2345               {
2346                 if(configname)
2347                   log_error(_("%s:%d: invalid list options\n"),
2348                             configname,configlineno);
2349                 else
2350                   log_error(_("invalid list options\n"));
2351               }
2352             break;
2353           case oVerifyOptions:
2354             {
2355               struct parse_options vopts[]=
2356                 {
2357                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL},
2358                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL},
2359                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL},
2360                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2361                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL},
2362                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL},
2363                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL},
2364                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL},
2365                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL},
2366                   {NULL,0,NULL}
2367                 };
2368
2369               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2370                 {
2371                   if(configname)
2372                     log_error(_("%s:%d: invalid verify options\n"),
2373                               configname,configlineno);
2374                   else
2375                     log_error(_("invalid verify options\n"));
2376                 }
2377             }
2378             break;
2379           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2380           case oExecPath:
2381             if(set_exec_path(pargs.r.ret_str,0))
2382               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2383             else
2384               opt.exec_path_set=1;
2385             break;
2386           case oSetNotation:
2387             add_notation_data( pargs.r.ret_str, 0 );
2388             add_notation_data( pargs.r.ret_str, 1 );
2389             break;
2390           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2391           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2392           case oShowNotation:
2393             deprecated_warning(configname,configlineno,"--show-notation",
2394                                "--list-options ","show-notations");
2395             deprecated_warning(configname,configlineno,"--show-notation",
2396                                "--verify-options ","show-notations");
2397             opt.list_options|=LIST_SHOW_NOTATIONS;
2398             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2399             break;
2400           case oNoShowNotation:
2401             deprecated_warning(configname,configlineno,"--no-show-notation",
2402                                "--list-options ","no-show-notations");
2403             deprecated_warning(configname,configlineno,"--no-show-notation",
2404                                "--verify-options ","no-show-notations");
2405             opt.list_options&=~LIST_SHOW_NOTATIONS;
2406             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2407             break;
2408           case oUtf8Strings: utf8_strings = 1; break;
2409           case oNoUtf8Strings: utf8_strings = 0; break;
2410           case oDisableCipherAlgo:
2411                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
2412                 break;
2413           case oDisablePubkeyAlgo:
2414                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
2415                 break;
2416           case oNoSigCache: opt.no_sig_cache = 1; break;
2417           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2418           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2419           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2420           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2421           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2422           case oNoLiteral: opt.no_literal = 1; break;
2423           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2424           case oHonorHttpProxy:
2425                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2426                 deprecated_warning(configname,configlineno,
2427                                    "--honor-http-proxy",
2428                                    "--keyserver-options ","http-proxy");
2429                 break;
2430           case oFastListMode: opt.fast_list_mode = 1; break;
2431           case oFixedListMode: opt.fixed_list_mode = 1; break;
2432           case oListOnly: opt.list_only=1; break;
2433           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2434           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2435           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2436           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2437           case oNoRandomSeedFile: use_random_seed = 0; break;
2438           case oAutoKeyRetrieve:
2439           case oNoAutoKeyRetrieve:
2440                 if(pargs.r_opt==oAutoKeyRetrieve)
2441                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2442                 else
2443                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2444
2445                 deprecated_warning(configname,configlineno,
2446                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2447                                "--no-auto-key-retrieve","--keyserver-options ",
2448                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2449                                "no-auto-key-retrieve");
2450                 break;
2451           case oShowSessionKey: opt.show_session_key = 1; break;
2452           case oOverrideSessionKey:
2453                 opt.override_session_key = pargs.r.ret_str;
2454                 break;
2455           case oMergeOnly:
2456                 deprecated_warning(configname,configlineno,"--merge-only",
2457                                    "--import-options ","merge-only");
2458                 opt.import_options|=IMPORT_MERGE_ONLY;
2459             break;
2460           case oAllowSecretKeyImport: /* obsolete */ break;
2461           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2462           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2463           case oEnableSpecialFilenames:
2464             iobuf_enable_special_filenames (1);
2465             break;
2466           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2467           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2468           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2469           case oPreservePermissions: opt.preserve_permissions=1; break;
2470           case oDefaultPreferenceList:
2471             opt.def_preference_list = pargs.r.ret_str;
2472             break;
2473           case oPersonalCipherPreferences:
2474             pers_cipher_list=pargs.r.ret_str;
2475             break;
2476           case oPersonalDigestPreferences:
2477             pers_digest_list=pargs.r.ret_str;
2478             break;
2479           case oPersonalCompressPreferences:
2480             pers_compress_list=pargs.r.ret_str;
2481             break;
2482           case oDisplay: opt.display = pargs.r.ret_str; break;
2483           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2484           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2485           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2486           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2487           case oGroup: add_group(pargs.r.ret_str); break;
2488           case oUnGroup: rm_group(pargs.r.ret_str); break;
2489           case oNoGroups:
2490             while(opt.grouplist)
2491               {
2492                 struct groupitem *iter=opt.grouplist;
2493                 free_strlist(iter->values);
2494                 opt.grouplist=opt.grouplist->next;
2495                 m_free(iter);
2496               }
2497             break;
2498           case oStrict: opt.strict=1; log_set_strict(1); break;
2499           case oNoStrict: opt.strict=0; log_set_strict(0); break;
2500           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2501           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2502           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2503           case oMultifile: multifile=1; break;
2504           case oKeyidFormat:
2505             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2506               opt.keyid_format=KF_SHORT;
2507             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2508               opt.keyid_format=KF_LONG;
2509             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2510               opt.keyid_format=KF_0xSHORT;
2511             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2512               opt.keyid_format=KF_0xLONG;
2513             else
2514               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2515             break;
2516
2517           default : pargs.err = configfp? 1:2; break;
2518           }
2519       }
2520
2521
2522     if( configfp ) {
2523         fclose( configfp );
2524         configfp = NULL;
2525         /* Remember the first config file name. */
2526         if (!save_configname)
2527           save_configname = configname;
2528         else
2529           m_free(configname);
2530         configname = NULL;
2531         goto next_pass;
2532     }
2533     m_free( configname ); configname = NULL;
2534     if( log_get_errorcount(0) )
2535         g10_exit(2);
2536
2537     /* The command --gpgconf-list is pretty simple and may be called
2538        directly after the option parsing. */
2539     if (cmd == aGPGConfList)
2540       {
2541         gpgconf_list (save_configname);
2542         g10_exit (0);
2543       }
2544     m_free (save_configname);
2545
2546     if( nogreeting )
2547         greeting = 0;
2548
2549     if( greeting ) {
2550         fprintf(stderr, "%s %s; %s\n",
2551                         strusage(11), strusage(13), strusage(14) );
2552         fprintf(stderr, "%s\n", strusage(15) );
2553     }
2554 #ifdef IS_DEVELOPMENT_VERSION
2555     if( !opt.batch )
2556       {
2557         const char *s;
2558
2559         if((s=strusage(20)))
2560           log_info("%s\n",s);
2561         if((s=strusage(21)))
2562           log_info("%s\n",s);
2563         if((s=strusage(22)))
2564           log_info("%s\n",s);
2565       }
2566 #endif
2567
2568     if (opt.verbose > 2)
2569         log_info ("using character set `%s'\n", get_native_charset ());
2570
2571     if( may_coredump && !opt.quiet )
2572         log_info(_("WARNING: program may create a core file!\n"));
2573
2574     if (eyes_only) {
2575       if (opt.set_filename)
2576           log_info(_("WARNING: %s overrides %s\n"),
2577                    "--for-your-eyes-only","--set-filename");
2578
2579       opt.set_filename="_CONSOLE";
2580     }
2581
2582     if (opt.no_literal) {
2583         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2584         if (opt.textmode)
2585             log_error(_("%s not allowed with %s!\n"),
2586                        "--textmode", "--no-literal" );
2587         if (opt.set_filename)
2588             log_error(_("%s makes no sense with %s!\n"),
2589                         eyes_only?"--for-your-eyes-only":"--set-filename",
2590                         "--no-literal" );
2591     }
2592
2593     if (opt.set_filesize)
2594         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2595     if( opt.batch )
2596         tty_batchmode( 1 );
2597
2598     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2599
2600     if(require_secmem && !got_secmem)
2601       {
2602         log_info(_("will not run with insecure memory due to %s"),
2603                  "--require-secmem\n");
2604         g10_exit(2);
2605       }
2606
2607     set_debug();
2608
2609     /* Do these after the switch(), so they can override settings. */
2610     if(PGP2)
2611       {
2612         int unusable=0;
2613
2614         if(cmd==aSign && !detached_sig)
2615           {
2616             log_info(_("you can only make detached or clear signatures "
2617                        "while in --pgp2 mode\n"));
2618             unusable=1;
2619           }
2620         else if(cmd==aSignEncr || cmd==aSignSym)
2621           {
2622             log_info(_("you can't sign and encrypt at the "
2623                        "same time while in --pgp2 mode\n"));
2624             unusable=1;
2625           }
2626         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2627           {
2628             log_info(_("you must use files (and not a pipe) when "
2629                        "working with --pgp2 enabled.\n"));
2630             unusable=1;
2631           }
2632         else if(cmd==aEncr || cmd==aSym)
2633           {
2634             /* Everything else should work without IDEA (except using
2635                a secret key encrypted with IDEA and setting an IDEA
2636                preference, but those have their own error
2637                messages). */
2638
2639             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2640               {
2641                 log_info(_("encrypting a message in --pgp2 mode requires "
2642                            "the IDEA cipher\n"));
2643                 idea_cipher_warn(1);
2644                 unusable=1;
2645               }
2646             else if(cmd==aSym)
2647               {
2648                 /* This only sets IDEA for symmetric encryption
2649                    since it is set via select_algo_from_prefs for
2650                    pk encryption. */
2651                 m_free(def_cipher_string);
2652                 def_cipher_string = m_strdup("idea");
2653               }
2654
2655             /* PGP2 can't handle the output from the textmode
2656                filter, so we disable it for anything that could
2657                create a literal packet (only encryption and
2658                symmetric encryption, since we disable signing
2659                above). */
2660             if(!unusable)
2661               opt.textmode=0;
2662           }
2663
2664         if(unusable)
2665           compliance_failure();
2666         else
2667           {
2668             opt.force_v4_certs = 0;
2669             opt.sk_comments = 0;
2670             opt.escape_from = 1;
2671             opt.force_v3_sigs = 1;
2672             opt.pgp2_workarounds = 1;
2673             opt.ask_sig_expire = 0;
2674             opt.ask_cert_expire = 0;
2675             m_free(def_digest_string);
2676             def_digest_string = m_strdup("md5");
2677             m_free(s2k_digest_string);
2678             s2k_digest_string = m_strdup("md5");
2679             opt.compress_algo = COMPRESS_ALGO_ZIP;
2680           }
2681       }
2682     else if(PGP6)
2683       {
2684         opt.sk_comments=0;
2685         opt.escape_from=1;
2686         opt.force_v3_sigs=1;
2687         opt.ask_sig_expire=0;
2688       }
2689     else if(PGP7)
2690       {
2691         opt.sk_comments=0;
2692         opt.escape_from=1;
2693         opt.force_v3_sigs=1;
2694         opt.ask_sig_expire=0;
2695       }
2696     else if(PGP8)
2697       {
2698         opt.escape_from=1;
2699       }
2700
2701     /* must do this after dropping setuid, because string_to...
2702      * may try to load an module */
2703     if( def_cipher_string ) {
2704         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2705         if(opt.def_cipher_algo==0 &&
2706            (ascii_strcasecmp(def_cipher_string,"idea")==0
2707             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2708           idea_cipher_warn(1);
2709         m_free(def_cipher_string); def_cipher_string = NULL;
2710         if( check_cipher_algo(opt.def_cipher_algo) )
2711             log_error(_("selected cipher algorithm is invalid\n"));
2712     }
2713     if( def_digest_string ) {
2714         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2715         m_free(def_digest_string); def_digest_string = NULL;
2716         if( check_digest_algo(opt.def_digest_algo) )
2717             log_error(_("selected digest algorithm is invalid\n"));
2718     }
2719     if( compress_algo_string ) {
2720         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2721         m_free(compress_algo_string); compress_algo_string = NULL;
2722         if( check_compress_algo(opt.compress_algo) )
2723             log_error(_("selected compression algorithm is invalid\n"));
2724     }
2725     if( cert_digest_string ) {
2726         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2727         m_free(cert_digest_string); cert_digest_string = NULL;
2728         if( check_digest_algo(opt.cert_digest_algo) )
2729             log_error(_("selected certification digest algorithm is invalid\n"));
2730     }
2731     if( s2k_cipher_string ) {
2732         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2733         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2734         if( check_cipher_algo(opt.s2k_cipher_algo) )
2735             log_error(_("selected cipher algorithm is invalid\n"));
2736     }
2737     if( s2k_digest_string ) {
2738         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2739         m_free(s2k_digest_string); s2k_digest_string = NULL;
2740         if( check_digest_algo(opt.s2k_digest_algo) )
2741             log_error(_("selected digest algorithm is invalid\n"));
2742     }
2743     if( opt.completes_needed < 1 )
2744       log_error(_("completes-needed must be greater than 0\n"));
2745     if( opt.marginals_needed < 2 )
2746       log_error(_("marginals-needed must be greater than 1\n"));
2747     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2748       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2749     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2750       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2751     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2752       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2753     switch( opt.s2k_mode ) {
2754       case 0:
2755         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2756         break;
2757       case 1: case 3: break;
2758       default:
2759         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2760     }
2761
2762     /* This isn't actually needed, but does serve to error out if the
2763        string is invalid. */
2764     if(opt.def_preference_list &&
2765         keygen_set_std_prefs(opt.def_preference_list,0))
2766       log_error(_("invalid default preferences\n"));
2767
2768     /* We provide defaults for the personal digest list.  This is
2769        SHA-1. */
2770     if(!pers_digest_list)
2771       pers_digest_list="h2";
2772
2773     if(pers_cipher_list &&
2774        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2775       log_error(_("invalid personal cipher preferences\n"));
2776
2777     if(pers_digest_list &&
2778        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2779       log_error(_("invalid personal digest preferences\n"));
2780
2781     if(pers_compress_list &&
2782        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2783       log_error(_("invalid personal compress preferences\n"));
2784
2785     /* We don't support all possible commands with multifile yet */
2786     if(multifile)
2787       {
2788         char *cmdname;
2789
2790         switch(cmd)
2791           {
2792           case aSign:
2793             cmdname="--sign";
2794             break;
2795           case aClearsign:
2796             cmdname="--clearsign";
2797             break;
2798           case aDetachedSign:
2799             cmdname="--detach-sign";
2800             break;
2801           case aSym:
2802             cmdname="--symmetric";
2803             break;
2804           case aEncrSym:
2805             cmdname="--symmetric --encrypt";
2806             break;
2807           case aStore:
2808             cmdname="--store";
2809             break;
2810           default:
2811             cmdname=NULL;
2812             break;
2813           }
2814
2815         if(cmdname)
2816           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2817       }
2818
2819     if( log_get_errorcount(0) )
2820         g10_exit(2);
2821
2822     if(opt.compress_level==0)
2823       opt.compress_algo=COMPRESS_ALGO_NONE;
2824
2825     /* Check our chosen algorithms against the list of legal
2826        algorithms. */
2827
2828     if(!GNUPG)
2829       {
2830         const char *badalg=NULL;
2831         preftype_t badtype=PREFTYPE_NONE;
2832
2833         if(opt.def_cipher_algo
2834            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2835           {
2836             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2837             badtype=PREFTYPE_SYM;
2838           }
2839         else if(opt.def_digest_algo
2840                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2841           {
2842             badalg=digest_algo_to_string(opt.def_digest_algo);
2843             badtype=PREFTYPE_HASH;
2844           }
2845         else if(opt.cert_digest_algo
2846                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2847           {
2848             badalg=digest_algo_to_string(opt.cert_digest_algo);
2849             badtype=PREFTYPE_HASH;
2850           }
2851         else if(opt.compress_algo!=-1
2852                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
2853           {
2854             badalg=compress_algo_to_string(opt.compress_algo);
2855             badtype=PREFTYPE_ZIP;
2856           }
2857
2858         if(badalg)
2859           {
2860             switch(badtype)
2861               {
2862               case PREFTYPE_SYM:
2863                 log_info(_("you may not use cipher algorithm `%s'"
2864                            " while in %s mode\n"),
2865                          badalg,compliance_option_string());
2866                 break;
2867               case PREFTYPE_HASH:
2868                 log_info(_("you may not use digest algorithm `%s'"
2869                            " while in %s mode\n"),
2870                          badalg,compliance_option_string());
2871                 break;
2872               case PREFTYPE_ZIP:
2873                 log_info(_("you may not use compression algorithm `%s'"
2874                            " while in %s mode\n"),
2875                          badalg,compliance_option_string());
2876                 break;
2877               default:
2878                 BUG();
2879               }
2880
2881             compliance_failure();
2882           }
2883       }
2884
2885     /* set the random seed file */
2886     if( use_random_seed ) {
2887         char *p = make_filename(opt.homedir, "random_seed", NULL );
2888         set_random_seed_file(p);
2889         if (!access (p, F_OK))
2890           register_secured_file (p);
2891         m_free(p);
2892     }
2893
2894     if( !cmd && opt.fingerprint && !with_fpr ) {
2895         set_cmd( &cmd, aListKeys);
2896     }
2897
2898     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2899         if( cmd == aKModeC ) {
2900             opt.fingerprint = 1;
2901             cmd = aKMode;
2902         }
2903         opt.list_sigs = 0;
2904         if( opt.verbose > 2 )
2905             opt.check_sigs++;
2906         if( opt.verbose > 1 )
2907             opt.list_sigs++;
2908
2909         opt.verbose = opt.verbose > 1;
2910         g10_opt_verbose = opt.verbose;
2911     }
2912
2913     /* kludge to let -sat generate a clear text signature */
2914     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2915         cmd = aClearsign;
2916
2917     if( opt.verbose > 1 )
2918         set_packet_list_mode(1);
2919
2920     /* Add the keyrings, but not for some special commands and not in
2921        case of "-kvv userid keyring".  Also avoid adding the secret
2922        keyring for a couple of commands to avoid unneeded access in
2923        case the secrings are stored on a floppy.
2924        
2925        We always need to add the keyrings if we are running under
2926        SELinux, thi is so that the rings are added to the list of
2927        secured files. */
2928     if( ALWAYS_ADD_KEYRINGS 
2929         || (cmd != aDeArmor && cmd != aEnArmor
2930             && !(cmd == aKMode && argc == 2 )) ) 
2931       {
2932         if (ALWAYS_ADD_KEYRINGS
2933             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2934                 && cmd != aVerify && cmd != aSym))
2935           {
2936             if (!sec_nrings || default_keyring) /* add default secret rings */
2937               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2938             for (sl = sec_nrings; sl; sl = sl->next)
2939               keydb_add_resource ( sl->d, 0, 1 );
2940           }
2941         if( !nrings || default_keyring )  /* add default ring */
2942             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2943         for(sl = nrings; sl; sl = sl->next )
2944             keydb_add_resource ( sl->d, sl->flags, 0 );
2945       }
2946     FREE_STRLIST(nrings);
2947     FREE_STRLIST(sec_nrings);
2948
2949
2950     if( pwfd != -1 )  /* read the passphrase now. */
2951         read_passphrase_from_fd( pwfd );
2952
2953     fname = argc? *argv : NULL;
2954
2955     switch( cmd ) {
2956       case aPrimegen:
2957       case aPrintMD:
2958       case aPrintMDs:
2959       case aGenRandom:
2960       case aDeArmor:
2961       case aEnArmor:
2962       case aFixTrustDB:
2963         break;
2964       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2965       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2966       default: rc = setup_trustdb(1, trustdb_name ); break;
2967     }
2968     if( rc )
2969         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2970
2971
2972     switch (cmd)
2973       {
2974       case aStore: 
2975       case aSym:  
2976       case aSign: 
2977       case aSignSym: 
2978       case aClearsign: 
2979         if (!opt.quiet && any_explicit_recipient)
2980           log_info (_("WARNING: recipients (-r) given "
2981                       "without using public key encryption\n"));
2982         break;
2983       default:
2984         break;
2985       }
2986
2987     switch( cmd )
2988       {
2989       case aStore: /* only store the file */
2990         if( argc > 1 )
2991             wrong_args(_("--store [filename]"));
2992         if( (rc = encode_store(fname)) )
2993             log_error ("storing `%s' failed: %s\n",
2994                        print_fname_stdin(fname),g10_errstr(rc) );
2995         break;
2996       case aSym: /* encrypt the given file only with the symmetric cipher */
2997         if( argc > 1 )
2998             wrong_args(_("--symmetric [filename]"));
2999         if( (rc = encode_symmetric(fname)) )
3000             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3001                         print_fname_stdin(fname),g10_errstr(rc) );
3002         break;
3003
3004       case aEncr: /* encrypt the given file */
3005         if(multifile)
3006           encode_crypt_files(argc, argv, remusr);
3007         else
3008           {
3009             if( argc > 1 )
3010               wrong_args(_("--encrypt [filename]"));
3011             if( (rc = encode_crypt(fname,remusr,0)) )
3012               log_error("%s: encryption failed: %s\n",
3013                         print_fname_stdin(fname), g10_errstr(rc) );
3014           }
3015         break;
3016
3017       case aEncrSym:
3018         /* This works with PGP 8 in the sense that it acts just like a
3019            symmetric message.  It doesn't work at all with 2 or 6.  It
3020            might work with 7, but alas, I don't have a copy to test
3021            with right now. */
3022         if( argc > 1 )
3023           wrong_args(_("--symmetric --encrypt [filename]"));
3024         else if(opt.s2k_mode==0)
3025           log_error(_("you cannot use --symmetric --encrypt"
3026                       " with --s2k-mode 0\n"));
3027         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3028           log_error(_("you cannot use --symmetric --encrypt"
3029                       " while in %s mode\n"),compliance_option_string());
3030         else
3031           {
3032             if( (rc = encode_crypt(fname,remusr,1)) )
3033               log_error("%s: encryption failed: %s\n",
3034                         print_fname_stdin(fname), g10_errstr(rc) );
3035           }
3036         break;
3037
3038       case aSign: /* sign the given file */
3039         sl = NULL;
3040         if( detached_sig ) { /* sign all files */
3041             for( ; argc; argc--, argv++ )
3042                 add_to_strlist( &sl, *argv );
3043         }
3044         else {
3045             if( argc > 1 )
3046                 wrong_args(_("--sign [filename]"));
3047             if( argc ) {
3048                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
3049                 strcpy(sl->d, fname);
3050             }
3051         }
3052         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3053             log_error("signing failed: %s\n", g10_errstr(rc) );
3054         free_strlist(sl);
3055         break;
3056
3057       case aSignEncr: /* sign and encrypt the given file */
3058         if( argc > 1 )
3059             wrong_args(_("--sign --encrypt [filename]"));
3060         if( argc ) {
3061             sl = m_alloc_clear( sizeof *sl + strlen(fname));
3062             strcpy(sl->d, fname);
3063         }
3064         else
3065             sl = NULL;
3066         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3067             log_error("%s: sign+encrypt failed: %s\n",
3068                       print_fname_stdin(fname), g10_errstr(rc) );
3069         free_strlist(sl);
3070         break;
3071
3072       case aSignEncrSym: /* sign and encrypt the given file */
3073         if( argc > 1 )
3074             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3075         else if(opt.s2k_mode==0)
3076           log_error(_("you cannot use --symmetric --sign --encrypt"
3077                       " with --s2k-mode 0\n"));
3078         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3079           log_error(_("you cannot use --symmetric --sign --encrypt"
3080                       " while in %s mode\n"),compliance_option_string());
3081         else
3082           {
3083             if( argc )
3084               {
3085                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
3086                 strcpy(sl->d, fname);
3087               }
3088             else
3089               sl = NULL;
3090             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3091               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3092                         print_fname_stdin(fname), g10_errstr(rc) );
3093             free_strlist(sl);
3094           }
3095         break;
3096
3097       case aSignSym: /* sign and conventionally encrypt the given file */
3098         if (argc > 1)
3099             wrong_args(_("--sign --symmetric [filename]"));
3100         rc = sign_symencrypt_file (fname, locusr);
3101         if (rc)
3102             log_error("%s: sign+symmetric failed: %s\n",
3103                       print_fname_stdin(fname), g10_errstr(rc) );
3104         break;
3105
3106       case aClearsign: /* make a clearsig */
3107         if( argc > 1 )
3108             wrong_args(_("--clearsign [filename]"));
3109         if( (rc = clearsign_file(fname, locusr, NULL)) )
3110             log_error("%s: clearsign failed: %s\n",
3111                       print_fname_stdin(fname), g10_errstr(rc) );
3112         break;
3113
3114       case aVerify:
3115         if(multifile)
3116           {
3117             if( (rc = verify_files( argc, argv ) ))
3118               log_error("verify files failed: %s\n", g10_errstr(rc) );
3119           }
3120         else
3121           {
3122             if( (rc = verify_signatures( argc, argv ) ))
3123               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3124           }
3125         break;
3126
3127       case aDecrypt:
3128         if(multifile)
3129           decrypt_messages(argc, argv);
3130         else
3131           {
3132             if( argc > 1 )
3133               wrong_args(_("--decrypt [filename]"));
3134             if( (rc = decrypt_message( fname ) ))
3135               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3136           }
3137         break;
3138             
3139       case aSignKey:
3140         if( argc != 1 )
3141           wrong_args(_("--sign-key user-id"));
3142         /* fall through */
3143       case aLSignKey:
3144         if( argc != 1 )
3145           wrong_args(_("--lsign-key user-id"));
3146         /* fall through */
3147
3148         sl=NULL;
3149
3150         if(cmd==aSignKey)
3151           append_to_strlist(&sl,"sign");
3152         else if(cmd==aLSignKey)
3153           append_to_strlist(&sl,"lsign");
3154         else
3155           BUG();
3156
3157         append_to_strlist( &sl, "save" );
3158         username = make_username( fname );
3159         keyedit_menu(fname, locusr, sl, 0, 0 );
3160         m_free(username);
3161         free_strlist(sl);
3162         break;
3163
3164       case aEditKey: /* Edit a key signature */
3165         if( !argc )
3166             wrong_args(_("--edit-key user-id [commands]"));
3167         username = make_username( fname );
3168         if( argc > 1 ) {
3169             sl = NULL;
3170             for( argc--, argv++ ; argc; argc--, argv++ )
3171                 append_to_strlist( &sl, *argv );
3172             keyedit_menu( username, locusr, sl, 0, 1 );
3173             free_strlist(sl);
3174         }
3175         else
3176             keyedit_menu(username, locusr, NULL, 0, 1 );
3177         m_free(username);
3178         break;
3179
3180       case aDeleteKeys:
3181       case aDeleteSecretKeys:
3182       case aDeleteSecretAndPublicKeys:
3183         sl = NULL;
3184         /* I'm adding these in reverse order as add_to_strlist2
3185            reverses them again, and it's easier to understand in the
3186            proper order :) */
3187         for( ; argc; argc-- )
3188           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3189         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3190         free_strlist(sl);
3191         break;
3192
3193       case aCheckKeys:
3194         opt.check_sigs = 1;
3195       case aListSigs:
3196         opt.list_sigs = 1;
3197       case aListKeys:
3198         sl = NULL;
3199         for( ; argc; argc--, argv++ )
3200             add_to_strlist2( &sl, *argv, utf8_strings );
3201         public_key_list( sl );
3202         free_strlist(sl);
3203         break;
3204       case aListSecretKeys:
3205         sl = NULL;
3206         for( ; argc; argc--, argv++ )
3207             add_to_strlist2( &sl, *argv, utf8_strings );
3208         secret_key_list( sl );
3209         free_strlist(sl);
3210         break;
3211
3212       case aKMode: /* list keyring -- NOTE: This will be removed soon */
3213         if( argc < 2 ) { /* -kv [userid] */
3214             sl = NULL;
3215             if (argc && **argv)
3216                 add_to_strlist2( &sl, *argv, utf8_strings );
3217             public_key_list( sl );
3218             free_strlist(sl);
3219         }
3220         else if( argc == 2 ) { /* -kv userid keyring */
3221             if( access( argv[1], R_OK ) ) {
3222                 log_error(_("can't open `%s': %s\n"),
3223                                print_fname_stdin(argv[1]), strerror(errno));
3224             }
3225             else {
3226                 /* add keyring (default keyrings are not registered in this
3227                  * special case */
3228                 keydb_add_resource( argv[1], 0, 0 );
3229                 sl = NULL;
3230                 if (**argv)
3231                     add_to_strlist2( &sl, *argv, utf8_strings );
3232                 public_key_list( sl );
3233                 free_strlist(sl);
3234             }
3235         }
3236         else
3237             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3238         break;
3239
3240       case aKeygen: /* generate a key */
3241         if( opt.batch ) {
3242             if( argc > 1 )
3243                 wrong_args("--gen-key [parameterfile]");
3244             generate_keypair( argc? *argv : NULL, NULL, NULL );
3245         }
3246         else {
3247             if( argc )
3248                 wrong_args("--gen-key");
3249             generate_keypair(NULL, NULL, NULL);
3250         }
3251         break;
3252
3253       case aFastImport:
3254         opt.import_options |= IMPORT_FAST;
3255       case aImport:
3256         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3257         break;
3258
3259       case aExport:
3260       case aSendKeys:
3261       case aRecvKeys:
3262         sl = NULL;
3263         for( ; argc; argc--, argv++ )
3264             add_to_strlist2( &sl, *argv, utf8_strings );
3265         if( cmd == aSendKeys )
3266             rc=keyserver_export( sl );
3267         else if( cmd == aRecvKeys )
3268             rc=keyserver_import( sl );
3269         else
3270             rc=export_pubkeys( sl, opt.export_options );
3271         if(rc)
3272           {
3273             if(cmd==aSendKeys)
3274               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3275             else if(cmd==aRecvKeys)
3276               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3277             else
3278               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3279           }
3280         free_strlist(sl);
3281         break;
3282
3283      case aSearchKeys:
3284         sl = NULL;
3285         for( ; argc; argc--, argv++ )
3286           append_to_strlist2( &sl, *argv, utf8_strings );
3287         rc=keyserver_search( sl );
3288         if(rc)
3289           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3290         free_strlist(sl);
3291         break;
3292
3293       case aRefreshKeys:
3294         sl = NULL;
3295         for( ; argc; argc--, argv++ )
3296             add_to_strlist2( &sl, *argv, utf8_strings );
3297         rc=keyserver_refresh(sl);
3298         if(rc)
3299           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3300         free_strlist(sl);
3301         break;
3302
3303       case aExportSecret:
3304         sl = NULL;
3305         for( ; argc; argc--, argv++ )
3306             add_to_strlist2( &sl, *argv, utf8_strings );
3307         export_seckeys( sl );
3308         free_strlist(sl);
3309         break;
3310
3311       case aExportSecretSub:
3312         sl = NULL;
3313         for( ; argc; argc--, argv++ )
3314             add_to_strlist2( &sl, *argv, utf8_strings );
3315         export_secsubkeys( sl );
3316         free_strlist(sl);
3317         break;
3318
3319       case aGenRevoke:
3320         if( argc != 1 )
3321             wrong_args("--gen-revoke user-id");
3322         username =  make_username(*argv);
3323         gen_revoke( username );
3324         m_free( username );
3325         break;
3326
3327       case aDesigRevoke:
3328         if( argc != 1 )
3329             wrong_args("--desig-revoke user-id");
3330         username =  make_username(*argv);
3331         gen_desig_revoke( username );
3332         m_free( username );
3333         break;
3334
3335       case aDeArmor:
3336         if( argc > 1 )
3337             wrong_args("--dearmor [file]");
3338         rc = dearmor_file( argc? *argv: NULL );
3339         if( rc )
3340             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3341         break;
3342
3343       case aEnArmor:
3344         if( argc > 1 )
3345             wrong_args("--enarmor [file]");
3346         rc = enarmor_file( argc? *argv: NULL );
3347         if( rc )
3348             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3349         break;
3350
3351
3352       case aPrimegen:
3353         {   int mode = argc < 2 ? 0 : atoi(*argv);
3354
3355             if( mode == 1 && argc == 2 ) {
3356                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3357             }
3358             else if( mode == 2 && argc == 3 ) {
3359                 mpi_print( stdout, generate_elg_prime(
3360                                              0, atoi(argv[1]),
3361                                              atoi(argv[2]), NULL,NULL ), 1);
3362             }
3363             else if( mode == 3 && argc == 3 ) {
3364                 MPI *factors;
3365                 mpi_print( stdout, generate_elg_prime(
3366                                              1, atoi(argv[1]),
3367                                              atoi(argv[2]), NULL,&factors ), 1);
3368                 putchar('\n');
3369                 mpi_print( stdout, factors[0], 1 ); /* print q */
3370             }
3371             else if( mode == 4 && argc == 3 ) {
3372                 MPI g = mpi_alloc(1);
3373                 mpi_print( stdout, generate_elg_prime(
3374                                                  0, atoi(argv[1]),
3375                                                  atoi(argv[2]), g, NULL ), 1);
3376                 putchar('\n');
3377                 mpi_print( stdout, g, 1 );
3378                 mpi_free(g);
3379             }
3380             else
3381                 wrong_args("--gen-prime mode bits [qbits] ");
3382             putchar('\n');
3383         }
3384         break;
3385
3386       case aGenRandom:
3387         {
3388             int level = argc ? atoi(*argv):0;
3389             int count = argc > 1 ? atoi(argv[1]): 0;
3390             int endless = !count;
3391
3392             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3393                 wrong_args("--gen-random 0|1|2 [count]");
3394
3395             while( endless || count ) {
3396                 byte *p;
3397                 /* Wee need a multiple of 3, so that in case of
3398                    armored output we get a correct string.  No
3399                    linefolding is done, as it is best to levae this to
3400                    other tools */
3401                 size_t n = !endless && count < 99? count : 99;
3402
3403                 p = get_random_bits( n*8, level, 0);
3404 #ifdef HAVE_DOSISH_SYSTEM
3405                 setmode ( fileno(stdout), O_BINARY );
3406 #endif
3407                 if (opt.armor) {
3408                     char *tmp = make_radix64_string (p, n);
3409                     fputs (tmp, stdout);
3410                     m_free (tmp);
3411                     if (n%3 == 1)
3412                       putchar ('=');
3413                     if (n%3)
3414                       putchar ('=');
3415                 } else {
3416                     fwrite( p, n, 1, stdout );
3417                 }
3418                 m_free(p);
3419                 if( !endless )
3420                     count -= n;
3421             }
3422             if (opt.armor)
3423                 putchar ('\n');
3424         }
3425         break;
3426
3427       case aPrintMD:
3428         if( argc < 1)
3429             wrong_args("--print-md algo [files]");
3430         {
3431             int all_algos = (**argv=='*' && !(*argv)[1]);
3432             int algo = all_algos? 0 : string_to_digest_algo(*argv);
3433
3434             if( !algo && !all_algos )
3435                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3436             else {
3437                 argc--; argv++;
3438                 if( !argc )
3439                     print_mds(NULL, algo);
3440                 else {
3441                     for(; argc; argc--, argv++ )
3442                         print_mds(*argv, algo);
3443                 }
3444             }
3445         }
3446         break;
3447
3448       case aPrintMDs: /* old option */
3449         if( !argc )
3450             print_mds(NULL,0);
3451         else {
3452             for(; argc; argc--, argv++ )
3453                 print_mds(*argv,0);
3454         }
3455         break;
3456
3457       case aListTrustDB:
3458         if( !argc )
3459             list_trustdb(NULL);
3460         else {
3461             for( ; argc; argc--, argv++ )
3462                 list_trustdb( *argv );
3463         }
3464         break;
3465
3466       case aUpdateTrustDB:
3467         if( argc )
3468             wrong_args("--update-trustdb");
3469         update_trustdb();
3470         break;
3471
3472       case aCheckTrustDB:
3473         /* Old versions allowed for arguments - ignore them */
3474         check_trustdb();
3475         break;
3476
3477       case aFixTrustDB:
3478         log_error("this command is not yet implemented.\n");
3479         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3480         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3481         break;
3482
3483       case aListTrustPath:
3484         if( !argc )
3485             wrong_args("--list-trust-path <user-ids>");
3486         for( ; argc; argc--, argv++ ) {
3487             username = make_username( *argv );
3488             list_trust_path( username );
3489             m_free(username);
3490         }
3491         break;
3492
3493       case aExportOwnerTrust:
3494         if( argc )
3495             wrong_args("--export-ownertrust");
3496         export_ownertrust();
3497         break;
3498
3499       case aImportOwnerTrust:
3500         if( argc > 1 )
3501             wrong_args("--import-ownertrust [file]");
3502         import_ownertrust( argc? *argv:NULL );
3503         break;
3504       
3505       case aPipeMode:
3506         if ( argc )
3507             wrong_args ("--pipemode");
3508         run_in_pipemode ();
3509         break;
3510
3511       case aRebuildKeydbCaches:
3512         if (argc)
3513             wrong_args ("--rebuild-keydb-caches");
3514         keydb_rebuild_caches (1);
3515         break;
3516
3517 #ifdef ENABLE_CARD_SUPPORT
3518       case aCardStatus:
3519         if (argc)
3520             wrong_args ("--card-status");
3521         card_status (stdout, NULL, 0);
3522         break;
3523
3524       case aCardEdit:
3525         if (argc) {
3526             sl = NULL;
3527             for (argc--, argv++ ; argc; argc--, argv++)
3528                 append_to_strlist (&sl, *argv);
3529             card_edit (sl);
3530             free_strlist (sl);
3531         }
3532         else
3533             card_edit (NULL);
3534         break;
3535
3536       case aChangePIN:
3537         if (!argc)
3538             change_pin (0,1);
3539         else if (argc == 1)
3540             change_pin (atoi (*argv),1);
3541         else
3542         wrong_args ("--change-pin [no]");
3543         break;
3544 #endif /* ENABLE_CARD_SUPPORT*/
3545
3546       case aListConfig:
3547         {
3548           char *str=collapse_args(argc,argv);
3549           list_config(str);
3550           m_free(str);
3551         }
3552         break;
3553
3554       case aListPackets:
3555         opt.list_packets=2;
3556       default:
3557         if( argc > 1 )
3558             wrong_args(_("[filename]"));
3559         /* Issue some output for the unix newbie */
3560         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3561                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3562             log_info(_("Go ahead and type your message ...\n"));
3563
3564         a = iobuf_open(fname);
3565         if (a && is_secured_file (iobuf_get_fd (a)))
3566           {
3567             iobuf_close (a);
3568             a = NULL;
3569             errno = EPERM;
3570           }
3571         if( !a )
3572             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3573         else {
3574
3575             if( !opt.no_armor ) {
3576                 if( use_armor_filter( a ) ) {
3577                     memset( &afx, 0, sizeof afx);
3578                     iobuf_push_filter( a, armor_filter, &afx );
3579                 }
3580             }
3581             if( cmd == aListPackets ) {
3582                 set_packet_list_mode(1);
3583                 opt.list_packets=1;
3584             }
3585             rc = proc_packets(NULL, a );
3586             if( rc )
3587                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3588             iobuf_close(a);
3589         }
3590         break;
3591       }
3592
3593     /* cleanup */
3594     FREE_STRLIST(remusr);
3595     FREE_STRLIST(locusr);
3596     g10_exit(0);
3597     return 8; /*NEVER REACHED*/
3598 }
3599
3600
3601 void
3602 g10_exit( int rc )
3603 {
3604 #ifdef ENABLE_CARD_SUPPORT
3605     card_close ();
3606 #endif
3607     update_random_seed_file();
3608     if( opt.debug & DBG_MEMSTAT_VALUE ) {
3609         m_print_stats("on exit");
3610         random_dump_stats();
3611     }
3612     if( opt.debug )
3613         secmem_dump_stats();
3614     secmem_term();
3615     rc = rc? rc : log_get_errorcount(0)? 2 :
3616                         g10_errors_seen? 1 : 0;
3617     exit(rc );
3618 }
3619
3620
3621 /* Pretty-print hex hashes.  This assumes at least an 80-character
3622    display, but there are a few other similar assumptions in the
3623    display code. */
3624 static void
3625 print_hex( MD_HANDLE md, int algo, const char *fname )
3626 {
3627   int i,n,count,indent=0;
3628   const byte *p;
3629
3630   if(fname)
3631     indent=printf("%s: ",fname);
3632
3633   if(indent>40)
3634     {
3635       printf("\n");
3636       indent=0;
3637     }
3638
3639   if(algo==DIGEST_ALGO_RMD160)
3640     indent+=printf("RMD160 = ");
3641   else if(algo>0)
3642     indent+=printf("%6s = ",digest_algo_to_string(algo));
3643   else
3644     algo=abs(algo);
3645
3646   count=indent;
3647
3648   p = md_read( md, algo );
3649   n = md_digest_length(algo);
3650
3651   count+=printf("%02X",*p++);
3652
3653   for(i=1;i<n;i++,p++)
3654     {
3655       if(n==16)
3656         {
3657           if(count+2>79)
3658             {
3659               printf("\n%*s",indent," ");
3660               count=indent;
3661             }
3662           else
3663             count+=printf(" ");
3664
3665           if(!(i%8))
3666             count+=printf(" ");
3667         }
3668       else if (n==20)
3669         {
3670           if(!(i%2))
3671             {
3672               if(count+4>79)
3673                 {
3674                   printf("\n%*s",indent," ");
3675                   count=indent;
3676                 }
3677               else
3678                 count+=printf(" ");
3679             }
3680
3681           if(!(i%10))
3682             count+=printf(" ");
3683         }
3684       else
3685         {
3686           if(!(i%4))
3687             {
3688               if(count+8>79)
3689                 {
3690                   printf("\n%*s",indent," ");
3691                   count=indent;
3692                 }
3693               else
3694                 count+=printf(" ");
3695             }
3696         }
3697
3698       count+=printf("%02X",*p);
3699     }
3700
3701   printf("\n");
3702 }
3703
3704 static void
3705 print_hashline( MD_HANDLE md, int algo, const char *fname )
3706 {
3707     int i, n;
3708     const byte *p;
3709     
3710     if ( fname ) {
3711         for (p = fname; *p; p++ ) {
3712             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3713                 printf("%%%02X", *p );
3714             else 
3715                 putchar( *p );
3716         }
3717     }
3718     putchar(':');
3719     printf("%d:", algo );
3720     p = md_read( md, algo );
3721     n = md_digest_length(algo);
3722     for(i=0; i < n ; i++, p++ ) 
3723         printf("%02X", *p );
3724     putchar(':');
3725     putchar('\n');
3726 }
3727
3728 static void
3729 print_mds( const char *fname, int algo )
3730 {
3731     FILE *fp;
3732     char buf[1024];
3733     size_t n;
3734     MD_HANDLE md;
3735
3736     if( !fname ) {
3737         fp = stdin;
3738 #ifdef HAVE_DOSISH_SYSTEM
3739         setmode ( fileno(fp) , O_BINARY );
3740 #endif
3741     }
3742     else {
3743         fp = fopen( fname, "rb" );
3744         if (fp && is_secured_file (fileno (fp)))
3745           {
3746             fclose (fp);
3747             fp = NULL;
3748             errno = EPERM;
3749           }
3750     }
3751     if( !fp ) {
3752         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3753         return;
3754     }
3755
3756     md = md_open( 0, 0 );
3757     if( algo )
3758         md_enable( md, algo );
3759     else {
3760         md_enable( md, DIGEST_ALGO_MD5 );
3761         md_enable( md, DIGEST_ALGO_SHA1 );
3762         md_enable( md, DIGEST_ALGO_RMD160 );
3763 #ifdef USE_SHA256
3764         md_enable( md, DIGEST_ALGO_SHA256 );
3765 #endif
3766 #ifdef USE_SHA512
3767         md_enable( md, DIGEST_ALGO_SHA384 );
3768         md_enable( md, DIGEST_ALGO_SHA512 );
3769 #endif
3770     }
3771
3772     while( (n=fread( buf, 1, DIM(buf), fp )) )
3773         md_write( md, buf, n );
3774     if( ferror(fp) )
3775         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3776     else {
3777         md_final(md);
3778         if ( opt.with_colons ) {
3779             if ( algo ) 
3780                 print_hashline( md, algo, fname );
3781             else {
3782                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3783                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3784                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3785 #ifdef USE_SHA256
3786                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3787 #endif
3788 #ifdef USE_SHA512
3789                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3790                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3791 #endif
3792             }
3793         }
3794         else {
3795             if( algo )
3796                print_hex(md,-algo,fname);
3797             else {
3798                 print_hex( md, DIGEST_ALGO_MD5, fname );
3799                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3800                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3801 #ifdef USE_SHA256
3802                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3803 #endif
3804 #ifdef USE_SHA512
3805                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3806                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3807 #endif
3808             }
3809         }
3810     }
3811     md_close(md);
3812
3813     if( fp != stdin )
3814         fclose(fp);
3815 }
3816
3817
3818 /****************
3819  * Check the supplied name,value string and add it to the notation
3820  * data to be used for signatures.  which==0 for sig notations, and 1
3821  * for cert notations.
3822 */
3823 static void
3824 add_notation_data( const char *string, int which )
3825 {
3826     const char *s;
3827     STRLIST sl,*notation_data;
3828     int critical=0;
3829     int highbit=0;
3830     int saw_at=0;
3831
3832     if(which)
3833       notation_data=&opt.cert_notation_data;
3834     else
3835       notation_data=&opt.sig_notation_data;
3836
3837     if( *string == '!' ) {
3838         critical = 1;
3839         string++;
3840     }
3841
3842     /* If and when the IETF assigns some official name tags, we'll
3843        have to add them here. */
3844
3845     for( s=string ; *s != '='; s++ )
3846       {
3847         if( *s=='@')
3848           saw_at=1;
3849
3850         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3851           {
3852             log_error(_("a notation name must have only printable characters "
3853                         "or spaces, and end with an '='\n") );
3854             return;
3855           }
3856       }
3857
3858     if(!saw_at && !opt.expert)
3859       {
3860         log_error(_("a user notation name must contain the '@' character\n"));
3861         return;
3862       }
3863
3864     /* we only support printable text - therefore we enforce the use
3865      * of only printable characters (an empty value is valid) */
3866     for( s++; *s ; s++ ) {
3867         if ((*s & 0x80))
3868           highbit = 1;
3869         else if (iscntrl(*s)) {
3870             log_error(_("a notation value must not use"
3871                         " any control characters\n") );
3872             return;
3873         }
3874     }
3875
3876     if( highbit )   /* must use UTF8 encoding */
3877         sl = add_to_strlist2( notation_data, string, utf8_strings );
3878     else
3879         sl = add_to_strlist( notation_data, string );
3880
3881     if( critical )
3882         sl->flags |= 1;
3883 }
3884
3885 static void
3886 add_policy_url( const char *string, int which )
3887 {
3888   unsigned int i,critical=0;
3889   STRLIST sl;
3890
3891   if(*string=='!')
3892     {
3893       string++;
3894       critical=1;
3895     }
3896
3897   for(i=0;i<strlen(string);i++)
3898     if(string[i]&0x80 || iscntrl(string[i]))
3899       break;
3900
3901   if(i==0 || i<strlen(string))
3902     {
3903       if(which)
3904         log_error(_("the given certification policy URL is invalid\n"));
3905       else
3906         log_error(_("the given signature policy URL is invalid\n"));
3907     }
3908
3909   if(which)
3910     sl=add_to_strlist( &opt.cert_policy_url, string );
3911   else
3912     sl=add_to_strlist( &opt.sig_policy_url, string );
3913
3914   if(critical)
3915     sl->flags |= 1;    
3916 }
3917
3918 static void
3919 add_keyserver_url( const char *string, int which )
3920 {
3921   unsigned int i,critical=0;
3922   STRLIST sl;
3923
3924   if(*string=='!')
3925     {
3926       string++;
3927       critical=1;
3928     }
3929
3930   for(i=0;i<strlen(string);i++)
3931     if(string[i]&0x80 || iscntrl(string[i]))
3932       break;
3933
3934   if(i==0 || i<strlen(string))
3935     {
3936       if(which)
3937         BUG();
3938       else
3939         log_error(_("the given preferred keyserver URL is invalid\n"));
3940     }
3941
3942   if(which)
3943     BUG();
3944   else
3945     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3946
3947   if(critical)
3948     sl->flags |= 1;    
3949 }