* options.h, g10.c (main), mainproc.c (proc_encrypted): Return a
[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         configname = make_filename(opt.homedir, "options", NULL );
983
984     argc = orig_argc;
985     argv = orig_argv;
986     pargs.argc = &argc;
987     pargs.argv = &argv;
988     pargs.flags=  1;  /* do not remove the args */
989   next_pass:
990     if( configname ) {
991
992       if(check_permissions(configname,0,1))
993         {
994           add_to_strlist(&unsafe_files,configname);
995
996           /* If any options file is unsafe, then disable any external
997              programs for keyserver calls or photo IDs.  Since the
998              external program to call is set in the options file, a
999              unsafe options file can lead to an arbitrary program
1000              being run. */
1001
1002           opt.exec_disable=1;
1003         }
1004
1005         configlineno = 0;
1006         configfp = fopen( configname, "r" );
1007         if( !configfp ) {
1008             if( default_config ) {
1009                 if( parse_debug )
1010                     log_info(_("NOTE: no default option file `%s'\n"),
1011                                                             configname );
1012             }
1013             else {
1014                 log_error(_("option file `%s': %s\n"),
1015                                     configname, strerror(errno) );
1016                 g10_exit(2);
1017             }
1018             m_free(configname); configname = NULL;
1019         }
1020         if( parse_debug && configname )
1021             log_info(_("reading options from `%s'\n"), configname );
1022         default_config = 0;
1023     }
1024
1025     while( optfile_parse( configfp, configname, &configlineno,
1026                                                 &pargs, opts) ) {
1027         switch( pargs.r_opt ) {
1028           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1029           case aListPackets: set_cmd( &cmd, aListPackets); break;
1030           case aImport: set_cmd( &cmd, aImport); break;
1031           case aFastImport: set_cmd( &cmd, aFastImport); break;
1032           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1033           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1034           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1035           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1036           case aExport: set_cmd( &cmd, aExport); break;
1037           case aExportAll: set_cmd( &cmd, aExportAll); break;
1038           case aListKeys: set_cmd( &cmd, aListKeys); break;
1039           case aListSigs: set_cmd( &cmd, aListSigs); break;
1040           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1041           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1042           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1043                                                         greeting=1; break;
1044           case aDeleteSecretAndPublicKeys:
1045             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1046             greeting=1; 
1047             break;
1048           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1049
1050           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1051           case aSym: set_cmd( &cmd, aSym); break;
1052
1053           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1054           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1055
1056           case aEncr: set_cmd( &cmd, aEncr); break;
1057           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1058           case aSign: set_cmd( &cmd, aSign );  break;
1059           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1060           case aSignKey: set_cmd( &cmd, aSignKey); break;
1061           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1062           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1063           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1064           case aStore: set_cmd( &cmd, aStore); break;
1065           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1066           case aClearsign: set_cmd( &cmd, aClearsign); break;
1067           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1068           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1069           case aVerify: set_cmd( &cmd, aVerify); break;
1070           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1071           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1072           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1073           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1074           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1075           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1076           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1077           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1078           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1079           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1080           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1081           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1082           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1083           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1084           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1085           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1086
1087           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1088           case oOutput: opt.outfile = pargs.r.ret_str; break;
1089           case oQuiet: opt.quiet = 1; break;
1090           case oNoTTY: tty_no_terminal(1); break;
1091           case oDryRun: opt.dry_run = 1; break;
1092           case oInteractive: opt.interactive = 1; break;
1093           case oVerbose: g10_opt_verbose++;
1094                     opt.verbose++; opt.list_sigs=1; break;
1095           case oKOption: set_cmd( &cmd, aKMode ); break;
1096
1097           case oBatch: opt.batch = 1; nogreeting = 1; break;
1098           case oUseAgent:
1099 #ifndef __riscos__
1100             opt.use_agent = 1;
1101 #else /* __riscos__ */
1102             opt.use_agent = 0;
1103             not_implemented("use-agent");
1104 #endif /* __riscos__ */
1105             break;
1106           case oNoUseAgent: opt.use_agent = 0; break;
1107           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1108           case oAnswerYes: opt.answer_yes = 1; break;
1109           case oAnswerNo: opt.answer_no = 1; break;
1110           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1111           case oShowKeyring: opt.show_keyring = 1; break;
1112           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1113           case oDebugAll: opt.debug = ~0; break;
1114           case oStatusFD:
1115             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1116             break;
1117 #ifdef __riscos__
1118           case oStatusFile:
1119             set_status_fd( iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1120             break;
1121 #endif /* __riscos__ */
1122           case oAttributeFD:
1123             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1124             break;
1125 #ifdef __riscos__
1126           case oAttributeFile:
1127             set_attrib_fd(iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1128             break;
1129 #endif /* __riscos__ */
1130           case oLoggerFD:
1131             log_set_logfile( NULL,
1132                              iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1133             break;
1134 #ifdef __riscos__
1135           case oLoggerFile:
1136             log_set_logfile( NULL,
1137                              iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 1), 1) );
1138             break;
1139 #endif /* __riscos__ */
1140           case oWithFingerprint:
1141             opt.with_fingerprint = 1;
1142             with_fpr=1; /*fall thru*/
1143           case oFingerprint: opt.fingerprint++; break;
1144           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1145           case oOptions:
1146             /* config files may not be nested (silently ignore them) */
1147             if( !configfp ) {
1148                 m_free(configname);
1149                 configname = m_strdup(pargs.r.ret_str);
1150                 goto next_pass;
1151             }
1152             break;
1153           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1154           case oNoDefKeyring: default_keyring = 0; break;
1155           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1156           case oNoGreeting: nogreeting = 1; break;
1157           case oNoVerbose: g10_opt_verbose = 0;
1158                            opt.verbose = 0; opt.list_sigs=0; break;
1159           case oQuickRandom: quick_random_gen(1); break;
1160           case oSKComments: opt.sk_comments=1; break;
1161           case oNoSKComments: opt.sk_comments=0; break;
1162           case oNoVersion: opt.no_version=1; break;
1163           case oEmitVersion: opt.no_version=0; break;
1164           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1165           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1166           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1167           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1168           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1169           case oDefRecipient:
1170                     if( *pargs.r.ret_str )
1171                         opt.def_recipient = make_username(pargs.r.ret_str);
1172                     break;
1173           case oDefRecipientSelf:
1174                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1175                     opt.def_recipient_self = 1;
1176                     break;
1177           case oNoDefRecipient:
1178                     m_free(opt.def_recipient); opt.def_recipient = NULL;
1179                     opt.def_recipient_self = 0;
1180                     break;
1181           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1182           case oHomedir: break;
1183           case oNoBatch: opt.batch = 0; break;
1184           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1185           case oWithColons: opt.with_colons=':'; break;
1186
1187           case oSkipVerify: opt.skip_verify=1; break;
1188           case oCompressAlgo: opt.def_compress_algo = pargs.r.ret_int; break;
1189           case oCompressKeys: opt.compress_keys = 1; break;
1190           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1191           case oAlwaysTrust: opt.always_trust = 1; break;
1192           case oLoadExtension:
1193 #ifndef __riscos__
1194             add_to_strlist(&extensions,pargs.r.ret_str);
1195             register_cipher_extension(orig_argc? *orig_argv:NULL,
1196                                       pargs.r.ret_str);
1197 #else /* __riscos__ */
1198             not_implemented("load-extension");
1199 #endif /* __riscos__ */
1200             break;
1201           case oRFC1991:
1202             opt.rfc1991 = 1;
1203             opt.rfc2440 = 0;
1204             opt.force_v4_certs = 0;
1205             opt.sk_comments = 0;
1206             opt.escape_from = 1;
1207             break;
1208           case oOpenPGP:
1209             opt.rfc1991 = 0;
1210             opt.rfc2440 = 1;
1211             opt.allow_non_selfsigned_uid = 1;
1212             opt.allow_freeform_uid = 1;
1213             opt.pgp2_workarounds = 0;
1214             opt.escape_from = 0;
1215             opt.force_v3_sigs = 0;
1216             opt.compress_keys = 0;          /* not mandated  but we do it */
1217             opt.compress_sigs = 0;          /* ditto. */
1218             opt.not_dash_escaped = 0;
1219             opt.def_cipher_algo = 0;
1220             opt.def_digest_algo = 0;
1221             opt.cert_digest_algo = 0;
1222             opt.def_compress_algo = 1;
1223             opt.s2k_mode = 3; /* iterated+salted */
1224             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1225             opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1226             break;
1227           case oPGP2: opt.pgp2 = 1; break;
1228           case oNoPGP2: opt.pgp2 = 0; break;
1229           case oPGP6: opt.pgp6 = 1; break;
1230           case oNoPGP6: opt.pgp6 = 0; break;
1231           case oPGP7: opt.pgp7 = 1; break;
1232           case oNoPGP7: opt.pgp7 = 0; break;
1233           case oEmuChecksumBug: opt.emulate_bugs |= EMUBUG_GPGCHKSUM; break;
1234           case oEmu3DESS2KBug:  opt.emulate_bugs |= EMUBUG_3DESS2K; break;
1235           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1236           case oCompressSigs: opt.compress_sigs = 1; break;
1237           case oRunAsShmCP:
1238 #ifndef __riscos__
1239           #ifndef USE_SHM_COPROCESSING
1240             /* not possible in the option file,
1241              * but we print the warning here anyway */
1242             log_error("shared memory coprocessing is not available\n");
1243           #endif
1244 #else /* __riscos__ */
1245             not_implemented("run-as-shm-coprocess");
1246 #endif /* __riscos__ */
1247             break;
1248           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1249           case oForYourEyesOnly: eyes_only = 1; break;
1250           case oNoForYourEyesOnly: eyes_only = 0; break;
1251           case oSetPolicyURL:
1252             add_policy_url(pargs.r.ret_str,0);
1253             add_policy_url(pargs.r.ret_str,1);
1254             break;
1255           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1256           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1257           case oShowPolicyURL: opt.show_policy_url=1; break;
1258           case oNoShowPolicyURL: opt.show_policy_url=0; break;
1259           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1260           case oComment: opt.comment_string = pargs.r.ret_str; break;
1261           case oDefaultComment: opt.comment_string = NULL; break;
1262           case oThrowKeyid: opt.throw_keyid = 1; break;
1263           case oShowPhotos: opt.show_photos = 1; break;
1264           case oNoShowPhotos: opt.show_photos = 0; break;
1265           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1266           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1267           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1268           case oForceV4Certs: opt.force_v4_certs = 1; break;
1269           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1270           case oForceMDC: opt.force_mdc = 1; break;
1271           case oNoForceMDC: opt.force_mdc = 0; break;
1272           case oDisableMDC: opt.disable_mdc = 1; break;
1273           case oNoDisableMDC: opt.disable_mdc = 0; break;
1274           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1275           case oS2KDigest: s2k_digest_string = m_strdup(pargs.r.ret_str); break;
1276           case oS2KCipher: s2k_cipher_string = m_strdup(pargs.r.ret_str); break;
1277           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1278           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1279           case oEncryptTo: /* store the recipient in the second list */
1280             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1281             sl->flags = 1;
1282             break;
1283           case oRecipient: /* store the recipient */
1284             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1285             any_explicit_recipient = 1;
1286             break;
1287           case oTextmodeShort: opt.textmode = 2; break;
1288           case oTextmode: opt.textmode=1;  break;
1289           case oExpert: opt.expert = 1; break;
1290           case oNoExpert: opt.expert = 0; break;
1291           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1292           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1293           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1294           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1295           case oUser: /* store the local users */
1296             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1297             break;
1298           case oCompress: opt.compress = pargs.r.ret_int; break;
1299           case oPasswdFD:
1300             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1301             break;
1302 #ifdef __riscos__
1303           case oPasswdFile:
1304             pwfd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1305             break;
1306 #endif /* __riscos__ */
1307           case oCommandFD:
1308             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1309             break;
1310 #ifdef __riscos__
1311           case oCommandFile:
1312             opt.command_fd = iobuf_translate_file_handle ( fdopenfile (pargs.r.ret_str, 0), 0);
1313             break;
1314 #endif /* __riscos__ */
1315           case oCipherAlgo: def_cipher_string = m_strdup(pargs.r.ret_str); break;
1316           case oDigestAlgo: def_digest_string = m_strdup(pargs.r.ret_str); break;
1317           case oCertDigestAlgo: cert_digest_string = m_strdup(pargs.r.ret_str); break;
1318           case oNoSecmemWarn: secmem_set_flags( secmem_get_flags() | 1 ); break;
1319           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1320           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1321           case oCharset:
1322             if( set_native_charset( pargs.r.ret_str ) )
1323                 log_error(_("%s is not a valid character set\n"),
1324                                                     pargs.r.ret_str);
1325             break;
1326           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1327           case oEscapeFrom: opt.escape_from = 1; break;
1328           case oNoEscapeFrom: opt.escape_from = 0; break;
1329           case oLockOnce: opt.lock_once = 1; break;
1330           case oLockNever: disable_dotlock(); break;
1331           case oLockMultiple:
1332 #ifndef __riscos__
1333             opt.lock_once = 0;
1334 #else /* __riscos__ */
1335             not_implemented("lock-multiple");
1336 #endif /* __riscos__ */
1337             break;
1338           case oKeyServer:
1339             opt.keyserver_uri=m_strdup(pargs.r.ret_str);
1340             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1341               log_error(_("could not parse keyserver URI\n"));
1342             break;
1343           case oKeyServerOptions:
1344             parse_keyserver_options(pargs.r.ret_str);
1345             break;
1346           case oImportOptions:
1347             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1348               {
1349                 if(configname)
1350                   log_error(_("%s:%d: invalid import options\n"),
1351                             configname,configlineno);
1352                 else
1353                   log_error(_("invalid import options\n"));
1354               }
1355             break;
1356           case oExportOptions:
1357             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1358               {
1359                 if(configname)
1360                   log_error(_("%s:%d: invalid export options\n"),
1361                             configname,configlineno);
1362                 else
1363                   log_error(_("invalid export options\n"));
1364               }
1365             break;
1366           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1367           case oExecPath:
1368             if(set_exec_path(pargs.r.ret_str,0))
1369               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1370             else
1371               opt.exec_path_set=1;
1372             break;
1373           case oNotation:
1374             add_notation_data( pargs.r.ret_str, 0 );
1375             add_notation_data( pargs.r.ret_str, 1 );
1376             break;
1377           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1378           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1379           case oShowNotation: opt.show_notation=1; break;
1380           case oNoShowNotation: opt.show_notation=0; break;
1381           case oUtf8Strings: utf8_strings = 1; break;
1382           case oNoUtf8Strings: utf8_strings = 0; break;
1383           case oDisableCipherAlgo:
1384                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1385                 break;
1386           case oDisablePubkeyAlgo:
1387                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1388                 break;
1389           case oNoSigCache: opt.no_sig_cache = 1; break;
1390           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1391           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1392           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1393           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1394           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1395           case oNoLiteral: opt.no_literal = 1; break;
1396           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1397           case oHonorHttpProxy:
1398                 opt.keyserver_options.honor_http_proxy = 1;
1399                 deprecated_warning(configname,configlineno,
1400                                    "--honor-http-proxy",
1401                                    "--keyserver-options ",
1402                                    "honor-http-proxy");
1403                 break;
1404           case oFastListMode: opt.fast_list_mode = 1; break;
1405           case oFixedListMode: opt.fixed_list_mode = 1; break;
1406           case oListOnly: opt.list_only=1; break;
1407           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1408           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1409           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1410           case oNoRandomSeedFile: use_random_seed = 0; break;
1411           case oAutoKeyRetrieve:
1412           case oNoAutoKeyRetrieve:
1413                 opt.keyserver_options.auto_key_retrieve=
1414                                              (pargs.r_opt==oAutoKeyRetrieve);
1415                 deprecated_warning(configname,configlineno,
1416                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1417                                "--no-auto-key-retrieve","--keyserver-options ",
1418                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1419                                "no-auto-key-retrieve");
1420                 break;
1421           case oShowSessionKey: opt.show_session_key = 1; break;
1422           case oOverrideSessionKey:
1423                 opt.override_session_key = pargs.r.ret_str;
1424                 break;
1425           case oMergeOnly: opt.merge_only = 1; break;
1426           case oAllowSecretKeyImport: /* obsolete */ break;
1427           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1428           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1429           case oEnableSpecialFilenames:
1430             iobuf_enable_special_filenames (1);
1431             break;
1432           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1433           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1434           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1435           case oPreservePermissions: opt.preserve_permissions=1; break;
1436           case oDefaultPreferenceList:
1437             opt.def_preference_list = pargs.r.ret_str;
1438             break;
1439           case oPersonalCipherPreferences:
1440             pers_cipher_list=pargs.r.ret_str;
1441             break;
1442           case oPersonalDigestPreferences:
1443             pers_digest_list=pargs.r.ret_str;
1444             break;
1445           case oPersonalCompressPreferences:
1446             pers_compress_list=pargs.r.ret_str;
1447             break;
1448           case oDisplay: opt.display = pargs.r.ret_str; break;
1449           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1450           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1451           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1452           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1453           case oGroup: add_group(pargs.r.ret_str); break;
1454           default : pargs.err = configfp? 1:2; break;
1455         }
1456     }
1457
1458     if( configfp ) {
1459         fclose( configfp );
1460         configfp = NULL;
1461         m_free(configname); configname = NULL;
1462         goto next_pass;
1463     }
1464     m_free( configname ); configname = NULL;
1465     if( log_get_errorcount(0) )
1466         g10_exit(2);
1467     if( nogreeting )
1468         greeting = 0;
1469
1470     if( greeting ) {
1471         fprintf(stderr, "%s %s; %s\n",
1472                         strusage(11), strusage(13), strusage(14) );
1473         fprintf(stderr, "%s\n", strusage(15) );
1474     }
1475   #ifdef IS_DEVELOPMENT_VERSION
1476     if( !opt.batch ) {
1477         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1478         log_info("It is only intended for test purposes and should NOT be\n");
1479         log_info("used in a production environment or with production keys!\n");
1480     }
1481   #endif
1482
1483     check_permissions(opt.homedir,0,0);
1484
1485     if(unsafe_files)
1486       {
1487         STRLIST tmp;
1488
1489         for(tmp=unsafe_files;tmp;tmp=tmp->next)
1490           check_permissions(tmp->d,0,0);
1491
1492         free_strlist(unsafe_files);
1493       }
1494
1495     if(extensions)
1496       {
1497         STRLIST tmp;
1498
1499         for(tmp=extensions;tmp;tmp=tmp->next)
1500           check_permissions(tmp->d,1,0);
1501
1502         free_strlist(extensions);
1503       }
1504
1505     if( may_coredump && !opt.quiet )
1506         log_info(_("WARNING: program may create a core file!\n"));
1507
1508     if (eyes_only) {
1509       if (opt.set_filename)
1510           log_info(_("WARNING: %s overrides %s\n"),
1511                    "--for-your-eyes-only","--set-filename");
1512
1513       opt.set_filename="_CONSOLE";
1514     }
1515
1516     if (opt.no_literal) {
1517         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1518         if (opt.textmode)
1519             log_error(_("%s not allowed with %s!\n"),
1520                        "--textmode", "--no-literal" );
1521         if (opt.set_filename)
1522             log_error(_("%s makes no sense with %s!\n"),
1523                         eyes_only?"--for-your-eyes-only":"--set-filename",
1524                         "--no-literal" );
1525     }
1526
1527     if (opt.set_filesize)
1528         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1529     if( opt.batch )
1530         tty_batchmode( 1 );
1531
1532     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1533
1534     set_debug();
1535     g10_opt_homedir = opt.homedir;
1536
1537     /* Do these after the switch(), so they can override settings. */
1538     if(opt.pgp2 && (opt.pgp6 || opt.pgp7))
1539       log_error(_("%s not allowed with %s!\n"),
1540                 "--pgp2",opt.pgp6?"--pgp6":"--pgp7");
1541     else
1542       {
1543         if(opt.pgp2)
1544           {
1545             int unusable=0;
1546
1547             if(cmd==aSign && !detached_sig)
1548               {
1549                 log_info(_("you can only make detached or clear signatures "
1550                            "while in --pgp2 mode\n"));
1551                 unusable=1;
1552               }
1553             else if(cmd==aSignEncr || cmd==aSignSym)
1554               {
1555                 log_info(_("you can't sign and encrypt at the "
1556                            "same time while in --pgp2 mode\n"));
1557                 unusable=1;
1558               }
1559             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1560               {
1561                 log_info(_("you must use files (and not a pipe) when "
1562                            "working with --pgp2 enabled.\n"));
1563                 unusable=1;
1564               }
1565             else if(cmd==aEncr || cmd==aSym)
1566               {
1567                 /* Everything else should work without IDEA (except using
1568                    a secret key encrypted with IDEA and setting an IDEA
1569                    preference, but those have their own error
1570                    messages). */
1571
1572                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1573                   {
1574                     log_info(_("encrypting a message in --pgp2 mode requires "
1575                                "the IDEA cipher\n"));
1576                     idea_cipher_warn(1);
1577                     unusable=1;
1578                   }
1579                 else if(cmd==aSym)
1580                   {
1581                     m_free(def_cipher_string);
1582                     def_cipher_string = m_strdup("idea");
1583                   }
1584               }
1585
1586             if(unusable)
1587               {
1588                 log_info(_("this message may not be usable by PGP 2.x\n"));
1589                 opt.pgp2=0;
1590               }
1591             else
1592               {
1593                 opt.rfc1991 = 1;
1594                 opt.rfc2440 = 0;
1595                 opt.force_mdc = 0;
1596                 opt.disable_mdc = 1;
1597                 opt.force_v4_certs = 0;
1598                 opt.sk_comments = 0;
1599                 opt.escape_from = 1;
1600                 opt.force_v3_sigs = 1;
1601                 opt.pgp2_workarounds = 1;
1602                 opt.ask_sig_expire = 0;
1603                 opt.ask_cert_expire = 0;
1604                 m_free(def_digest_string);
1605                 def_digest_string = m_strdup("md5");
1606                 opt.def_compress_algo = 1;
1607               }
1608           }
1609
1610         if(opt.pgp6 || opt.pgp7)
1611           {
1612             opt.sk_comments=0;
1613             opt.escape_from=1;
1614             opt.force_v3_sigs=1;
1615             opt.ask_sig_expire=0;
1616             opt.def_compress_algo=1;
1617
1618             if(opt.pgp6) /* pgp7 has MDC */
1619               {
1620                 opt.force_mdc=0;
1621                 opt.disable_mdc=1;
1622               }
1623           }
1624       }
1625
1626     /* must do this after dropping setuid, because string_to...
1627      * may try to load an module */
1628     if( def_cipher_string ) {
1629         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1630         if(opt.def_cipher_algo==0 &&
1631            ascii_strcasecmp(def_cipher_string,"idea")==0)
1632           idea_cipher_warn(1);
1633         m_free(def_cipher_string); def_cipher_string = NULL;
1634         if( check_cipher_algo(opt.def_cipher_algo) )
1635             log_error(_("selected cipher algorithm is invalid\n"));
1636     }
1637     if( def_digest_string ) {
1638         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1639         m_free(def_digest_string); def_digest_string = NULL;
1640         if( check_digest_algo(opt.def_digest_algo) )
1641             log_error(_("selected digest algorithm is invalid\n"));
1642     }
1643     if( cert_digest_string ) {
1644         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1645         m_free(cert_digest_string); cert_digest_string = NULL;
1646         if( check_digest_algo(opt.cert_digest_algo) )
1647             log_error(_("selected certification digest algorithm is invalid\n"));
1648     }
1649     if( s2k_cipher_string ) {
1650         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
1651         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
1652         if( check_cipher_algo(opt.s2k_cipher_algo) )
1653             log_error(_("selected cipher algorithm is invalid\n"));
1654     }
1655     if( s2k_digest_string ) {
1656         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
1657         m_free(s2k_digest_string); s2k_digest_string = NULL;
1658         if( check_digest_algo(opt.s2k_digest_algo) )
1659             log_error(_("selected digest algorithm is invalid\n"));
1660     }
1661     if( opt.def_compress_algo < -1 || opt.def_compress_algo > 2 )
1662         log_error(_("compress algorithm must be in range %d..%d\n"), 0, 2);
1663     if( opt.completes_needed < 1 )
1664         log_error(_("completes-needed must be greater than 0\n"));
1665     if( opt.marginals_needed < 2 )
1666         log_error(_("marginals-needed must be greater than 1\n"));
1667     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1668         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1669     switch( opt.s2k_mode ) {
1670       case 0:
1671         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1672         break;
1673       case 1: case 3: break;
1674       default:
1675         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1676     }
1677
1678     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
1679       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
1680
1681     /* This isn't actually needed, but does serve to error out if the
1682        string is invalid. */
1683     if(opt.def_preference_list &&
1684         keygen_set_std_prefs(opt.def_preference_list,0))
1685       log_error(_("invalid default preferences\n"));
1686
1687     /* We provide defaults for the personal digest list */
1688     if(!pers_digest_list)
1689       pers_digest_list="h2";
1690
1691     if(pers_cipher_list &&
1692        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
1693       log_error(_("invalid personal cipher preferences\n"));
1694
1695     if(pers_digest_list &&
1696        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
1697       log_error(_("invalid personal digest preferences\n"));
1698
1699     if(pers_compress_list &&
1700        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
1701       log_error(_("invalid personal compress preferences\n"));
1702
1703     if( log_get_errorcount(0) )
1704         g10_exit(2);
1705
1706     /* set the random seed file */
1707     if( use_random_seed ) {
1708         char *p = make_filename(opt.homedir, "random_seed", NULL );
1709         check_permissions(p,0,0);
1710         set_random_seed_file(p);
1711         m_free(p);
1712     }
1713
1714     if( !cmd && opt.fingerprint && !with_fpr ) {
1715         set_cmd( &cmd, aListKeys);
1716     }
1717
1718     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1719         if( cmd == aKModeC ) {
1720             opt.fingerprint = 1;
1721             cmd = aKMode;
1722         }
1723         opt.list_sigs = 0;
1724         if( opt.verbose > 2 )
1725             opt.check_sigs++;
1726         if( opt.verbose > 1 )
1727             opt.list_sigs++;
1728
1729         opt.verbose = opt.verbose > 1;
1730         g10_opt_verbose = opt.verbose;
1731     }
1732
1733     /* Compression algorithm 0 means no compression at all */
1734     if( opt.def_compress_algo == 0)
1735         opt.compress = 0;
1736
1737     /* kludge to let -sat generate a clear text signature */
1738     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1739         cmd = aClearsign;
1740
1741     if( opt.verbose > 1 )
1742         set_packet_list_mode(1);
1743
1744     /* Add the keyrings, but not for some special commands and not in
1745        case of "-kvv userid keyring".  Also avoid adding the secret
1746        keyring for a couple of commands to avoid unneeded access in
1747        case the secrings are stored on a floppy */
1748     if( cmd != aDeArmor && cmd != aEnArmor
1749         && !(cmd == aKMode && argc == 2 ) ) 
1750       {
1751         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
1752             && cmd != aVerify && cmd != aVerifyFiles
1753             && cmd != aSym)
1754           {
1755             if (!sec_nrings || default_keyring) /* add default secret rings */
1756               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
1757             for (sl = sec_nrings; sl; sl = sl->next)
1758               keydb_add_resource ( sl->d, 0, 1 );
1759           }
1760         if( !nrings || default_keyring )  /* add default ring */
1761             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
1762         for(sl = nrings; sl; sl = sl->next )
1763             keydb_add_resource ( sl->d, 0, 0 );
1764       }
1765     FREE_STRLIST(nrings);
1766     FREE_STRLIST(sec_nrings);
1767
1768
1769     if( pwfd != -1 )  /* read the passphrase now. */
1770         read_passphrase_from_fd( pwfd );
1771
1772     fname = argc? *argv : NULL;
1773
1774     switch( cmd ) {
1775       case aPrimegen:
1776       case aPrintMD:
1777       case aPrintMDs:
1778       case aGenRandom:
1779       case aDeArmor:
1780       case aEnArmor:
1781       case aFixTrustDB:
1782         break;
1783       case aKMode:
1784       case aListKeys:
1785       case aListSecretKeys:
1786       case aCheckKeys:
1787         if( opt.with_colons ) /* need this to list the trust */
1788             rc = setup_trustdb(1, trustdb_name );
1789         break;
1790       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1791       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1792       default: rc = setup_trustdb(1, trustdb_name ); break;
1793     }
1794     if( rc )
1795         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1796
1797
1798     switch (cmd) {
1799       case aStore: 
1800       case aSym:  
1801       case aSign: 
1802       case aSignSym: 
1803       case aClearsign: 
1804         if (!opt.quiet && any_explicit_recipient)
1805           log_info (_("WARNING: recipients (-r) given "
1806                       "without using public key encryption\n"));
1807         break;
1808       default:
1809         break;
1810     }
1811
1812     switch( cmd ) {
1813       case aStore: /* only store the file */
1814         if( argc > 1 )
1815             wrong_args(_("--store [filename]"));
1816         if( (rc = encode_store(fname)) )
1817             log_error_f( print_fname_stdin(fname),
1818                         "store failed: %s\n", g10_errstr(rc) );
1819         break;
1820       case aSym: /* encrypt the given file only with the symmetric cipher */
1821         if( argc > 1 )
1822             wrong_args(_("--symmetric [filename]"));
1823         if( (rc = encode_symmetric(fname)) )
1824             log_error_f(print_fname_stdin(fname),
1825                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1826         break;
1827
1828       case aEncr: /* encrypt the given file */
1829         if( argc > 1 )
1830             wrong_args(_("--encrypt [filename]"));
1831         if( (rc = encode_crypt(fname,remusr)) )
1832             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1833         break;
1834
1835       case aEncrFiles: /* encrypt the given files */
1836         encode_crypt_files(argc, argv, remusr);
1837         break;
1838           
1839       case aSign: /* sign the given file */
1840         sl = NULL;
1841         if( detached_sig ) { /* sign all files */
1842             for( ; argc; argc--, argv++ )
1843                 add_to_strlist( &sl, *argv );
1844         }
1845         else {
1846             if( argc > 1 )
1847                 wrong_args(_("--sign [filename]"));
1848             if( argc ) {
1849                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1850                 strcpy(sl->d, fname);
1851             }
1852         }
1853         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1854             log_error("signing failed: %s\n", g10_errstr(rc) );
1855         free_strlist(sl);
1856         break;
1857
1858       case aSignEncr: /* sign and encrypt the given file */
1859         if( argc > 1 )
1860             wrong_args(_("--sign --encrypt [filename]"));
1861         if( argc ) {
1862             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1863             strcpy(sl->d, fname);
1864         }
1865         else
1866             sl = NULL;
1867         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1868             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1869         free_strlist(sl);
1870         break;
1871
1872       case aSignSym: /* sign and conventionally encrypt the given file */
1873         if (argc > 1)
1874             wrong_args(_("--sign --symmetric [filename]"));
1875         rc = sign_symencrypt_file (fname, locusr);
1876         if (rc)
1877             log_error("%s: sign+symmetric failed: %s\n",
1878                       print_fname_stdin(fname), g10_errstr(rc) );
1879         break;
1880
1881       case aClearsign: /* make a clearsig */
1882         if( argc > 1 )
1883             wrong_args(_("--clearsign [filename]"));
1884         if( (rc = clearsign_file(fname, locusr, NULL)) )
1885             log_error("%s: clearsign failed: %s\n",
1886                       print_fname_stdin(fname), g10_errstr(rc) );
1887         break;
1888
1889       case aVerify:
1890         if( (rc = verify_signatures( argc, argv ) ))
1891             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1892         break;
1893
1894       case aVerifyFiles:
1895         if( (rc = verify_files( argc, argv ) ))
1896             log_error("verify files failed: %s\n", g10_errstr(rc) );
1897         break;
1898
1899       case aDecrypt:
1900         if( argc > 1 )
1901             wrong_args(_("--decrypt [filename]"));
1902         if( (rc = decrypt_message( fname ) ))
1903             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1904         break;
1905
1906       case aDecryptFiles:
1907         decrypt_messages(argc, argv);
1908         break;
1909             
1910       case aSignKey: /* sign the key given as argument */
1911         if( argc != 1 )
1912             wrong_args(_("--sign-key user-id"));
1913         username = make_username( fname );
1914         keyedit_menu(fname, locusr, NULL, 1 );
1915         m_free(username);
1916         break;
1917
1918       case aLSignKey:
1919         if( argc != 1 )
1920             wrong_args(_("--lsign-key user-id"));
1921         username = make_username( fname );
1922         keyedit_menu(fname, locusr, NULL, 2 );
1923         m_free(username);
1924         break;
1925
1926       case aNRSignKey:
1927         if( argc != 1 )
1928             wrong_args(_("--nrsign-key user-id"));
1929         username = make_username( fname );
1930         keyedit_menu(fname, locusr, NULL, 3 );
1931         m_free(username);
1932         break;
1933
1934       case aNRLSignKey:
1935         if( argc != 1 )
1936             wrong_args(_("--nrlsign-key user-id"));
1937         username = make_username( fname );
1938         keyedit_menu(fname, locusr, NULL, 4 );
1939         m_free(username);
1940         break;
1941
1942       case aEditKey: /* Edit a key signature */
1943         if( !argc )
1944             wrong_args(_("--edit-key user-id [commands]"));
1945         username = make_username( fname );
1946         if( argc > 1 ) {
1947             sl = NULL;
1948             for( argc--, argv++ ; argc; argc--, argv++ )
1949                 append_to_strlist( &sl, *argv );
1950             keyedit_menu( username, locusr, sl, 0 );
1951             free_strlist(sl);
1952         }
1953         else
1954             keyedit_menu(username, locusr, NULL, 0 );
1955         m_free(username);
1956         break;
1957
1958       case aDeleteKeys:
1959       case aDeleteSecretKeys:
1960       case aDeleteSecretAndPublicKeys:
1961         sl = NULL;
1962         /* I'm adding these in reverse order as add_to_strlist2
1963            reverses them again, and it's easier to understand in the
1964            proper order :) */
1965         for( ; argc; argc-- )
1966           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
1967         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
1968         free_strlist(sl);
1969         break;
1970
1971       case aCheckKeys:
1972         opt.check_sigs = 1;
1973       case aListSigs:
1974         opt.list_sigs = 1;
1975       case aListKeys:
1976         sl = NULL;
1977         for( ; argc; argc--, argv++ )
1978             add_to_strlist2( &sl, *argv, utf8_strings );
1979         public_key_list( sl );
1980         free_strlist(sl);
1981         break;
1982       case aListSecretKeys:
1983         sl = NULL;
1984         for( ; argc; argc--, argv++ )
1985             add_to_strlist2( &sl, *argv, utf8_strings );
1986         secret_key_list( sl );
1987         free_strlist(sl);
1988         break;
1989
1990       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1991         if( argc < 2 ) { /* -kv [userid] */
1992             sl = NULL;
1993             if (argc && **argv)
1994                 add_to_strlist2( &sl, *argv, utf8_strings );
1995             public_key_list( sl );
1996             free_strlist(sl);
1997         }
1998         else if( argc == 2 ) { /* -kv userid keyring */
1999             if( access( argv[1], R_OK ) ) {
2000                 log_error(_("can't open %s: %s\n"),
2001                                print_fname_stdin(argv[1]), strerror(errno));
2002             }
2003             else {
2004                 /* add keyring (default keyrings are not registered in this
2005                  * special case */
2006                 keydb_add_resource( argv[1], 0, 0 );
2007                 sl = NULL;
2008                 if (**argv)
2009                     add_to_strlist2( &sl, *argv, utf8_strings );
2010                 public_key_list( sl );
2011                 free_strlist(sl);
2012             }
2013         }
2014         else
2015             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2016         break;
2017
2018       case aKeygen: /* generate a key */
2019         if( opt.batch ) {
2020             if( argc > 1 )
2021                 wrong_args("--gen-key [parameterfile]");
2022             generate_keypair( argc? *argv : NULL );
2023         }
2024         else {
2025             if( argc )
2026                 wrong_args("--gen-key");
2027             generate_keypair(NULL);
2028         }
2029         break;
2030
2031       case aFastImport:
2032       case aImport:
2033         import_keys( argc? argv:NULL, argc, (cmd == aFastImport),
2034                      NULL, opt.import_options );
2035         break;
2036
2037       case aExport:
2038       case aExportAll:
2039       case aSendKeys:
2040       case aRecvKeys:
2041         sl = NULL;
2042         for( ; argc; argc--, argv++ )
2043             add_to_strlist2( &sl, *argv, utf8_strings );
2044         if( cmd == aSendKeys )
2045             keyserver_export( sl );
2046         else if( cmd == aRecvKeys )
2047             keyserver_import( sl );
2048         else
2049             export_pubkeys( sl, opt.export_options );
2050         free_strlist(sl);
2051         break;
2052
2053      case aSearchKeys:
2054         sl = NULL;
2055         for( ; argc; argc--, argv++ )
2056           append_to_strlist2( &sl, *argv, utf8_strings );
2057
2058         keyserver_search( sl );
2059         free_strlist(sl);
2060         break;
2061
2062       case aRefreshKeys:
2063         sl = NULL;
2064         for( ; argc; argc--, argv++ )
2065             add_to_strlist2( &sl, *argv, utf8_strings );
2066         keyserver_refresh(sl);
2067         free_strlist(sl);
2068         break;
2069
2070       case aExportSecret:
2071         sl = NULL;
2072         for( ; argc; argc--, argv++ )
2073             add_to_strlist2( &sl, *argv, utf8_strings );
2074         export_seckeys( sl );
2075         free_strlist(sl);
2076         break;
2077
2078       case aExportSecretSub:
2079         sl = NULL;
2080         for( ; argc; argc--, argv++ )
2081             add_to_strlist2( &sl, *argv, utf8_strings );
2082         export_secsubkeys( sl );
2083         free_strlist(sl);
2084         break;
2085
2086       case aGenRevoke:
2087         if( argc != 1 )
2088             wrong_args("--gen-revoke user-id");
2089         username =  make_username(*argv);
2090         gen_revoke( username );
2091         m_free( username );
2092         break;
2093
2094       case aDesigRevoke:
2095         if( argc != 1 )
2096             wrong_args("--desig-revoke user-id");
2097         username =  make_username(*argv);
2098         gen_desig_revoke( username );
2099         m_free( username );
2100         break;
2101
2102       case aDeArmor:
2103         if( argc > 1 )
2104             wrong_args("--dearmor [file]");
2105         rc = dearmor_file( argc? *argv: NULL );
2106         if( rc )
2107             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2108         break;
2109
2110       case aEnArmor:
2111         if( argc > 1 )
2112             wrong_args("--enarmor [file]");
2113         rc = enarmor_file( argc? *argv: NULL );
2114         if( rc )
2115             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2116         break;
2117
2118
2119       case aPrimegen:
2120         {   int mode = argc < 2 ? 0 : atoi(*argv);
2121
2122             if( mode == 1 && argc == 2 ) {
2123                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2124             }
2125             else if( mode == 2 && argc == 3 ) {
2126                 mpi_print( stdout, generate_elg_prime(
2127                                              0, atoi(argv[1]),
2128                                              atoi(argv[2]), NULL,NULL ), 1);
2129             }
2130             else if( mode == 3 && argc == 3 ) {
2131                 MPI *factors;
2132                 mpi_print( stdout, generate_elg_prime(
2133                                              1, atoi(argv[1]),
2134                                              atoi(argv[2]), NULL,&factors ), 1);
2135                 putchar('\n');
2136                 mpi_print( stdout, factors[0], 1 ); /* print q */
2137             }
2138             else if( mode == 4 && argc == 3 ) {
2139                 MPI g = mpi_alloc(1);
2140                 mpi_print( stdout, generate_elg_prime(
2141                                                  0, atoi(argv[1]),
2142                                                  atoi(argv[2]), g, NULL ), 1);
2143                 putchar('\n');
2144                 mpi_print( stdout, g, 1 );
2145                 mpi_free(g);
2146             }
2147             else
2148                 wrong_args("--gen-prime mode bits [qbits] ");
2149             putchar('\n');
2150         }
2151         break;
2152
2153       case aGenRandom:
2154         {
2155             int level = argc ? atoi(*argv):0;
2156             int count = argc > 1 ? atoi(argv[1]): 0;
2157             int endless = !count;
2158
2159             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2160                 wrong_args("--gen-random 0|1|2 [count]");
2161
2162             while( endless || count ) {
2163                 byte *p;
2164                 /* Wee need a multiple of 3, so that in case of
2165                    armored output we get a correct string.  No
2166                    linefolding is done, as it is best to levae this to
2167                    other tools */
2168                 size_t n = !endless && count < 99? count : 99;
2169
2170                 p = get_random_bits( n*8, level, 0);
2171               #ifdef HAVE_DOSISH_SYSTEM
2172                 setmode ( fileno(stdout), O_BINARY );
2173               #endif
2174                 if (opt.armor) {
2175                     char *tmp = make_radix64_string (p, n);
2176                     fputs (tmp, stdout);
2177                     m_free (tmp);
2178                     if (n%3 == 1)
2179                       putchar ('=');
2180                     if (n%3)
2181                       putchar ('=');
2182                 } else {
2183                     fwrite( p, n, 1, stdout );
2184                 }
2185                 m_free(p);
2186                 if( !endless )
2187                     count -= n;
2188             }
2189             if (opt.armor)
2190                 putchar ('\n');
2191         }
2192         break;
2193
2194       case aPrintMD:
2195         if( argc < 1)
2196             wrong_args("--print-md algo [files]");
2197         {
2198             int all_algos = (**argv=='*' && !(*argv)[1]);
2199             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2200
2201             if( !algo && !all_algos )
2202                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2203             else {
2204                 argc--; argv++;
2205                 if( !argc )
2206                     print_mds(NULL, algo);
2207                 else {
2208                     for(; argc; argc--, argv++ )
2209                         print_mds(*argv, algo);
2210                 }
2211             }
2212         }
2213         break;
2214
2215       case aPrintMDs: /* old option */
2216         if( !argc )
2217             print_mds(NULL,0);
2218         else {
2219             for(; argc; argc--, argv++ )
2220                 print_mds(*argv,0);
2221         }
2222         break;
2223
2224       case aListTrustDB:
2225         if( !argc )
2226             list_trustdb(NULL);
2227         else {
2228             for( ; argc; argc--, argv++ )
2229                 list_trustdb( *argv );
2230         }
2231         break;
2232
2233       case aUpdateTrustDB:
2234         if( argc )
2235             wrong_args("--update-trustdb");
2236         update_trustdb();
2237         break;
2238
2239       case aCheckTrustDB:
2240         /* Old versions allowed for arguments - ignore them */
2241         check_trustdb();
2242         break;
2243
2244       case aFixTrustDB:
2245         log_error("this command is not yet implemented.\n");
2246         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2247         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2248         break;
2249
2250       case aListTrustPath:
2251         if( !argc )
2252             wrong_args("--list-trust-path <user-ids>");
2253         for( ; argc; argc--, argv++ ) {
2254             username = make_username( *argv );
2255             list_trust_path( username );
2256             m_free(username);
2257         }
2258         break;
2259
2260       case aExportOwnerTrust:
2261         if( argc )
2262             wrong_args("--export-ownertrust");
2263         export_ownertrust();
2264         break;
2265
2266       case aImportOwnerTrust:
2267         if( argc > 1 )
2268             wrong_args("--import-ownertrust [file]");
2269         import_ownertrust( argc? *argv:NULL );
2270         break;
2271       
2272       case aPipeMode:
2273         if ( argc )
2274             wrong_args ("--pipemode");
2275         run_in_pipemode ();
2276         break;
2277
2278       case aRebuildKeydbCaches:
2279         if (argc)
2280             wrong_args ("--rebuild-keydb-caches");
2281         keydb_rebuild_caches ();
2282         break;
2283
2284       case aListPackets:
2285         opt.list_packets=2;
2286       default:
2287         if( argc > 1 )
2288             wrong_args(_("[filename]"));
2289         /* Issue some output for the unix newbie */
2290         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2291                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2292             log_info(_("Go ahead and type your message ...\n"));
2293
2294         if( !(a = iobuf_open(fname)) )
2295             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2296         else {
2297
2298             if( !opt.no_armor ) {
2299                 if( use_armor_filter( a ) ) {
2300                     memset( &afx, 0, sizeof afx);
2301                     iobuf_push_filter( a, armor_filter, &afx );
2302                 }
2303             }
2304             if( cmd == aListPackets ) {
2305                 set_packet_list_mode(1);
2306                 opt.list_packets=1;
2307             }
2308             rc = proc_packets(NULL, a );
2309             if( rc )
2310                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2311             iobuf_close(a);
2312         }
2313         break;
2314     }
2315
2316     /* cleanup */
2317     FREE_STRLIST(remusr);
2318     FREE_STRLIST(locusr);
2319     g10_exit(0);
2320     return 8; /*NEVER REACHED*/
2321 }
2322
2323
2324 void
2325 g10_exit( int rc )
2326 {
2327     update_random_seed_file();
2328     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2329         m_print_stats("on exit");
2330         random_dump_stats();
2331     }
2332     if( opt.debug )
2333         secmem_dump_stats();
2334     secmem_term();
2335     rc = rc? rc : log_get_errorcount(0)? 2 :
2336                         g10_errors_seen? 1 : 0;
2337     exit(rc );
2338 }
2339
2340
2341
2342
2343 static void
2344 print_hex( byte *p, size_t n )
2345 {
2346     int i;
2347
2348     if( n == 20 ) {
2349         for(i=0; i < n ; i++, i++, p += 2 ) {
2350             if( i )
2351                 putchar(' ');
2352             if( i == 10 )
2353                 putchar(' ');
2354             printf("%02X%02X", *p, p[1] );
2355         }
2356     }
2357     else if( n == 24 ) {
2358         for(i=0; i < n ; i += 4, p += 4 ) {
2359             if( i )
2360                 putchar(' ');
2361             if( i == 12 )
2362                 putchar(' ');
2363             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2364         }
2365     }
2366     else {
2367         for(i=0; i < n ; i++, p++ ) {
2368             if( i )
2369                 putchar(' ');
2370             if( i && !(i%8) )
2371                 putchar(' ');
2372             printf("%02X", *p );
2373         }
2374     }
2375 }
2376
2377 static void
2378 print_hashline( MD_HANDLE md, int algo, const char *fname )
2379 {
2380     int i, n;
2381     const byte *p;
2382     
2383     if ( fname ) {
2384         for (p = fname; *p; p++ ) {
2385             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2386                 printf("%%%02X", *p );
2387             else 
2388                 putchar( *p );
2389         }
2390     }
2391     putchar(':');
2392     printf("%d:", algo );
2393     p = md_read( md, algo );
2394     n = md_digest_length(algo);
2395     for(i=0; i < n ; i++, p++ ) 
2396         printf("%02X", *p );
2397     putchar(':');
2398     putchar('\n');
2399 }
2400
2401 static void
2402 print_mds( const char *fname, int algo )
2403 {
2404     FILE *fp;
2405     char buf[1024];
2406     size_t n;
2407     MD_HANDLE md;
2408     char *pname;
2409
2410     if( !fname ) {
2411         fp = stdin;
2412       #ifdef HAVE_DOSISH_SYSTEM
2413         setmode ( fileno(fp) , O_BINARY );
2414       #endif
2415         pname = m_strdup("[stdin]: ");
2416     }
2417     else {
2418         pname = m_alloc(strlen(fname)+3);
2419         strcpy(stpcpy(pname,fname),": ");
2420         fp = fopen( fname, "rb" );
2421     }
2422     if( !fp ) {
2423         log_error("%s%s\n", pname, strerror(errno) );
2424         m_free(pname);
2425         return;
2426     }
2427
2428     md = md_open( 0, 0 );
2429     if( algo )
2430         md_enable( md, algo );
2431     else {
2432         md_enable( md, DIGEST_ALGO_MD5 );
2433         md_enable( md, DIGEST_ALGO_SHA1 );
2434         md_enable( md, DIGEST_ALGO_RMD160 );
2435         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2436             md_enable( md, DIGEST_ALGO_TIGER );
2437     }
2438
2439     while( (n=fread( buf, 1, DIM(buf), fp )) )
2440         md_write( md, buf, n );
2441     if( ferror(fp) )
2442         log_error("%s%s\n", pname, strerror(errno) );
2443     else {
2444         md_final(md);
2445         if ( opt.with_colons ) {
2446             if ( algo ) 
2447                 print_hashline( md, algo, fname );
2448             else {
2449                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2450                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2451                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2452                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2453                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2454             }
2455         }
2456         else {
2457             if( algo ) {
2458                 if( fname )
2459                     fputs( pname, stdout );
2460                 print_hex(md_read(md, algo), md_digest_length(algo) );
2461             }
2462             else {
2463                 printf(  "%s   MD5 = ", fname?pname:"" );
2464                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2465                 printf("\n%s  SHA1 = ", fname?pname:""  );
2466                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2467                 printf("\n%sRMD160 = ", fname?pname:""  );
2468                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2469                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2470                     printf("\n%s TIGER = ", fname?pname:""  );
2471                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2472                 }
2473             }
2474             putchar('\n');
2475         }
2476     }
2477     md_close(md);
2478
2479     if( fp != stdin )
2480         fclose(fp);
2481 }
2482
2483
2484 /****************
2485  * Check the supplied name,value string and add it to the notation
2486  * data to be used for signatures.  which==0 for sig notations, and 1
2487  * for cert notations.
2488 */
2489 static void
2490 add_notation_data( const char *string, int which )
2491 {
2492     const char *s;
2493     STRLIST sl,*notation_data;
2494     int critical=0;
2495     int highbit=0;
2496
2497     if(which)
2498       notation_data=&opt.cert_notation_data;
2499     else
2500       notation_data=&opt.sig_notation_data;
2501
2502     if( *string == '!' ) {
2503         critical = 1;
2504         string++;
2505     }
2506
2507     for( s=string ; *s != '='; s++ ) {
2508         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) ) {
2509             log_error(_("a notation name must have only printable characters "
2510                         "or spaces, and end with an '='\n") );
2511             return;
2512         }
2513     }
2514     /* we only support printable text - therefore we enforce the use
2515      * of only printable characters (an empty value is valid) */
2516     for( s++; *s ; s++ ) {
2517         if( iscntrl(*s) ) {
2518             log_error(_("a notation value must not use "
2519                         "any control characters\n") );
2520             return;
2521         }
2522         else if( *s & 0x80 )
2523             highbit = 1;
2524     }
2525
2526     if( highbit )   /* must use UTF8 encoding */
2527         sl = add_to_strlist2( notation_data, string, utf8_strings );
2528     else
2529         sl = add_to_strlist( notation_data, string );
2530
2531     if( critical )
2532         sl->flags |= 1;
2533 }
2534
2535
2536 static void
2537 add_policy_url( const char *string, int which )
2538 {
2539   int i,critical=0;
2540   STRLIST sl;
2541
2542   if(*string=='!')
2543     {
2544       string++;
2545       critical=1;
2546     }
2547
2548   for(i=0;i<strlen(string);i++)
2549     if(string[i]&0x80 || iscntrl(string[i]))
2550       break;
2551
2552   if(i==0 || i<strlen(string))
2553     {
2554       if(which)
2555         log_error(_("the given certification policy URL is invalid\n"));
2556       else
2557         log_error(_("the given signature policy URL is invalid\n"));
2558     }
2559
2560   if(which)
2561     sl=add_to_strlist( &opt.cert_policy_url, string );
2562   else
2563     sl=add_to_strlist( &opt.sig_policy_url, string );
2564
2565   if(critical)
2566     sl->flags |= 1;    
2567 }