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