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