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