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