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