* options.h, exec.h, exec.c (set_exec_path, exec_write), g10.c (main),
[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,0))
1365               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1366             else
1367               opt.exec_path_set=1;
1368 #endif
1369             break;
1370           case oNotation:
1371             add_notation_data( pargs.r.ret_str, 0 );
1372             add_notation_data( pargs.r.ret_str, 1 );
1373             break;
1374           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1375           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1376           case oShowNotation: opt.show_notation=1; break;
1377           case oNoShowNotation: opt.show_notation=0; break;
1378           case oUtf8Strings: utf8_strings = 1; break;
1379           case oNoUtf8Strings: utf8_strings = 0; break;
1380           case oDisableCipherAlgo:
1381                 disable_cipher_algo( string_to_cipher_algo(pargs.r.ret_str) );
1382                 break;
1383           case oDisablePubkeyAlgo:
1384                 disable_pubkey_algo( string_to_pubkey_algo(pargs.r.ret_str) );
1385                 break;
1386           case oNoSigCache: opt.no_sig_cache = 1; break;
1387           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1388           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1389           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1390           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1391           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1392           case oNoLiteral: opt.no_literal = 1; break;
1393           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1394           case oHonorHttpProxy:
1395                 opt.keyserver_options.honor_http_proxy = 1;
1396                 deprecated_warning(configname,configlineno,
1397                                    "--honor-http-proxy",
1398                                    "--keyserver-options ",
1399                                    "honor-http-proxy");
1400                 break;
1401           case oFastListMode: opt.fast_list_mode = 1; break;
1402           case oFixedListMode: opt.fixed_list_mode = 1; break;
1403           case oListOnly: opt.list_only=1; break;
1404           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1405           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1406           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1407           case oNoRandomSeedFile: use_random_seed = 0; break;
1408           case oAutoKeyRetrieve:
1409           case oNoAutoKeyRetrieve:
1410                 opt.keyserver_options.auto_key_retrieve=
1411                                              (pargs.r_opt==oAutoKeyRetrieve);
1412                 deprecated_warning(configname,configlineno,
1413                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1414                                "--no-auto-key-retrieve","--keyserver-options ",
1415                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1416                                "no-auto-key-retrieve");
1417                 break;
1418           case oShowSessionKey: opt.show_session_key = 1; break;
1419           case oOverrideSessionKey:
1420                 opt.override_session_key = pargs.r.ret_str;
1421                 break;
1422           case oMergeOnly: opt.merge_only = 1; break;
1423           case oAllowSecretKeyImport: /* obsolete */ break;
1424           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1425           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1426           case oEnableSpecialFilenames:
1427             iobuf_enable_special_filenames (1);
1428             break;
1429           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1430           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1431           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1432           case oPreservePermissions: opt.preserve_permissions=1; break;
1433           case oDefaultPreferenceList:
1434             opt.def_preference_list = pargs.r.ret_str;
1435             break;
1436           case oPersonalCipherPreferences:
1437             pers_cipher_list=pargs.r.ret_str;
1438             break;
1439           case oPersonalDigestPreferences:
1440             pers_digest_list=pargs.r.ret_str;
1441             break;
1442           case oPersonalCompressPreferences:
1443             pers_compress_list=pargs.r.ret_str;
1444             break;
1445           case oDisplay: opt.display = pargs.r.ret_str; break;
1446           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1447           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1448           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1449           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1450           case oGroup: add_group(pargs.r.ret_str); break;
1451           default : pargs.err = configfp? 1:2; break;
1452         }
1453     }
1454
1455     if( configfp ) {
1456         fclose( configfp );
1457         configfp = NULL;
1458         m_free(configname); configname = NULL;
1459         goto next_pass;
1460     }
1461     m_free( configname ); configname = NULL;
1462     if( log_get_errorcount(0) )
1463         g10_exit(2);
1464     if( nogreeting )
1465         greeting = 0;
1466
1467     if( greeting ) {
1468         fprintf(stderr, "%s %s; %s\n",
1469                         strusage(11), strusage(13), strusage(14) );
1470         fprintf(stderr, "%s\n", strusage(15) );
1471     }
1472   #ifdef IS_DEVELOPMENT_VERSION
1473     if( !opt.batch ) {
1474         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1475         log_info("It is only intended for test purposes and should NOT be\n");
1476         log_info("used in a production environment or with production keys!\n");
1477     }
1478   #endif
1479
1480     check_permissions(opt.homedir,0,0);
1481
1482     if(unsafe_files)
1483       {
1484         STRLIST tmp;
1485
1486         for(tmp=unsafe_files;tmp;tmp=tmp->next)
1487           check_permissions(tmp->d,0,0);
1488
1489         free_strlist(unsafe_files);
1490       }
1491
1492     if(extensions)
1493       {
1494         STRLIST tmp;
1495
1496         for(tmp=extensions;tmp;tmp=tmp->next)
1497           check_permissions(tmp->d,1,0);
1498
1499         free_strlist(extensions);
1500       }
1501
1502     if( may_coredump && !opt.quiet )
1503         log_info(_("WARNING: program may create a core file!\n"));
1504
1505     if (eyes_only) {
1506       if (opt.set_filename)
1507           log_info(_("WARNING: %s overrides %s\n"),
1508                    "--for-your-eyes-only","--set-filename");
1509
1510       opt.set_filename="_CONSOLE";
1511     }
1512
1513     if (opt.no_literal) {
1514         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
1515         if (opt.textmode)
1516             log_error(_("%s not allowed with %s!\n"),
1517                        "--textmode", "--no-literal" );
1518         if (opt.set_filename)
1519             log_error(_("%s makes no sense with %s!\n"),
1520                         eyes_only?"--for-your-eyes-only":"--set-filename",
1521                         "--no-literal" );
1522     }
1523
1524     if (opt.set_filesize)
1525         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
1526     if( opt.batch )
1527         tty_batchmode( 1 );
1528
1529     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
1530
1531     set_debug();
1532     g10_opt_homedir = opt.homedir;
1533
1534     /* Do these after the switch(), so they can override settings. */
1535     if(opt.pgp2 && (opt.pgp6 || opt.pgp7))
1536       log_error(_("%s not allowed with %s!\n"),
1537                 "--pgp2",opt.pgp6?"--pgp6":"--pgp7");
1538     else
1539       {
1540         if(opt.pgp2)
1541           {
1542             int unusable=0;
1543
1544             if(cmd==aSign && !detached_sig)
1545               {
1546                 log_info(_("you can only make detached or clear signatures "
1547                            "while in --pgp2 mode\n"));
1548                 unusable=1;
1549               }
1550             else if(cmd==aSignEncr || cmd==aSignSym)
1551               {
1552                 log_info(_("you can't sign and encrypt at the "
1553                            "same time while in --pgp2 mode\n"));
1554                 unusable=1;
1555               }
1556             else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
1557               {
1558                 log_info(_("you must use files (and not a pipe) when "
1559                            "working with --pgp2 enabled.\n"));
1560                 unusable=1;
1561               }
1562             else if(cmd==aEncr || cmd==aSym)
1563               {
1564                 /* Everything else should work without IDEA (except using
1565                    a secret key encrypted with IDEA and setting an IDEA
1566                    preference, but those have their own error
1567                    messages). */
1568
1569                 if(check_cipher_algo(CIPHER_ALGO_IDEA))
1570                   {
1571                     log_info(_("encrypting a message in --pgp2 mode requires "
1572                                "the IDEA cipher\n"));
1573                     idea_cipher_warn(1);
1574                     unusable=1;
1575                   }
1576                 else if(cmd==aSym)
1577                   {
1578                     m_free(def_cipher_string);
1579                     def_cipher_string = m_strdup("idea");
1580                   }
1581               }
1582
1583             if(unusable)
1584               {
1585                 log_info(_("this message may not be usable by PGP 2.x\n"));
1586                 opt.pgp2=0;
1587               }
1588             else
1589               {
1590                 opt.rfc1991 = 1;
1591                 opt.rfc2440 = 0;
1592                 opt.force_mdc = 0;
1593                 opt.disable_mdc = 1;
1594                 opt.force_v4_certs = 0;
1595                 opt.sk_comments = 0;
1596                 opt.escape_from = 1;
1597                 opt.force_v3_sigs = 1;
1598                 opt.pgp2_workarounds = 1;
1599                 opt.ask_sig_expire = 0;
1600                 opt.ask_cert_expire = 0;
1601                 m_free(def_digest_string);
1602                 def_digest_string = m_strdup("md5");
1603                 opt.def_compress_algo = 1;
1604               }
1605           }
1606
1607         if(opt.pgp6 || opt.pgp7)
1608           {
1609             opt.sk_comments=0;
1610             opt.escape_from=1;
1611             opt.force_v3_sigs=1;
1612             opt.ask_sig_expire=0;
1613             opt.def_compress_algo=1;
1614
1615             if(opt.pgp6) /* pgp7 has MDC */
1616               {
1617                 opt.force_mdc=0;
1618                 opt.disable_mdc=1;
1619               }
1620           }
1621       }
1622
1623     /* must do this after dropping setuid, because string_to...
1624      * may try to load an module */
1625     if( def_cipher_string ) {
1626         opt.def_cipher_algo = string_to_cipher_algo(def_cipher_string);
1627         if(opt.def_cipher_algo==0 &&
1628            ascii_strcasecmp(def_cipher_string,"idea")==0)
1629           idea_cipher_warn(1);
1630         m_free(def_cipher_string); def_cipher_string = NULL;
1631         if( check_cipher_algo(opt.def_cipher_algo) )
1632             log_error(_("selected cipher algorithm is invalid\n"));
1633     }
1634     if( def_digest_string ) {
1635         opt.def_digest_algo = string_to_digest_algo(def_digest_string);
1636         m_free(def_digest_string); def_digest_string = NULL;
1637         if( check_digest_algo(opt.def_digest_algo) )
1638             log_error(_("selected digest algorithm is invalid\n"));
1639     }
1640     if( cert_digest_string ) {
1641         opt.cert_digest_algo = string_to_digest_algo(cert_digest_string);
1642         m_free(cert_digest_string); cert_digest_string = NULL;
1643         if( check_digest_algo(opt.cert_digest_algo) )
1644             log_error(_("selected certification digest algorithm is invalid\n"));
1645     }
1646     if( s2k_cipher_string ) {
1647         opt.s2k_cipher_algo = string_to_cipher_algo(s2k_cipher_string);
1648         m_free(s2k_cipher_string); s2k_cipher_string = NULL;
1649         if( check_cipher_algo(opt.s2k_cipher_algo) )
1650             log_error(_("selected cipher algorithm is invalid\n"));
1651     }
1652     if( s2k_digest_string ) {
1653         opt.s2k_digest_algo = string_to_digest_algo(s2k_digest_string);
1654         m_free(s2k_digest_string); s2k_digest_string = NULL;
1655         if( check_digest_algo(opt.s2k_digest_algo) )
1656             log_error(_("selected digest algorithm is invalid\n"));
1657     }
1658     if( opt.def_compress_algo < -1 || opt.def_compress_algo > 2 )
1659         log_error(_("compress algorithm must be in range %d..%d\n"), 0, 2);
1660     if( opt.completes_needed < 1 )
1661         log_error(_("completes-needed must be greater than 0\n"));
1662     if( opt.marginals_needed < 2 )
1663         log_error(_("marginals-needed must be greater than 1\n"));
1664     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
1665         log_error(_("max-cert-depth must be in range 1 to 255\n"));
1666     switch( opt.s2k_mode ) {
1667       case 0:
1668         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
1669         break;
1670       case 1: case 3: break;
1671       default:
1672         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
1673     }
1674
1675     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
1676       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
1677
1678     /* This isn't actually needed, but does serve to error out if the
1679        string is invalid. */
1680     if(opt.def_preference_list &&
1681         keygen_set_std_prefs(opt.def_preference_list,0))
1682       log_error(_("invalid default preferences\n"));
1683
1684     /* We provide defaults for the personal digest list */
1685     if(!pers_digest_list)
1686       pers_digest_list="h2";
1687
1688     if(pers_cipher_list &&
1689        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
1690       log_error(_("invalid personal cipher preferences\n"));
1691
1692     if(pers_digest_list &&
1693        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
1694       log_error(_("invalid personal digest preferences\n"));
1695
1696     if(pers_compress_list &&
1697        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
1698       log_error(_("invalid personal compress preferences\n"));
1699
1700     if( log_get_errorcount(0) )
1701         g10_exit(2);
1702
1703     /* set the random seed file */
1704     if( use_random_seed ) {
1705         char *p = make_filename(opt.homedir, "random_seed", NULL );
1706         check_permissions(p,0,0);
1707         set_random_seed_file(p);
1708         m_free(p);
1709     }
1710
1711     if( !cmd && opt.fingerprint && !with_fpr ) {
1712         set_cmd( &cmd, aListKeys);
1713     }
1714
1715     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
1716         if( cmd == aKModeC ) {
1717             opt.fingerprint = 1;
1718             cmd = aKMode;
1719         }
1720         opt.list_sigs = 0;
1721         if( opt.verbose > 2 )
1722             opt.check_sigs++;
1723         if( opt.verbose > 1 )
1724             opt.list_sigs++;
1725
1726         opt.verbose = opt.verbose > 1;
1727         g10_opt_verbose = opt.verbose;
1728     }
1729
1730     /* Compression algorithm 0 means no compression at all */
1731     if( opt.def_compress_algo == 0)
1732         opt.compress = 0;
1733
1734     /* kludge to let -sat generate a clear text signature */
1735     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
1736         cmd = aClearsign;
1737
1738     if( opt.verbose > 1 )
1739         set_packet_list_mode(1);
1740
1741     /* Add the keyrings, but not for some special commands and not in
1742        case of "-kvv userid keyring".  Also avoid adding the secret
1743        keyring for a couple of commands to avoid unneeded access in
1744        case the secrings are stored on a floppy */
1745     if( cmd != aDeArmor && cmd != aEnArmor
1746         && !(cmd == aKMode && argc == 2 ) ) 
1747       {
1748         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
1749             && cmd != aVerify && cmd != aVerifyFiles
1750             && cmd != aSym)
1751           {
1752             if (!sec_nrings || default_keyring) /* add default secret rings */
1753               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
1754             for (sl = sec_nrings; sl; sl = sl->next)
1755               keydb_add_resource ( sl->d, 0, 1 );
1756           }
1757         if( !nrings || default_keyring )  /* add default ring */
1758             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
1759         for(sl = nrings; sl; sl = sl->next )
1760             keydb_add_resource ( sl->d, 0, 0 );
1761       }
1762     FREE_STRLIST(nrings);
1763     FREE_STRLIST(sec_nrings);
1764
1765
1766     if( pwfd != -1 )  /* read the passphrase now. */
1767         read_passphrase_from_fd( pwfd );
1768
1769     fname = argc? *argv : NULL;
1770
1771     switch( cmd ) {
1772       case aPrimegen:
1773       case aPrintMD:
1774       case aPrintMDs:
1775       case aGenRandom:
1776       case aDeArmor:
1777       case aEnArmor:
1778       case aFixTrustDB:
1779         break;
1780       case aKMode:
1781       case aListKeys:
1782       case aListSecretKeys:
1783       case aCheckKeys:
1784         if( opt.with_colons ) /* need this to list the trust */
1785             rc = setup_trustdb(1, trustdb_name );
1786         break;
1787       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
1788       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
1789       default: rc = setup_trustdb(1, trustdb_name ); break;
1790     }
1791     if( rc )
1792         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
1793
1794
1795     switch (cmd) {
1796       case aStore: 
1797       case aSym:  
1798       case aSign: 
1799       case aSignSym: 
1800       case aClearsign: 
1801         if (!opt.quiet && any_explicit_recipient)
1802           log_info (_("WARNING: recipients (-r) given "
1803                       "without using public key encryption\n"));
1804         break;
1805       default:
1806         break;
1807     }
1808
1809     switch( cmd ) {
1810       case aStore: /* only store the file */
1811         if( argc > 1 )
1812             wrong_args(_("--store [filename]"));
1813         if( (rc = encode_store(fname)) )
1814             log_error_f( print_fname_stdin(fname),
1815                         "store failed: %s\n", g10_errstr(rc) );
1816         break;
1817       case aSym: /* encrypt the given file only with the symmetric cipher */
1818         if( argc > 1 )
1819             wrong_args(_("--symmetric [filename]"));
1820         if( (rc = encode_symmetric(fname)) )
1821             log_error_f(print_fname_stdin(fname),
1822                         "symmetric encryption failed: %s\n",g10_errstr(rc) );
1823         break;
1824
1825       case aEncr: /* encrypt the given file */
1826         if( argc > 1 )
1827             wrong_args(_("--encrypt [filename]"));
1828         if( (rc = encode_crypt(fname,remusr)) )
1829             log_error("%s: encryption failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1830         break;
1831
1832       case aEncrFiles: /* encrypt the given files */
1833         encode_crypt_files(argc, argv, remusr);
1834         break;
1835           
1836       case aSign: /* sign the given file */
1837         sl = NULL;
1838         if( detached_sig ) { /* sign all files */
1839             for( ; argc; argc--, argv++ )
1840                 add_to_strlist( &sl, *argv );
1841         }
1842         else {
1843             if( argc > 1 )
1844                 wrong_args(_("--sign [filename]"));
1845             if( argc ) {
1846                 sl = m_alloc_clear( sizeof *sl + strlen(fname));
1847                 strcpy(sl->d, fname);
1848             }
1849         }
1850         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
1851             log_error("signing failed: %s\n", g10_errstr(rc) );
1852         free_strlist(sl);
1853         break;
1854
1855       case aSignEncr: /* sign and encrypt the given file */
1856         if( argc > 1 )
1857             wrong_args(_("--sign --encrypt [filename]"));
1858         if( argc ) {
1859             sl = m_alloc_clear( sizeof *sl + strlen(fname));
1860             strcpy(sl->d, fname);
1861         }
1862         else
1863             sl = NULL;
1864         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
1865             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), g10_errstr(rc) );
1866         free_strlist(sl);
1867         break;
1868
1869       case aSignSym: /* sign and conventionally encrypt the given file */
1870         if (argc > 1)
1871             wrong_args(_("--sign --symmetric [filename]"));
1872         rc = sign_symencrypt_file (fname, locusr);
1873         if (rc)
1874             log_error("%s: sign+symmetric failed: %s\n",
1875                       print_fname_stdin(fname), g10_errstr(rc) );
1876         break;
1877
1878       case aClearsign: /* make a clearsig */
1879         if( argc > 1 )
1880             wrong_args(_("--clearsign [filename]"));
1881         if( (rc = clearsign_file(fname, locusr, NULL)) )
1882             log_error("%s: clearsign failed: %s\n",
1883                       print_fname_stdin(fname), g10_errstr(rc) );
1884         break;
1885
1886       case aVerify:
1887         if( (rc = verify_signatures( argc, argv ) ))
1888             log_error("verify signatures failed: %s\n", g10_errstr(rc) );
1889         break;
1890
1891       case aVerifyFiles:
1892         if( (rc = verify_files( argc, argv ) ))
1893             log_error("verify files failed: %s\n", g10_errstr(rc) );
1894         break;
1895
1896       case aDecrypt:
1897         if( argc > 1 )
1898             wrong_args(_("--decrypt [filename]"));
1899         if( (rc = decrypt_message( fname ) ))
1900             log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
1901         break;
1902
1903       case aDecryptFiles:
1904         decrypt_messages(argc, argv);
1905         break;
1906             
1907       case aSignKey: /* sign the key given as argument */
1908         if( argc != 1 )
1909             wrong_args(_("--sign-key user-id"));
1910         username = make_username( fname );
1911         keyedit_menu(fname, locusr, NULL, 1 );
1912         m_free(username);
1913         break;
1914
1915       case aLSignKey:
1916         if( argc != 1 )
1917             wrong_args(_("--lsign-key user-id"));
1918         username = make_username( fname );
1919         keyedit_menu(fname, locusr, NULL, 2 );
1920         m_free(username);
1921         break;
1922
1923       case aNRSignKey:
1924         if( argc != 1 )
1925             wrong_args(_("--nrsign-key user-id"));
1926         username = make_username( fname );
1927         keyedit_menu(fname, locusr, NULL, 3 );
1928         m_free(username);
1929         break;
1930
1931       case aNRLSignKey:
1932         if( argc != 1 )
1933             wrong_args(_("--nrlsign-key user-id"));
1934         username = make_username( fname );
1935         keyedit_menu(fname, locusr, NULL, 4 );
1936         m_free(username);
1937         break;
1938
1939       case aEditKey: /* Edit a key signature */
1940         if( !argc )
1941             wrong_args(_("--edit-key user-id [commands]"));
1942         username = make_username( fname );
1943         if( argc > 1 ) {
1944             sl = NULL;
1945             for( argc--, argv++ ; argc; argc--, argv++ )
1946                 append_to_strlist( &sl, *argv );
1947             keyedit_menu( username, locusr, sl, 0 );
1948             free_strlist(sl);
1949         }
1950         else
1951             keyedit_menu(username, locusr, NULL, 0 );
1952         m_free(username);
1953         break;
1954
1955       case aDeleteKeys:
1956       case aDeleteSecretKeys:
1957       case aDeleteSecretAndPublicKeys:
1958         sl = NULL;
1959         /* I'm adding these in reverse order as add_to_strlist2
1960            reverses them again, and it's easier to understand in the
1961            proper order :) */
1962         for( ; argc; argc-- )
1963           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
1964         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
1965         free_strlist(sl);
1966         break;
1967
1968       case aCheckKeys:
1969         opt.check_sigs = 1;
1970       case aListSigs:
1971         opt.list_sigs = 1;
1972       case aListKeys:
1973         sl = NULL;
1974         for( ; argc; argc--, argv++ )
1975             add_to_strlist2( &sl, *argv, utf8_strings );
1976         public_key_list( sl );
1977         free_strlist(sl);
1978         break;
1979       case aListSecretKeys:
1980         sl = NULL;
1981         for( ; argc; argc--, argv++ )
1982             add_to_strlist2( &sl, *argv, utf8_strings );
1983         secret_key_list( sl );
1984         free_strlist(sl);
1985         break;
1986
1987       case aKMode: /* list keyring -- NOTE: This will be removed soon */
1988         if( argc < 2 ) { /* -kv [userid] */
1989             sl = NULL;
1990             if (argc && **argv)
1991                 add_to_strlist2( &sl, *argv, utf8_strings );
1992             public_key_list( sl );
1993             free_strlist(sl);
1994         }
1995         else if( argc == 2 ) { /* -kv userid keyring */
1996             if( access( argv[1], R_OK ) ) {
1997                 log_error(_("can't open %s: %s\n"),
1998                                print_fname_stdin(argv[1]), strerror(errno));
1999             }
2000             else {
2001                 /* add keyring (default keyrings are not registered in this
2002                  * special case */
2003                 keydb_add_resource( argv[1], 0, 0 );
2004                 sl = NULL;
2005                 if (**argv)
2006                     add_to_strlist2( &sl, *argv, utf8_strings );
2007                 public_key_list( sl );
2008                 free_strlist(sl);
2009             }
2010         }
2011         else
2012             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2013         break;
2014
2015       case aKeygen: /* generate a key */
2016         if( opt.batch ) {
2017             if( argc > 1 )
2018                 wrong_args("--gen-key [parameterfile]");
2019             generate_keypair( argc? *argv : NULL );
2020         }
2021         else {
2022             if( argc )
2023                 wrong_args("--gen-key");
2024             generate_keypair(NULL);
2025         }
2026         break;
2027
2028       case aFastImport:
2029       case aImport:
2030         import_keys( argc? argv:NULL, argc, (cmd == aFastImport), NULL );
2031         break;
2032
2033       case aExport:
2034       case aExportAll:
2035       case aSendKeys:
2036       case aRecvKeys:
2037         sl = NULL;
2038         for( ; argc; argc--, argv++ )
2039             add_to_strlist2( &sl, *argv, utf8_strings );
2040         if( cmd == aSendKeys )
2041             keyserver_export( sl );
2042         else if( cmd == aRecvKeys )
2043             keyserver_import( sl );
2044         else
2045             export_pubkeys( sl, opt.export_options );
2046         free_strlist(sl);
2047         break;
2048
2049      case aSearchKeys:
2050         sl = NULL;
2051         for( ; argc; argc--, argv++ )
2052           append_to_strlist2( &sl, *argv, utf8_strings );
2053
2054         keyserver_search( sl );
2055         free_strlist(sl);
2056         break;
2057
2058       case aRefreshKeys:
2059         sl = NULL;
2060         for( ; argc; argc--, argv++ )
2061             add_to_strlist2( &sl, *argv, utf8_strings );
2062         keyserver_refresh(sl);
2063         free_strlist(sl);
2064         break;
2065
2066       case aExportSecret:
2067         sl = NULL;
2068         for( ; argc; argc--, argv++ )
2069             add_to_strlist2( &sl, *argv, utf8_strings );
2070         export_seckeys( sl );
2071         free_strlist(sl);
2072         break;
2073
2074       case aExportSecretSub:
2075         sl = NULL;
2076         for( ; argc; argc--, argv++ )
2077             add_to_strlist2( &sl, *argv, utf8_strings );
2078         export_secsubkeys( sl );
2079         free_strlist(sl);
2080         break;
2081
2082       case aGenRevoke:
2083         if( argc != 1 )
2084             wrong_args("--gen-revoke user-id");
2085         username =  make_username(*argv);
2086         gen_revoke( username );
2087         m_free( username );
2088         break;
2089
2090       case aDesigRevoke:
2091         if( argc != 1 )
2092             wrong_args("--desig-revoke user-id");
2093         username =  make_username(*argv);
2094         gen_desig_revoke( username );
2095         m_free( username );
2096         break;
2097
2098       case aDeArmor:
2099         if( argc > 1 )
2100             wrong_args("--dearmor [file]");
2101         rc = dearmor_file( argc? *argv: NULL );
2102         if( rc )
2103             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
2104         break;
2105
2106       case aEnArmor:
2107         if( argc > 1 )
2108             wrong_args("--enarmor [file]");
2109         rc = enarmor_file( argc? *argv: NULL );
2110         if( rc )
2111             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
2112         break;
2113
2114
2115       case aPrimegen:
2116         {   int mode = argc < 2 ? 0 : atoi(*argv);
2117
2118             if( mode == 1 && argc == 2 ) {
2119                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2120             }
2121             else if( mode == 2 && argc == 3 ) {
2122                 mpi_print( stdout, generate_elg_prime(
2123                                              0, atoi(argv[1]),
2124                                              atoi(argv[2]), NULL,NULL ), 1);
2125             }
2126             else if( mode == 3 && argc == 3 ) {
2127                 MPI *factors;
2128                 mpi_print( stdout, generate_elg_prime(
2129                                              1, atoi(argv[1]),
2130                                              atoi(argv[2]), NULL,&factors ), 1);
2131                 putchar('\n');
2132                 mpi_print( stdout, factors[0], 1 ); /* print q */
2133             }
2134             else if( mode == 4 && argc == 3 ) {
2135                 MPI g = mpi_alloc(1);
2136                 mpi_print( stdout, generate_elg_prime(
2137                                                  0, atoi(argv[1]),
2138                                                  atoi(argv[2]), g, NULL ), 1);
2139                 putchar('\n');
2140                 mpi_print( stdout, g, 1 );
2141                 mpi_free(g);
2142             }
2143             else
2144                 wrong_args("--gen-prime mode bits [qbits] ");
2145             putchar('\n');
2146         }
2147         break;
2148
2149       case aGenRandom:
2150         {
2151             int level = argc ? atoi(*argv):0;
2152             int count = argc > 1 ? atoi(argv[1]): 0;
2153             int endless = !count;
2154
2155             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2156                 wrong_args("--gen-random 0|1|2 [count]");
2157
2158             while( endless || count ) {
2159                 byte *p;
2160                 /* Wee need a multiple of 3, so that in case of
2161                    armored output we get a correct string.  No
2162                    linefolding is done, as it is best to levae this to
2163                    other tools */
2164                 size_t n = !endless && count < 99? count : 99;
2165
2166                 p = get_random_bits( n*8, level, 0);
2167               #ifdef HAVE_DOSISH_SYSTEM
2168                 setmode ( fileno(stdout), O_BINARY );
2169               #endif
2170                 if (opt.armor) {
2171                     char *tmp = make_radix64_string (p, n);
2172                     fputs (tmp, stdout);
2173                     m_free (tmp);
2174                     if (n%3 == 1)
2175                       putchar ('=');
2176                     if (n%3)
2177                       putchar ('=');
2178                 } else {
2179                     fwrite( p, n, 1, stdout );
2180                 }
2181                 m_free(p);
2182                 if( !endless )
2183                     count -= n;
2184             }
2185             if (opt.armor)
2186                 putchar ('\n');
2187         }
2188         break;
2189
2190       case aPrintMD:
2191         if( argc < 1)
2192             wrong_args("--print-md algo [files]");
2193         {
2194             int all_algos = (**argv=='*' && !(*argv)[1]);
2195             int algo = all_algos? 0 : string_to_digest_algo(*argv);
2196
2197             if( !algo && !all_algos )
2198                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2199             else {
2200                 argc--; argv++;
2201                 if( !argc )
2202                     print_mds(NULL, algo);
2203                 else {
2204                     for(; argc; argc--, argv++ )
2205                         print_mds(*argv, algo);
2206                 }
2207             }
2208         }
2209         break;
2210
2211       case aPrintMDs: /* old option */
2212         if( !argc )
2213             print_mds(NULL,0);
2214         else {
2215             for(; argc; argc--, argv++ )
2216                 print_mds(*argv,0);
2217         }
2218         break;
2219
2220       case aListTrustDB:
2221         if( !argc )
2222             list_trustdb(NULL);
2223         else {
2224             for( ; argc; argc--, argv++ )
2225                 list_trustdb( *argv );
2226         }
2227         break;
2228
2229       case aUpdateTrustDB:
2230         if( argc )
2231             wrong_args("--update-trustdb");
2232         update_trustdb();
2233         break;
2234
2235       case aCheckTrustDB:
2236         /* Old versions allowed for arguments - ignore them */
2237         check_trustdb();
2238         break;
2239
2240       case aFixTrustDB:
2241         log_error("this command is not yet implemented.\n");
2242         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2243         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2244         break;
2245
2246       case aListTrustPath:
2247         if( !argc )
2248             wrong_args("--list-trust-path <user-ids>");
2249         for( ; argc; argc--, argv++ ) {
2250             username = make_username( *argv );
2251             list_trust_path( username );
2252             m_free(username);
2253         }
2254         break;
2255
2256       case aExportOwnerTrust:
2257         if( argc )
2258             wrong_args("--export-ownertrust");
2259         export_ownertrust();
2260         break;
2261
2262       case aImportOwnerTrust:
2263         if( argc > 1 )
2264             wrong_args("--import-ownertrust [file]");
2265         import_ownertrust( argc? *argv:NULL );
2266         break;
2267       
2268       case aPipeMode:
2269         if ( argc )
2270             wrong_args ("--pipemode");
2271         run_in_pipemode ();
2272         break;
2273
2274       case aRebuildKeydbCaches:
2275         if (argc)
2276             wrong_args ("--rebuild-keydb-caches");
2277         keydb_rebuild_caches ();
2278         break;
2279
2280       case aListPackets:
2281         opt.list_packets=2;
2282       default:
2283         if( argc > 1 )
2284             wrong_args(_("[filename]"));
2285         /* Issue some output for the unix newbie */
2286         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2287                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2288             log_info(_("Go ahead and type your message ...\n"));
2289
2290         if( !(a = iobuf_open(fname)) )
2291             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2292         else {
2293
2294             if( !opt.no_armor ) {
2295                 if( use_armor_filter( a ) ) {
2296                     memset( &afx, 0, sizeof afx);
2297                     iobuf_push_filter( a, armor_filter, &afx );
2298                 }
2299             }
2300             if( cmd == aListPackets ) {
2301                 set_packet_list_mode(1);
2302                 opt.list_packets=1;
2303             }
2304             rc = proc_packets(NULL, a );
2305             if( rc )
2306                 log_error("processing message failed: %s\n", g10_errstr(rc) );
2307             iobuf_close(a);
2308         }
2309         break;
2310     }
2311
2312     /* cleanup */
2313     FREE_STRLIST(remusr);
2314     FREE_STRLIST(locusr);
2315     g10_exit(0);
2316     return 8; /*NEVER REACHED*/
2317 }
2318
2319
2320 void
2321 g10_exit( int rc )
2322 {
2323     update_random_seed_file();
2324     if( opt.debug & DBG_MEMSTAT_VALUE ) {
2325         m_print_stats("on exit");
2326         random_dump_stats();
2327     }
2328     if( opt.debug )
2329         secmem_dump_stats();
2330     secmem_term();
2331     rc = rc? rc : log_get_errorcount(0)? 2 :
2332                         g10_errors_seen? 1 : 0;
2333     exit(rc );
2334 }
2335
2336
2337
2338
2339 static void
2340 print_hex( byte *p, size_t n )
2341 {
2342     int i;
2343
2344     if( n == 20 ) {
2345         for(i=0; i < n ; i++, i++, p += 2 ) {
2346             if( i )
2347                 putchar(' ');
2348             if( i == 10 )
2349                 putchar(' ');
2350             printf("%02X%02X", *p, p[1] );
2351         }
2352     }
2353     else if( n == 24 ) {
2354         for(i=0; i < n ; i += 4, p += 4 ) {
2355             if( i )
2356                 putchar(' ');
2357             if( i == 12 )
2358                 putchar(' ');
2359             printf("%02X%02X%02X%02X", *p, p[1], p[2], p[3] );
2360         }
2361     }
2362     else {
2363         for(i=0; i < n ; i++, p++ ) {
2364             if( i )
2365                 putchar(' ');
2366             if( i && !(i%8) )
2367                 putchar(' ');
2368             printf("%02X", *p );
2369         }
2370     }
2371 }
2372
2373 static void
2374 print_hashline( MD_HANDLE md, int algo, const char *fname )
2375 {
2376     int i, n;
2377     const byte *p;
2378     
2379     if ( fname ) {
2380         for (p = fname; *p; p++ ) {
2381             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
2382                 printf("%%%02X", *p );
2383             else 
2384                 putchar( *p );
2385         }
2386     }
2387     putchar(':');
2388     printf("%d:", algo );
2389     p = md_read( md, algo );
2390     n = md_digest_length(algo);
2391     for(i=0; i < n ; i++, p++ ) 
2392         printf("%02X", *p );
2393     putchar(':');
2394     putchar('\n');
2395 }
2396
2397 static void
2398 print_mds( const char *fname, int algo )
2399 {
2400     FILE *fp;
2401     char buf[1024];
2402     size_t n;
2403     MD_HANDLE md;
2404     char *pname;
2405
2406     if( !fname ) {
2407         fp = stdin;
2408       #ifdef HAVE_DOSISH_SYSTEM
2409         setmode ( fileno(fp) , O_BINARY );
2410       #endif
2411         pname = m_strdup("[stdin]: ");
2412     }
2413     else {
2414         pname = m_alloc(strlen(fname)+3);
2415         strcpy(stpcpy(pname,fname),": ");
2416         fp = fopen( fname, "rb" );
2417     }
2418     if( !fp ) {
2419         log_error("%s%s\n", pname, strerror(errno) );
2420         m_free(pname);
2421         return;
2422     }
2423
2424     md = md_open( 0, 0 );
2425     if( algo )
2426         md_enable( md, algo );
2427     else {
2428         md_enable( md, DIGEST_ALGO_MD5 );
2429         md_enable( md, DIGEST_ALGO_SHA1 );
2430         md_enable( md, DIGEST_ALGO_RMD160 );
2431         if( !check_digest_algo(DIGEST_ALGO_TIGER) )
2432             md_enable( md, DIGEST_ALGO_TIGER );
2433     }
2434
2435     while( (n=fread( buf, 1, DIM(buf), fp )) )
2436         md_write( md, buf, n );
2437     if( ferror(fp) )
2438         log_error("%s%s\n", pname, strerror(errno) );
2439     else {
2440         md_final(md);
2441         if ( opt.with_colons ) {
2442             if ( algo ) 
2443                 print_hashline( md, algo, fname );
2444             else {
2445                 print_hashline( md, DIGEST_ALGO_MD5, fname );
2446                 print_hashline( md, DIGEST_ALGO_SHA1, fname );
2447                 print_hashline( md, DIGEST_ALGO_RMD160, fname );
2448                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) 
2449                     print_hashline( md, DIGEST_ALGO_TIGER, fname );
2450             }
2451         }
2452         else {
2453             if( algo ) {
2454                 if( fname )
2455                     fputs( pname, stdout );
2456                 print_hex(md_read(md, algo), md_digest_length(algo) );
2457             }
2458             else {
2459                 printf(  "%s   MD5 = ", fname?pname:"" );
2460                 print_hex(md_read(md, DIGEST_ALGO_MD5), 16 );
2461                 printf("\n%s  SHA1 = ", fname?pname:""  );
2462                 print_hex(md_read(md, DIGEST_ALGO_SHA1), 20 );
2463                 printf("\n%sRMD160 = ", fname?pname:""  );
2464                 print_hex(md_read(md, DIGEST_ALGO_RMD160), 20 );
2465                 if( !check_digest_algo(DIGEST_ALGO_TIGER) ) {
2466                     printf("\n%s TIGER = ", fname?pname:""  );
2467                     print_hex(md_read(md, DIGEST_ALGO_TIGER), 24 );
2468                 }
2469             }
2470             putchar('\n');
2471         }
2472     }
2473     md_close(md);
2474
2475     if( fp != stdin )
2476         fclose(fp);
2477 }
2478
2479
2480 /****************
2481  * Check the supplied name,value string and add it to the notation
2482  * data to be used for signatures.  which==0 for sig notations, and 1
2483  * for cert notations.
2484 */
2485 static void
2486 add_notation_data( const char *string, int which )
2487 {
2488     const char *s;
2489     STRLIST sl,*notation_data;
2490     int critical=0;
2491     int highbit=0;
2492
2493     if(which)
2494       notation_data=&opt.cert_notation_data;
2495     else
2496       notation_data=&opt.sig_notation_data;
2497
2498     if( *string == '!' ) {
2499         critical = 1;
2500         string++;
2501     }
2502
2503     for( s=string ; *s != '='; s++ ) {
2504         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) ) {
2505             log_error(_("a notation name must have only printable characters "
2506                         "or spaces, and end with an '='\n") );
2507             return;
2508         }
2509     }
2510     /* we only support printable text - therefore we enforce the use
2511      * of only printable characters (an empty value is valid) */
2512     for( s++; *s ; s++ ) {
2513         if( iscntrl(*s) ) {
2514             log_error(_("a notation value must not use "
2515                         "any control characters\n") );
2516             return;
2517         }
2518         else if( *s & 0x80 )
2519             highbit = 1;
2520     }
2521
2522     if( highbit )   /* must use UTF8 encoding */
2523         sl = add_to_strlist2( notation_data, string, utf8_strings );
2524     else
2525         sl = add_to_strlist( notation_data, string );
2526
2527     if( critical )
2528         sl->flags |= 1;
2529 }
2530
2531
2532 static void
2533 add_policy_url( const char *string, int which )
2534 {
2535   int i,critical=0;
2536   STRLIST sl;
2537
2538   if(*string=='!')
2539     {
2540       string++;
2541       critical=1;
2542     }
2543
2544   for(i=0;i<strlen(string);i++)
2545     if(string[i]&0x80 || iscntrl(string[i]))
2546       break;
2547
2548   if(i==0 || i<strlen(string))
2549     {
2550       if(which)
2551         log_error(_("the given certification policy URL is invalid\n"));
2552       else
2553         log_error(_("the given signature policy URL is invalid\n"));
2554     }
2555
2556   if(which)
2557     sl=add_to_strlist( &opt.cert_policy_url, string );
2558   else
2559     sl=add_to_strlist( &opt.sig_policy_url, string );
2560
2561   if(critical)
2562     sl->flags |= 1;    
2563 }