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