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