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