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