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