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