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