5dff5768af6e057835fb12b009aee661bf0d5288
[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: add_to_strlist(&opt.comments,pargs.r.ret_str); break;
1662           case oDefaultComment:
1663             deprecated_warning(configname,configlineno,
1664                                "--default-comment","--no-comments","");
1665             /* fall through */
1666           case oNoComments:
1667             free_strlist(opt.comments);
1668             opt.comments=NULL;
1669             break;
1670           case oThrowKeyid: opt.throw_keyid = 1; break;
1671           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1672           case oShowPhotos:
1673             deprecated_warning(configname,configlineno,"--show-photos",
1674                                "--list-options ","show-photos");
1675             deprecated_warning(configname,configlineno,"--show-photos",
1676                                "--verify-options ","show-photos");
1677             opt.list_options|=LIST_SHOW_PHOTOS;
1678             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1679             break;
1680           case oNoShowPhotos:
1681             deprecated_warning(configname,configlineno,"--no-show-photos",
1682                                "--list-options ","no-show-photos");
1683             deprecated_warning(configname,configlineno,"--no-show-photos",
1684                                "--verify-options ","no-show-photos");
1685             opt.list_options&=~LIST_SHOW_PHOTOS;
1686             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1687             break;
1688           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1689           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1690           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1691           case oForceV4Certs: opt.force_v4_certs = 1; break;
1692           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1693           case oForceMDC: opt.force_mdc = 1; break;
1694           case oNoForceMDC: opt.force_mdc = 0; break;
1695           case oDisableMDC: opt.disable_mdc = 1; break;
1696           case oNoDisableMDC: opt.disable_mdc = 0; break;
1697           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1698           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1699           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1700           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1701           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1702           case oEncryptTo: /* store the recipient in the second list */
1703             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1704             sl->flags = 1;
1705             break;
1706           case oHiddenEncryptTo: /* store the recipient in the second list */
1707             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1708             sl->flags = 1|2;
1709             break;
1710           case oRecipient: /* store the recipient */
1711             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1712             any_explicit_recipient = 1;
1713             break;
1714           case oHiddenRecipient: /* store the recipient with a flag */
1715             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1716             sl->flags = 2;
1717             any_explicit_recipient = 1;
1718             break;
1719           case oTextmodeShort: opt.textmode = 2; break;
1720           case oTextmode: opt.textmode=1;  break;
1721           case oNoTextmode: opt.textmode=0;  break;
1722           case oExpert: opt.expert = 1; break;
1723           case oNoExpert: opt.expert = 0; break;
1724           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1725           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1726           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1727           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1728           case oUser: /* store the local users */
1729             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1730             break;
1731           case oCompress: opt.compress = pargs.r.ret_int; break;
1732           case oPasswdFD:
1733             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1734             opt.use_agent = 0;
1735             break;
1736 #ifdef __riscos__
1737           case oPasswdFile:
1738             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1739             break;
1740 #endif /* __riscos__ */
1741           case oCommandFD:
1742             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1743             break;
1744 #ifdef __riscos__
1745           case oCommandFile:
1746             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1747             break;
1748 #endif /* __riscos__ */
1749           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1750           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1751           case oCompressAlgo:
1752             /* If it is all digits, stick a Z in front of it for
1753                later.  This is for backwards compatibility with
1754                versions that took the compress algorithm number. */
1755             {
1756               char *pt=pargs.r.ret_str;
1757               while(*pt)
1758                 {
1759                   if(!isdigit(*pt))
1760                     break;
1761
1762                   pt++;
1763                 }
1764
1765               if(*pt=='\0')
1766                 {
1767                   def_compress_string=m_alloc(strlen(pargs.r.ret_str)+2);
1768                   strcpy(def_compress_string,"Z");
1769                   strcat(def_compress_string,pargs.r.ret_str);
1770                 }
1771               else
1772                 def_compress_string = m_strdup(pargs.r.ret_str);
1773             }
1774             break;
1775           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1776           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1777           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1778           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1779           case oCharset:
1780             if( set_native_charset( pargs.r.ret_str ) )
1781                 log_error(_("%s is not a valid character set\n"),
1782                                                     pargs.r.ret_str);
1783             break;
1784           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1785           case oEscapeFrom: opt.escape_from = 1; break;
1786           case oNoEscapeFrom: opt.escape_from = 0; break;
1787           case oLockOnce: opt.lock_once = 1; break;
1788           case oLockNever: disable_dotlock(); break;
1789           case oLockMultiple:
1790 #ifndef __riscos__
1791             opt.lock_once = 0;
1792 #else /* __riscos__ */
1793             riscos_not_implemented("lock-multiple");
1794 #endif /* __riscos__ */
1795             break;
1796           case oKeyServer:
1797             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1798             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1799               log_error(_("could not parse keyserver URI\n"));
1800             break;
1801           case oKeyServerOptions:
1802             parse_keyserver_options(pargs.r.ret_str);
1803             break;
1804           case oImportOptions:
1805             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1806               {
1807                 if(configname)
1808                   log_error(_("%s:%d: invalid import options\n"),
1809                             configname,configlineno);
1810                 else
1811                   log_error(_("invalid import options\n"));
1812               }
1813             break;
1814           case oExportOptions:
1815             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1816               {
1817                 if(configname)
1818                   log_error(_("%s:%d: invalid export options\n"),
1819                             configname,configlineno);
1820                 else
1821                   log_error(_("invalid export options\n"));
1822               }
1823             break;
1824           case oListOptions:
1825             {
1826               struct parse_options lopts[]=
1827                 {
1828                   {"show-photos",LIST_SHOW_PHOTOS},
1829                   {"show-policy-url",LIST_SHOW_POLICY},
1830                   {"show-notation",LIST_SHOW_NOTATION},
1831                   {"show-keyserver-url",LIST_SHOW_KEYSERVER},
1832                   {"show-validity",LIST_SHOW_VALIDITY},
1833                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1834                   {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS},
1835                   {"show-keyring",LIST_SHOW_KEYRING},
1836                   {"show-sig-expire",LIST_SHOW_SIG_EXPIRE},
1837                   {NULL,0}
1838                 };
1839
1840               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1841                 {
1842                   if(configname)
1843                     log_error(_("%s:%d: invalid list options\n"),
1844                               configname,configlineno);
1845                   else
1846                     log_error(_("invalid list options\n"));
1847                 }
1848             }
1849             break;
1850           case oVerifyOptions:
1851             {
1852               struct parse_options vopts[]=
1853                 {
1854                   {"show-photos",VERIFY_SHOW_PHOTOS},
1855                   {"show-policy-url",VERIFY_SHOW_POLICY},
1856                   {"show-notation",VERIFY_SHOW_NOTATION},
1857                   {"show-keyserver-url",VERIFY_SHOW_KEYSERVER},
1858                   {"show-validity",VERIFY_SHOW_VALIDITY},
1859                   {"show-long-keyid",VERIFY_SHOW_LONG_KEYID},
1860                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS},
1861                   {NULL,0}
1862                 };
1863
1864               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1865                 {
1866                   if(configname)
1867                     log_error(_("%s:%d: invalid verify options\n"),
1868                               configname,configlineno);
1869                   else
1870                     log_error(_("invalid verify options\n"));
1871                 }
1872             }
1873             break;
1874           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1875           case oExecPath:
1876             if(set_exec_path(pargs.r.ret_str,0))
1877               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1878             else
1879               opt.exec_path_set=1;
1880             break;
1881           case oSetNotation:
1882             add_notation_data( pargs.r.ret_str, 0 );
1883             add_notation_data( pargs.r.ret_str, 1 );
1884             break;
1885           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1886           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1887           case oShowNotation:
1888             deprecated_warning(configname,configlineno,"--show-notation",
1889                                "--list-options ","show-notation");
1890             deprecated_warning(configname,configlineno,"--show-notation",
1891                                "--verify-options ","show-notation");
1892             opt.list_options|=LIST_SHOW_NOTATION;
1893             opt.verify_options|=VERIFY_SHOW_NOTATION;
1894             break;
1895           case oNoShowNotation:
1896             deprecated_warning(configname,configlineno,"--no-show-notation",
1897                                "--list-options ","no-show-notation");
1898             deprecated_warning(configname,configlineno,"--no-show-notation",
1899                                "--verify-options ","no-show-notation");
1900             opt.list_options&=~LIST_SHOW_NOTATION;
1901             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1902             break;
1903           case oUtf8Strings: utf8_strings = 1; break;
1904           case oNoUtf8Strings: utf8_strings = 0; break;
1905           case oDisableCipherAlgo:
1906                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1907                 break;
1908           case oDisablePubkeyAlgo:
1909                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1910                 break;
1911           case oNoSigCache: opt.no_sig_cache = 1; break;
1912           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1913           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1914           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1915           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1916           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1917           case oNoLiteral: opt.no_literal = 1; break;
1918           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1919           case oHonorHttpProxy:
1920                 opt.keyserver_options.honor_http_proxy = 1;
1921                 deprecated_warning(configname,configlineno,
1922                                    "--honor-http-proxy",
1923                                    "--keyserver-options ",
1924                                    "honor-http-proxy");
1925                 break;
1926           case oFastListMode: opt.fast_list_mode = 1; break;
1927           case oFixedListMode: opt.fixed_list_mode = 1; break;
1928           case oListOnly: opt.list_only=1; break;
1929           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1930           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1931           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1932           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1933           case oNoRandomSeedFile: use_random_seed = 0; break;
1934           case oAutoKeyRetrieve:
1935           case oNoAutoKeyRetrieve:
1936                 opt.keyserver_options.auto_key_retrieve=
1937                                              (pargs.r_opt==oAutoKeyRetrieve);
1938                 deprecated_warning(configname,configlineno,
1939                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1940                                "--no-auto-key-retrieve","--keyserver-options ",
1941                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1942                                "no-auto-key-retrieve");
1943                 break;
1944           case oShowSessionKey: opt.show_session_key = 1; break;
1945           case oOverrideSessionKey:
1946                 opt.override_session_key = pargs.r.ret_str;
1947                 break;
1948           case oMergeOnly: opt.merge_only = 1; break;
1949           case oAllowSecretKeyImport: /* obsolete */ break;
1950           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1951           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1952           case oEnableSpecialFilenames:
1953             iobuf_enable_special_filenames (1);
1954             break;
1955           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1956           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1957           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1958           case oPreservePermissions: opt.preserve_permissions=1; break;
1959           case oDefaultPreferenceList:
1960             opt.def_preference_list = pargs.r.ret_str;
1961             break;
1962           case oPersonalCipherPreferences:
1963             pers_cipher_list=pargs.r.ret_str;
1964             break;
1965           case oPersonalDigestPreferences:
1966             pers_digest_list=pargs.r.ret_str;
1967             break;
1968           case oPersonalCompressPreferences:
1969             pers_compress_list=pargs.r.ret_str;
1970             break;
1971           case oDisplay: opt.display = pargs.r.ret_str; break;
1972           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1973           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1974           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1975           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1976           case oGroup: add_group(pargs.r.ret_str); break;
1977           case oNoGroups:
1978             while(opt.grouplist)
1979               {
1980                 struct groupitem *iter=opt.grouplist;
1981                 free_strlist(iter->values);
1982                 opt.grouplist=opt.grouplist->next;
1983                 m_free(iter);
1984               }
1985             break;
1986           case oStrict: opt.strict=1; log_set_strict(1); break;
1987           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1988           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1989           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1990           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1991           case oMultifile: multifile=1; break;
1992
1993           default : pargs.err = configfp? 1:2; break;
1994           }
1995       }
1996
1997     if( configfp ) {
1998         fclose( configfp );
1999         configfp = NULL;
2000         m_free(configname); configname = NULL;
2001         goto next_pass;
2002     }
2003     m_free( configname ); configname = NULL;
2004     if( log_get_errorcount(0) )
2005         g10_exit(2);
2006     if( nogreeting )
2007         greeting = 0;
2008
2009     if( greeting ) {
2010         fprintf(stderr, "%s %s; %s\n",
2011                         strusage(11), strusage(13), strusage(14) );
2012         fprintf(stderr, "%s\n", strusage(15) );
2013     }
2014 #ifdef IS_DEVELOPMENT_VERSION
2015     if( !opt.batch ) {
2016         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
2017         log_info("It is only intended for test purposes and should NOT be\n");
2018         log_info("used in a production environment or with production keys!\n");
2019     }
2020 #endif
2021
2022     if (opt.verbose > 2)
2023         log_info ("using character set `%s'\n", get_native_charset ());
2024
2025     if( may_coredump && !opt.quiet )
2026         log_info(_("WARNING: program may create a core file!\n"));
2027
2028     if (eyes_only) {
2029       if (opt.set_filename)
2030           log_info(_("WARNING: %s overrides %s\n"),
2031                    "--for-your-eyes-only","--set-filename");
2032
2033       opt.set_filename="_CONSOLE";
2034     }
2035
2036     if (opt.no_literal) {
2037         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2038         if (opt.textmode)
2039             log_error(_("%s not allowed with %s!\n"),
2040                        "--textmode", "--no-literal" );
2041         if (opt.set_filename)
2042             log_error(_("%s makes no sense with %s!\n"),
2043                         eyes_only?"--for-your-eyes-only":"--set-filename",
2044                         "--no-literal" );
2045     }
2046
2047     if (opt.set_filesize)
2048         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2049     if( opt.batch )
2050         tty_batchmode( 1 );
2051
2052     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2053
2054     set_debug();
2055
2056     /* Do these after the switch(), so they can override settings. */
2057     if(PGP2)
2058       {
2059         int unusable=0;
2060
2061         if(cmd==aSign && !detached_sig)
2062           {
2063             log_info(_("you can only make detached or clear signatures "
2064                        "while in --pgp2 mode\n"));
2065             unusable=1;
2066           }
2067         else if(cmd==aSignEncr || cmd==aSignSym)
2068           {
2069             log_info(_("you can't sign and encrypt at the "
2070                        "same time while in --pgp2 mode\n"));
2071             unusable=1;
2072           }
2073         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2074           {
2075             log_info(_("you must use files (and not a pipe) when "
2076                        "working with --pgp2 enabled.\n"));
2077             unusable=1;
2078           }
2079         else if(cmd==aEncr || cmd==aSym)
2080           {
2081             /* Everything else should work without IDEA (except using
2082                a secret key encrypted with IDEA and setting an IDEA
2083                preference, but those have their own error
2084                messages). */
2085
2086             if(check_cipher_algo(CIPHER_ALGO_IDEA))
2087               {
2088                 log_info(_("encrypting a message in --pgp2 mode requires "
2089                            "the IDEA cipher\n"));
2090                 idea_cipher_warn(1);
2091                 unusable=1;
2092               }
2093             else if(cmd==aSym)
2094               {
2095                 /* This only sets IDEA for symmetric encryption
2096                    since it is set via select_algo_from_prefs for
2097                    pk encryption. */
2098                 m_free(def_cipher_string);
2099                 def_cipher_string = m_strdup("idea");
2100               }
2101
2102             /* PGP2 can't handle the output from the textmode
2103                filter, so we disable it for anything that could
2104                create a literal packet (only encryption and
2105                symmetric encryption, since we disable signing
2106                above). */
2107             if(!unusable)
2108               opt.textmode=0;
2109           }
2110
2111         if(unusable)
2112           compliance_failure();
2113         else
2114           {
2115             opt.force_v4_certs = 0;
2116             opt.sk_comments = 0;
2117             opt.escape_from = 1;
2118             opt.force_v3_sigs = 1;
2119             opt.pgp2_workarounds = 1;
2120             opt.ask_sig_expire = 0;
2121             opt.ask_cert_expire = 0;
2122             m_free(def_digest_string);
2123             def_digest_string = m_strdup("md5");
2124             opt.def_compress_algo = 1;
2125           }
2126       }
2127     else if(PGP6)
2128       {
2129         opt.sk_comments=0;
2130         opt.escape_from=1;
2131         opt.force_v3_sigs=1;
2132         opt.ask_sig_expire=0;
2133       }
2134     else if(PGP7)
2135       {
2136         opt.sk_comments=0;
2137         opt.escape_from=1;
2138         opt.force_v3_sigs=1;
2139         opt.ask_sig_expire=0;
2140       }
2141     else if(PGP8)
2142       {
2143         opt.escape_from=1;
2144       }
2145
2146     /* must do this after dropping setuid, because string_to...
2147      * may try to load an module */
2148     if( def_cipher_string ) {
2149         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
2150         if(opt.def_cipher_algo==0 &&
2151            (ascii_strcasecmp(def_cipher_string,"idea")==0
2152             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2153           idea_cipher_warn(1);
2154         m_free(def_cipher_string); def_cipher_string = NULL;
2155         if( check_cipher_algo(opt.def_cipher_algo) )
2156             log_error(_("selected cipher algorithm is invalid\n"));
2157     }
2158     if( def_digest_string ) {
2159         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
2160         m_free(def_digest_string); def_digest_string = NULL;
2161         if( check_digest_algo(opt.def_digest_algo) )
2162             log_error(_("selected digest algorithm is invalid\n"));
2163     }
2164     if( def_compress_string ) {
2165         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2166         m_free(def_compress_string); def_compress_string = NULL;
2167         if( check_compress_algo(opt.def_compress_algo) )
2168             log_error(_("selected compression algorithm is invalid\n"));
2169     }
2170     if( cert_digest_string ) {
2171         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
2172         m_free(cert_digest_string); cert_digest_string = NULL;
2173         if( check_digest_algo(opt.cert_digest_algo) )
2174             log_error(_("selected certification digest algorithm is invalid\n"));
2175     }
2176     if( s2k_cipher_string ) {
2177         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
2178         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
2179         if( check_cipher_algo(opt.s2k_cipher_algo) )
2180             log_error(_("selected cipher algorithm is invalid\n"));
2181     }
2182     if( s2k_digest_string ) {
2183         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
2184         m_free(s2k_digest_string); s2k_digest_string = NULL;
2185         if( check_digest_algo(opt.s2k_digest_algo) )
2186             log_error(_("selected digest algorithm is invalid\n"));
2187     }
2188     if( opt.completes_needed < 1 )
2189         log_error(_("completes-needed must be greater than 0\n"));
2190     if( opt.marginals_needed < 2 )
2191         log_error(_("marginals-needed must be greater than 1\n"));
2192     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2193         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2194     switch( opt.s2k_mode ) {
2195       case 0:
2196         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2197         break;
2198       case 1: case 3: break;
2199       default:
2200         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2201     }
2202
2203     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2204       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2205
2206     /* This isn't actually needed, but does serve to error out if the
2207        string is invalid. */
2208     if(opt.def_preference_list &&
2209         keygen_set_std_prefs(opt.def_preference_list,0))
2210       log_error(_("invalid default preferences\n"));
2211
2212     /* We provide defaults for the personal digest list */
2213     if(!pers_digest_list)
2214       pers_digest_list="h2";
2215
2216     if(pers_cipher_list &&
2217        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2218       log_error(_("invalid personal cipher preferences\n"));
2219
2220     if(pers_digest_list &&
2221        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2222       log_error(_("invalid personal digest preferences\n"));
2223
2224     if(pers_compress_list &&
2225        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2226       log_error(_("invalid personal compress preferences\n"));
2227
2228     /* We don't support all possible commands with multifile yet */
2229     if(multifile)
2230       {
2231         char *cmdname;
2232
2233         switch(cmd)
2234           {
2235           case aSign:
2236             cmdname="--sign";
2237             break;
2238           case aClearsign:
2239             cmdname="--clearsign";
2240             break;
2241           case aDetachedSign:
2242             cmdname="--detach-sign";
2243             break;
2244           case aSym:
2245             cmdname="--symmetric";
2246             break;
2247           case aStore:
2248             cmdname="--store";
2249             break;
2250           default:
2251             cmdname=NULL;
2252             break;
2253           }
2254
2255         if(cmdname)
2256           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2257       }
2258
2259     if( log_get_errorcount(0) )
2260         g10_exit(2);
2261
2262     /* Check our chosen algorithms against the list of legal
2263        algorithms. */
2264
2265     if(!GNUPG)
2266       {
2267         const char *badalg=NULL;
2268         preftype_t badtype=PREFTYPE_NONE;
2269
2270         if(opt.def_cipher_algo
2271            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2272           {
2273             badalg=cipher_algo_to_string(opt.def_cipher_algo);
2274             badtype=PREFTYPE_SYM;
2275           }
2276         else if(opt.def_digest_algo
2277                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2278           {
2279             badalg=digest_algo_to_string(opt.def_digest_algo);
2280             badtype=PREFTYPE_HASH;
2281           }
2282         else if(opt.cert_digest_algo
2283                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2284           {
2285             badalg=digest_algo_to_string(opt.cert_digest_algo);
2286             badtype=PREFTYPE_HASH;
2287           }
2288         else if(opt.def_compress_algo!=-1
2289                 && !algo_available(PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2290           {
2291             badalg=compress_algo_to_string(opt.def_compress_algo);
2292             badtype=PREFTYPE_ZIP;
2293           }
2294
2295         if(badalg)
2296           {
2297             switch(badtype)
2298               {
2299               case PREFTYPE_SYM:
2300                 log_info(_("you may not use cipher algorithm \"%s\" "
2301                            "while in %s mode\n"),
2302                          badalg,compliance_option_string());
2303                 break;
2304               case PREFTYPE_HASH:
2305                 log_info(_("you may not use digest algorithm \"%s\" "
2306                            "while in %s mode\n"),
2307                          badalg,compliance_option_string());
2308                 break;
2309               case PREFTYPE_ZIP:
2310                 log_info(_("you may not use compression algorithm \"%s\" "
2311                            "while in %s mode\n"),
2312                          badalg,compliance_option_string());
2313                 break;
2314               default:
2315                 BUG();
2316               }
2317
2318             compliance_failure();
2319           }
2320       }
2321
2322     /* set the random seed file */
2323     if( use_random_seed ) {
2324         char *p = make_filename(opt.homedir, "random_seed", NULL );
2325         set_random_seed_file(p);
2326         m_free(p);
2327     }
2328
2329     if( !cmd && opt.fingerprint && !with_fpr ) {
2330         set_cmd( &cmd, aListKeys);
2331     }
2332
2333     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2334         if( cmd == aKModeC ) {
2335             opt.fingerprint = 1;
2336             cmd = aKMode;
2337         }
2338         opt.list_sigs = 0;
2339         if( opt.verbose > 2 )
2340             opt.check_sigs++;
2341         if( opt.verbose > 1 )
2342             opt.list_sigs++;
2343
2344         opt.verbose = opt.verbose > 1;
2345         g10_opt_verbose = opt.verbose;
2346     }
2347
2348     /* Compression algorithm 0 means no compression at all */
2349     if( opt.def_compress_algo == 0)
2350         opt.compress = 0;
2351
2352     /* kludge to let -sat generate a clear text signature */
2353     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2354         cmd = aClearsign;
2355
2356     if( opt.verbose > 1 )
2357         set_packet_list_mode(1);
2358
2359     /* Add the keyrings, but not for some special commands and not in
2360        case of "-kvv userid keyring".  Also avoid adding the secret
2361        keyring for a couple of commands to avoid unneeded access in
2362        case the secrings are stored on a floppy */
2363     if( cmd != aDeArmor && cmd != aEnArmor
2364         && !(cmd == aKMode && argc == 2 ) ) 
2365       {
2366         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2367             && cmd != aVerify && cmd != aSym)
2368           {
2369             if (!sec_nrings || default_keyring) /* add default secret rings */
2370               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2371             for (sl = sec_nrings; sl; sl = sl->next)
2372               keydb_add_resource ( sl->d, 0, 1 );
2373           }
2374         if( !nrings || default_keyring )  /* add default ring */
2375             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2376         for(sl = nrings; sl; sl = sl->next )
2377             keydb_add_resource ( sl->d, sl->flags, 0 );
2378       }
2379     FREE_STRLIST(nrings);
2380     FREE_STRLIST(sec_nrings);
2381
2382
2383     if( pwfd != -1 )  /* read the passphrase now. */
2384         read_passphrase_from_fd( pwfd );
2385
2386     fname = argc? *argv : NULL;
2387
2388     switch( cmd ) {
2389       case aPrimegen:
2390       case aPrintMD:
2391       case aPrintMDs:
2392       case aGenRandom:
2393       case aDeArmor:
2394       case aEnArmor:
2395       case aFixTrustDB:
2396         break;
2397       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2398       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2399       default: rc = setup_trustdb(1, trustdb_name ); break;
2400     }
2401     if( rc )
2402         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
2403
2404
2405     switch (cmd) {
2406       case aStore: 
2407       case aSym:  
2408       case aSign: 
2409       case aSignSym: 
2410       case aClearsign: 
2411         if (!opt.quiet && any_explicit_recipient)
2412           log_info (_("WARNING: recipients (-r) given "
2413                       "without using public key encryption\n"));
2414         break;
2415       default:
2416         break;
2417     }
2418
2419     switch( cmd ) {
2420       case aStore: /* only store the file */
2421         if( argc > 1 )
2422             wrong_args(_("--store [filename]"));
2423         if( (rc = encode_store(fname)) )
2424             log_error_f( print_fname_stdin(fname),
2425                         "store failed: %s\n", g10_errstr(rc) );
2426         break;
2427       case aSym: /* encrypt the given file only with the symmetric cipher */
2428         if( argc > 1 )
2429             wrong_args(_("--symmetric [filename]"));
2430         if( (rc = encode_symmetric(fname)) )
2431             log_error_f(print_fname_stdin(fname),
2432                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
2433         break;
2434
2435       case aEncr: /* encrypt the given file */
2436         if(multifile)
2437           encode_crypt_files(argc, argv, remusr);
2438         else
2439           {
2440             if( argc > 1 )
2441               wrong_args(_("--encrypt [filename]"));
2442             if( (rc = encode_crypt(fname,remusr)) )
2443               log_error("%s: encryption failed: %s\n",
2444                         print_fname_stdin(fname), g10_errstr(rc) );
2445           }
2446         break;
2447           
2448       case aSign: /* sign the given file */
2449         sl = NULL;
2450         if( detached_sig ) { /* sign all files */
2451             for( ; argc; argc--, argv++ )
2452                 add_to_strlist( &sl, *argv );
2453         }
2454         else {
2455             if( argc > 1 )
2456                 wrong_args(_("--sign [filename]"));
2457             if( argc ) {
2458                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
2459                 strcpy(sl->d, fname);
2460             }
2461         }
2462         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2463             log_error("signing failed: %s\n", g10_errstr(rc) );
2464         free_strlist(sl);
2465         break;
2466
2467       case aSignEncr: /* sign and encrypt the given file */
2468         if( argc > 1 )
2469             wrong_args(_("--sign --encrypt [filename]"));
2470         if( argc ) {
2471             sl = m_alloc_clear( sizeof *sl + strlen(fname));
2472             strcpy(sl->d, fname);
2473         }
2474         else
2475             sl = NULL;
2476         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2477             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
2478         free_strlist(sl);
2479         break;
2480
2481       case aSignSym: /* sign and conventionally encrypt the given file */
2482         if (argc > 1)
2483             wrong_args(_("--sign --symmetric [filename]"));
2484         rc = sign_symencrypt_file (fname, locusr);
2485         if (rc)
2486             log_error("%s: sign+symmetric failed: %s\n",
2487                       print_fname_stdin(fname), g10_errstr(rc) );
2488         break;
2489
2490       case aClearsign: /* make a clearsig */
2491         if( argc > 1 )
2492             wrong_args(_("--clearsign [filename]"));
2493         if( (rc = clearsign_file(fname, locusr, NULL)) )
2494             log_error("%s: clearsign failed: %s\n",
2495                       print_fname_stdin(fname), g10_errstr(rc) );
2496         break;
2497
2498       case aVerify:
2499         if(multifile)
2500           {
2501             if( (rc = verify_files( argc, argv ) ))
2502               log_error("verify files failed: %s\n", g10_errstr(rc) );
2503           }
2504         else
2505           {
2506             if( (rc = verify_signatures( argc, argv ) ))
2507               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
2508           }
2509         break;
2510
2511       case aDecrypt:
2512         if(multifile)
2513           decrypt_messages(argc, argv);
2514         else
2515           {
2516             if( argc > 1 )
2517               wrong_args(_("--decrypt [filename]"));
2518             if( (rc = decrypt_message( fname ) ))
2519               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
2520           }
2521         break;
2522             
2523       case aSignKey: /* sign the key given as argument */
2524         if( argc != 1 )
2525             wrong_args(_("--sign-key user-id"));
2526         username = make_username( fname );
2527         keyedit_menu(fname, locusr, NULL, 1 );
2528         m_free(username);
2529         break;
2530
2531       case aLSignKey:
2532         if( argc != 1 )
2533             wrong_args(_("--lsign-key user-id"));
2534         username = make_username( fname );
2535         keyedit_menu(fname, locusr, NULL, 2 );
2536         m_free(username);
2537         break;
2538
2539       case aNRSignKey:
2540         if( argc != 1 )
2541             wrong_args(_("--nrsign-key user-id"));
2542         username = make_username( fname );
2543         keyedit_menu(fname, locusr, NULL, 3 );
2544         m_free(username);
2545         break;
2546
2547       case aNRLSignKey:
2548         if( argc != 1 )
2549             wrong_args(_("--nrlsign-key user-id"));
2550         username = make_username( fname );
2551         keyedit_menu(fname, locusr, NULL, 4 );
2552         m_free(username);
2553         break;
2554
2555       case aEditKey: /* Edit a key signature */
2556         if( !argc )
2557             wrong_args(_("--edit-key user-id [commands]"));
2558         username = make_username( fname );
2559         if( argc > 1 ) {
2560             sl = NULL;
2561             for( argc--, argv++ ; argc; argc--, argv++ )
2562                 append_to_strlist( &sl, *argv );
2563             keyedit_menu( username, locusr, sl, 0 );
2564             free_strlist(sl);
2565         }
2566         else
2567             keyedit_menu(username, locusr, NULL, 0 );
2568         m_free(username);
2569         break;
2570
2571       case aDeleteKeys:
2572       case aDeleteSecretKeys:
2573       case aDeleteSecretAndPublicKeys:
2574         sl = NULL;
2575         /* I'm adding these in reverse order as add_to_strlist2
2576            reverses them again, and it's easier to understand in the
2577            proper order :) */
2578         for( ; argc; argc-- )
2579           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2580         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2581         free_strlist(sl);
2582         break;
2583
2584       case aCheckKeys:
2585         opt.check_sigs = 1;
2586       case aListSigs:
2587         opt.list_sigs = 1;
2588       case aListKeys:
2589         sl = NULL;
2590         for( ; argc; argc--, argv++ )
2591             add_to_strlist2( &sl, *argv, utf8_strings );
2592         public_key_list( sl );
2593         free_strlist(sl);
2594         break;
2595       case aListSecretKeys:
2596         sl = NULL;
2597         for( ; argc; argc--, argv++ )
2598             add_to_strlist2( &sl, *argv, utf8_strings );
2599         secret_key_list( sl );
2600         free_strlist(sl);
2601         break;
2602
2603       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2604         if( argc < 2 ) { /* -kv [userid] */
2605             sl = NULL;
2606             if (argc && **argv)
2607                 add_to_strlist2( &sl, *argv, utf8_strings );
2608             public_key_list( sl );
2609             free_strlist(sl);
2610         }
2611         else if( argc == 2 ) { /* -kv userid keyring */
2612             if( access( argv[1], R_OK ) ) {
2613                 log_error(_("can't open %s: %s\n"),
2614                                print_fname_stdin(argv[1]), strerror(errno));
2615             }
2616             else {
2617                 /* add keyring (default keyrings are not registered in this
2618                  * special case */
2619                 keydb_add_resource( argv[1], 0, 0 );
2620                 sl = NULL;
2621                 if (**argv)
2622                     add_to_strlist2( &sl, *argv, utf8_strings );
2623                 public_key_list( sl );
2624                 free_strlist(sl);
2625             }
2626         }
2627         else
2628             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2629         break;
2630
2631       case aKeygen: /* generate a key */
2632         if( opt.batch ) {
2633             if( argc > 1 )
2634                 wrong_args("--gen-key [parameterfile]");
2635             generate_keypair( argc? *argv : NULL, NULL );
2636         }
2637         else {
2638             if( argc )
2639                 wrong_args("--gen-key");
2640             generate_keypair(NULL, NULL);
2641         }
2642         break;
2643
2644       case aFastImport:
2645         opt.import_options |= IMPORT_FAST_IMPORT;
2646       case aImport:
2647         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2648         break;
2649
2650       case aExport:
2651       case aExportAll:
2652       case aSendKeys:
2653       case aRecvKeys:
2654         sl = NULL;
2655         for( ; argc; argc--, argv++ )
2656             add_to_strlist2( &sl, *argv, utf8_strings );
2657         if( cmd == aSendKeys )
2658             rc=keyserver_export( sl );
2659         else if( cmd == aRecvKeys )
2660             rc=keyserver_import( sl );
2661         else
2662             rc=export_pubkeys( sl, opt.export_options );
2663         if(rc)
2664           {
2665             if(cmd==aSendKeys)
2666               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
2667             else if(cmd==aRecvKeys)
2668               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
2669             else
2670               log_error(_("key export failed: %s\n"),g10_errstr(rc));
2671           }
2672         free_strlist(sl);
2673         break;
2674
2675      case aSearchKeys:
2676         sl = NULL;
2677         for( ; argc; argc--, argv++ )
2678           append_to_strlist2( &sl, *argv, utf8_strings );
2679
2680         rc=keyserver_search( sl );
2681         if(rc)
2682           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
2683         free_strlist(sl);
2684         break;
2685
2686       case aRefreshKeys:
2687         sl = NULL;
2688         for( ; argc; argc--, argv++ )
2689             add_to_strlist2( &sl, *argv, utf8_strings );
2690         rc=keyserver_refresh(sl);
2691         if(rc)
2692           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
2693         free_strlist(sl);
2694         break;
2695
2696       case aExportSecret:
2697         sl = NULL;
2698         for( ; argc; argc--, argv++ )
2699             add_to_strlist2( &sl, *argv, utf8_strings );
2700         export_seckeys( sl );
2701         free_strlist(sl);
2702         break;
2703
2704       case aExportSecretSub:
2705         sl = NULL;
2706         for( ; argc; argc--, argv++ )
2707             add_to_strlist2( &sl, *argv, utf8_strings );
2708         export_secsubkeys( sl );
2709         free_strlist(sl);
2710         break;
2711
2712       case aGenRevoke:
2713         if( argc != 1 )
2714             wrong_args("--gen-revoke user-id");
2715         username =  make_username(*argv);
2716         gen_revoke( username );
2717         m_free( username );
2718         break;
2719
2720       case aDesigRevoke:
2721         if( argc != 1 )
2722             wrong_args("--desig-revoke user-id");
2723         username =  make_username(*argv);
2724         gen_desig_revoke( username );
2725         m_free( username );
2726         break;
2727
2728       case aDeArmor:
2729         if( argc > 1 )
2730             wrong_args("--dearmor [file]");
2731         rc = dearmor_file( argc? *argv: NULL );
2732         if( rc )
2733             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2734         break;
2735
2736       case aEnArmor:
2737         if( argc > 1 )
2738             wrong_args("--enarmor [file]");
2739         rc = enarmor_file( argc? *argv: NULL );
2740         if( rc )
2741             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2742         break;
2743
2744
2745       case aPrimegen:
2746         {   int mode = argc < 2 ? 0 : atoi(*argv);
2747
2748             if( mode == 1 && argc == 2 ) {
2749                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2750             }
2751             else if( mode == 2 && argc == 3 ) {
2752                 mpi_print( stdout, generate_elg_prime(
2753                                              0, atoi(argv[1]),
2754                                              atoi(argv[2]), NULL,NULL ), 1);
2755             }
2756             else if( mode == 3 && argc == 3 ) {
2757                 MPI *factors;
2758                 mpi_print( stdout, generate_elg_prime(
2759                                              1, atoi(argv[1]),
2760                                              atoi(argv[2]), NULL,&factors ), 1);
2761                 putchar('\n');
2762                 mpi_print( stdout, factors[0], 1 ); /* print q */
2763             }
2764             else if( mode == 4 && argc == 3 ) {
2765                 MPI g = mpi_alloc(1);
2766                 mpi_print( stdout, generate_elg_prime(
2767                                                  0, atoi(argv[1]),
2768                                                  atoi(argv[2]), g, NULL ), 1);
2769                 putchar('\n');
2770                 mpi_print( stdout, g, 1 );
2771                 mpi_free(g);
2772             }
2773             else
2774                 wrong_args("--gen-prime mode bits [qbits] ");
2775             putchar('\n');
2776         }
2777         break;
2778
2779       case aGenRandom:
2780         {
2781             int level = argc ? atoi(*argv):0;
2782             int count = argc > 1 ? atoi(argv[1]): 0;
2783             int endless = !count;
2784
2785             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2786                 wrong_args("--gen-random 0|1|2 [count]");
2787
2788             while( endless || count ) {
2789                 byte *p;
2790                 /* Wee need a multiple of 3, so that in case of
2791                    armored output we get a correct string.  No
2792                    linefolding is done, as it is best to levae this to
2793                    other tools */
2794                 size_t n = !endless && count < 99? count : 99;
2795
2796                 p = get_random_bits( n*8, level, 0);
2797 #ifdef HAVE_DOSISH_SYSTEM
2798                 setmode ( fileno(stdout), O_BINARY );
2799 #endif
2800                 if (opt.armor) {
2801                     char *tmp = make_radix64_string (p, n);
2802                     fputs (tmp, stdout);
2803                     m_free (tmp);
2804                     if (n%3 == 1)
2805                       putchar ('=');
2806                     if (n%3)
2807                       putchar ('=');
2808                 } else {
2809                     fwrite( p, n, 1, stdout );
2810                 }
2811                 m_free(p);
2812                 if( !endless )
2813                     count -= n;
2814             }
2815             if (opt.armor)
2816                 putchar ('\n');
2817         }
2818         break;
2819
2820       case aPrintMD:
2821         if( argc < 1)
2822             wrong_args("--print-md algo [files]");
2823         {
2824             int all_algos = (**argv=='*' && !(*argv)[1]);
2825             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2826
2827             if( !algo && !all_algos )
2828                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2829             else {
2830                 argc--; argv++;
2831                 if( !argc )
2832                     print_mds(NULL, algo);
2833                 else {
2834                     for(; argc; argc--, argv++ )
2835                         print_mds(*argv, algo);
2836                 }
2837             }
2838         }
2839         break;
2840
2841       case aPrintMDs: /* old option */
2842         if( !argc )
2843             print_mds(NULL,0);
2844         else {
2845             for(; argc; argc--, argv++ )
2846                 print_mds(*argv,0);
2847         }
2848         break;
2849
2850       case aListTrustDB:
2851         if( !argc )
2852             list_trustdb(NULL);
2853         else {
2854             for( ; argc; argc--, argv++ )
2855                 list_trustdb( *argv );
2856         }
2857         break;
2858
2859       case aUpdateTrustDB:
2860         if( argc )
2861             wrong_args("--update-trustdb");
2862         update_trustdb();
2863         break;
2864
2865       case aCheckTrustDB:
2866         /* Old versions allowed for arguments - ignore them */
2867         check_trustdb();
2868         break;
2869
2870       case aFixTrustDB:
2871         log_error("this command is not yet implemented.\n");
2872         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2873         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2874         break;
2875
2876       case aListTrustPath:
2877         if( !argc )
2878             wrong_args("--list-trust-path <user-ids>");
2879         for( ; argc; argc--, argv++ ) {
2880             username = make_username( *argv );
2881             list_trust_path( username );
2882             m_free(username);
2883         }
2884         break;
2885
2886       case aExportOwnerTrust:
2887         if( argc )
2888             wrong_args("--export-ownertrust");
2889         export_ownertrust();
2890         break;
2891
2892       case aImportOwnerTrust:
2893         if( argc > 1 )
2894             wrong_args("--import-ownertrust [file]");
2895         import_ownertrust( argc? *argv:NULL );
2896         break;
2897       
2898       case aPipeMode:
2899         if ( argc )
2900             wrong_args ("--pipemode");
2901         run_in_pipemode ();
2902         break;
2903
2904       case aRebuildKeydbCaches:
2905         if (argc)
2906             wrong_args ("--rebuild-keydb-caches");
2907         keydb_rebuild_caches ();
2908         break;
2909
2910 #ifdef ENABLE_CARD_SUPPORT
2911       case aCardStatus:
2912         if (argc)
2913             wrong_args ("--card-status");
2914         card_status (stdout);
2915         break;
2916
2917       case aCardEdit:
2918         if (argc) {
2919             sl = NULL;
2920             for (argc--, argv++ ; argc; argc--, argv++)
2921                 append_to_strlist (&sl, *argv);
2922             card_edit (sl);
2923             free_strlist (sl);
2924         }
2925         else
2926             card_edit (NULL);
2927         break;
2928
2929       case aChangePIN:
2930         if (!argc)
2931             change_pin (0);
2932         else if (argc == 1)
2933             change_pin ( atoi (*argv));
2934         else
2935         wrong_args ("--change-pin [no]");
2936         break;
2937 #endif /* ENABLE_CARD_SUPPORT*/
2938
2939
2940       case aListPackets:
2941         opt.list_packets=2;
2942       default:
2943         if( argc > 1 )
2944             wrong_args(_("[filename]"));
2945         /* Issue some output for the unix newbie */
2946         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2947                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2948             log_info(_("Go ahead and type your message ...\n"));
2949
2950         if( !(a = iobuf_open(fname)) )
2951             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2952         else {
2953
2954             if( !opt.no_armor ) {
2955                 if( use_armor_filter( a ) ) {
2956                     memset( &afx, 0, sizeof afx);
2957                     iobuf_push_filter( a, armor_filter, &afx );
2958                 }
2959             }
2960             if( cmd == aListPackets ) {
2961                 set_packet_list_mode(1);
2962                 opt.list_packets=1;
2963             }
2964             rc = proc_packets(NULL, a );
2965             if( rc )
2966                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2967             iobuf_close(a);
2968         }
2969         break;
2970     }
2971
2972     /* cleanup */
2973     FREE_STRLIST(remusr);
2974     FREE_STRLIST(locusr);
2975     g10_exit(0);
2976     return 8; /*NEVER REACHED*/
2977 }
2978
2979
2980 void
2981 g10_exit( int rc )
2982 {
2983 #ifdef ENABLE_CARD_SUPPORT
2984     card_close ();
2985 #endif
2986     update_random_seed_file();
2987     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2988         m_print_stats("on exit");
2989         random_dump_stats();
2990     }
2991     if( opt.debug )
2992         secmem_dump_stats();
2993     secmem_term();
2994     rc = rc? rc : log_get_errorcount(0)? 2 :
2995                         g10_errors_seen? 1 : 0;
2996     exit(rc );
2997 }
2998
2999
3000 /* Pretty-print hex hashes.  This assumes at least an 80-character
3001    display, but there are a few other similar assumptions in the
3002    display code. */
3003 static void
3004 print_hex( MD_HANDLE md, int algo, const char *fname )
3005 {
3006   int i,n,count,indent=0;
3007   const byte *p;
3008
3009   if(fname)
3010     indent=printf("%s: ",fname);
3011
3012   if(indent>40)
3013     {
3014       printf("\n");
3015       indent=0;
3016     }
3017
3018   if(algo==DIGEST_ALGO_RMD160)
3019     indent+=printf("RMD160 = ");
3020   else if(algo>0)
3021     indent+=printf("%6s = ",digest_algo_to_string(algo));
3022   else
3023     algo=abs(algo);
3024
3025   count=indent;
3026
3027   p = md_read( md, algo );
3028   n = md_digest_length(algo);
3029
3030   count+=printf("%02X",*p++);
3031
3032   for(i=1;i<n;i++,p++)
3033     {
3034       if(n==16)
3035         {
3036           if(count+2>79)
3037             {
3038               printf("\n%*s",indent," ");
3039               count=indent;
3040             }
3041           else
3042             count+=printf(" ");
3043
3044           if(!(i%8))
3045             count+=printf(" ");
3046         }
3047       else if (n==20)
3048         {
3049           if(!(i%2))
3050             {
3051               if(count+4>79)
3052                 {
3053                   printf("\n%*s",indent," ");
3054                   count=indent;
3055                 }
3056               else
3057                 count+=printf(" ");
3058             }
3059
3060           if(!(i%10))
3061             count+=printf(" ");
3062         }
3063       else
3064         {
3065           if(!(i%4))
3066             {
3067               if(count+8>79)
3068                 {
3069                   printf("\n%*s",indent," ");
3070                   count=indent;
3071                 }
3072               else
3073                 count+=printf(" ");
3074             }
3075         }
3076
3077       count+=printf("%02X",*p);
3078     }
3079
3080   printf("\n");
3081 }
3082
3083 static void
3084 print_hashline( MD_HANDLE md, int algo, const char *fname )
3085 {
3086     int i, n;
3087     const byte *p;
3088     
3089     if ( fname ) {
3090         for (p = fname; *p; p++ ) {
3091             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3092                 printf("%%%02X", *p );
3093             else 
3094                 putchar( *p );
3095         }
3096     }
3097     putchar(':');
3098     printf("%d:", algo );
3099     p = md_read( md, algo );
3100     n = md_digest_length(algo);
3101     for(i=0; i < n ; i++, p++ ) 
3102         printf("%02X", *p );
3103     putchar(':');
3104     putchar('\n');
3105 }
3106
3107 static void
3108 print_mds( const char *fname, int algo )
3109 {
3110     FILE *fp;
3111     char buf[1024];
3112     size_t n;
3113     MD_HANDLE md;
3114
3115     if( !fname ) {
3116         fp = stdin;
3117 #ifdef HAVE_DOSISH_SYSTEM
3118         setmode ( fileno(fp) , O_BINARY );
3119 #endif
3120     }
3121     else {
3122         fp = fopen( fname, "rb" );
3123     }
3124     if( !fp ) {
3125         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3126         return;
3127     }
3128
3129     md = md_open( 0, 0 );
3130     if( algo )
3131         md_enable( md, algo );
3132     else {
3133         md_enable( md, DIGEST_ALGO_MD5 );
3134         md_enable( md, DIGEST_ALGO_SHA1 );
3135         md_enable( md, DIGEST_ALGO_RMD160 );
3136 #ifdef USE_SHA256
3137         md_enable( md, DIGEST_ALGO_SHA256 );
3138 #endif
3139 #ifdef USE_SHA512
3140         md_enable( md, DIGEST_ALGO_SHA384 );
3141         md_enable( md, DIGEST_ALGO_SHA512 );
3142 #endif
3143     }
3144
3145     while( (n=fread( buf, 1, DIM(buf), fp )) )
3146         md_write( md, buf, n );
3147     if( ferror(fp) )
3148         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3149     else {
3150         md_final(md);
3151         if ( opt.with_colons ) {
3152             if ( algo ) 
3153                 print_hashline( md, algo, fname );
3154             else {
3155                 print_hashline( md, DIGEST_ALGO_MD5, fname );
3156                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
3157                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
3158 #ifdef USE_SHA256
3159                 print_hashline( md, DIGEST_ALGO_SHA256, fname );
3160 #endif
3161 #ifdef USE_SHA512
3162                 print_hashline( md, DIGEST_ALGO_SHA384, fname );
3163                 print_hashline( md, DIGEST_ALGO_SHA512, fname );
3164 #endif
3165             }
3166         }
3167         else {
3168             if( algo )
3169                print_hex(md,-algo,fname);
3170             else {
3171                 print_hex( md, DIGEST_ALGO_MD5, fname );
3172                 print_hex( md, DIGEST_ALGO_SHA1, fname );
3173                 print_hex( md, DIGEST_ALGO_RMD160, fname );
3174 #ifdef USE_SHA256
3175                 print_hex( md, DIGEST_ALGO_SHA256, fname );
3176 #endif
3177 #ifdef USE_SHA512
3178                 print_hex( md, DIGEST_ALGO_SHA384, fname );
3179                 print_hex( md, DIGEST_ALGO_SHA512, fname );
3180 #endif
3181             }
3182         }
3183     }
3184     md_close(md);
3185
3186     if( fp != stdin )
3187         fclose(fp);
3188 }
3189
3190
3191 /****************
3192  * Check the supplied name,value string and add it to the notation
3193  * data to be used for signatures.  which==0 for sig notations, and 1
3194  * for cert notations.
3195 */
3196 static void
3197 add_notation_data( const char *string, int which )
3198 {
3199     const char *s;
3200     STRLIST sl,*notation_data;
3201     int critical=0;
3202     int highbit=0;
3203     int saw_at=0;
3204
3205     if(which)
3206       notation_data=&opt.cert_notation_data;
3207     else
3208       notation_data=&opt.sig_notation_data;
3209
3210     if( *string == '!' ) {
3211         critical = 1;
3212         string++;
3213     }
3214
3215     /* If and when the IETF assigns some official name tags, we'll
3216        have to add them here. */
3217
3218     for( s=string ; *s != '='; s++ )
3219       {
3220         if( *s=='@')
3221           saw_at=1;
3222
3223         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3224           {
3225             log_error(_("a notation name must have only printable characters "
3226                         "or spaces, and end with an '='\n") );
3227             return;
3228           }
3229       }
3230
3231     if(!saw_at && !opt.expert)
3232       {
3233         log_error(
3234                 _("a user notation name must contain the '@' character\n"));
3235         return;
3236       }
3237
3238     /* we only support printable text - therefore we enforce the use
3239      * of only printable characters (an empty value is valid) */
3240     for( s++; *s ; s++ ) {
3241         if ((*s & 0x80))
3242           highbit = 1;
3243         else if (iscntrl(*s)) {
3244             log_error(_("a notation value must not use "
3245                         "any control characters\n") );
3246             return;
3247         }
3248     }
3249
3250     if( highbit )   /* must use UTF8 encoding */
3251         sl = add_to_strlist2( notation_data, string, utf8_strings );
3252     else
3253         sl = add_to_strlist( notation_data, string );
3254
3255     if( critical )
3256         sl->flags |= 1;
3257 }
3258
3259 static void
3260 add_policy_url( const char *string, int which )
3261 {
3262   int i,critical=0;
3263   STRLIST sl;
3264
3265   if(*string=='!')
3266     {
3267       string++;
3268       critical=1;
3269     }
3270
3271   for(i=0;i<strlen(string);i++)
3272     if(string[i]&0x80 || iscntrl(string[i]))
3273       break;
3274
3275   if(i==0 || i<strlen(string))
3276     {
3277       if(which)
3278         log_error(_("the given certification policy URL is invalid\n"));
3279       else
3280         log_error(_("the given signature policy URL is invalid\n"));
3281     }
3282
3283   if(which)
3284     sl=add_to_strlist( &opt.cert_policy_url, string );
3285   else
3286     sl=add_to_strlist( &opt.sig_policy_url, string );
3287
3288   if(critical)
3289     sl->flags |= 1;    
3290 }
3291
3292 static void
3293 add_keyserver_url( const char *string, int which )
3294 {
3295   int i,critical=0;
3296   STRLIST sl;
3297
3298   if(*string=='!')
3299     {
3300       string++;
3301       critical=1;
3302     }
3303
3304   for(i=0;i<strlen(string);i++)
3305     if(string[i]&0x80 || iscntrl(string[i]))
3306       break;
3307
3308   if(i==0 || i<strlen(string))
3309     {
3310       if(which)
3311         BUG();
3312       else
3313         log_error(_("the given signature preferred"
3314                     " keyserver URL is invalid\n"));
3315     }
3316
3317   if(which)
3318     BUG();
3319   else
3320     sl=add_to_strlist( &opt.sig_keyserver_url, string );
3321
3322   if(critical)
3323     sl->flags |= 1;    
3324 }