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