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