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