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