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