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