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