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