* g10.c: New command --card-status.
[gnupg.git] / g10 / g10.c
1 /* g10.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 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 #include <assert.h>
29 #ifdef HAVE_DOSISH_SYSTEM
30 #include <fcntl.h> /* for setmode() */
31 #endif
32 #ifdef HAVE_STAT
33 #include <sys/stat.h> /* for stat() */
34 #endif
35
36 #define INCLUDED_BY_MAIN_MODULE 1
37 #include "gpg.h"
38 #include "packet.h"
39 #include "iobuf.h"
40 #include "memory.h"
41 #include "util.h"
42 #include "main.h"
43 #include "options.h"
44 #include "keydb.h"
45 #include "trustdb.h"
46 #include "mpi.h"
47 #include "cipher.h"
48 #include "filter.h"
49 #include "ttyio.h"
50 #include "i18n.h"
51 #include "status.h"
52 #include "keyserver-internal.h"
53 #include "exec.h"
54
55 enum cmd_and_opt_values { aNull = 0,
56     oArmor        = 'a',
57     aDetachedSign = 'b',
58     aSym          = 'c',
59     aDecrypt      = 'd',
60     aEncr         = 'e',
61     aEncrFiles,
62     oInteractive  = 'i',
63     oKOption      = 'k',
64     oDryRun       = 'n',
65     oOutput       = 'o',
66     oQuiet        = 'q',
67     oRecipient    = 'r',
68     oHiddenRecipient = 'R',
69     aSign         = 's',
70     oTextmodeShort= 't',
71     oUser         = 'u',
72     oVerbose      = 'v',
73     oCompress     = 'z',
74     oNotation     = 'N',
75     oBatch        = 500,
76     oSigNotation,
77     oCertNotation,
78     oShowNotation,
79     oNoShowNotation,
80     aDecryptFiles,                          
81     aClearsign,
82     aStore,
83     aKeygen,
84     aSignEncr,
85     aSignSym,
86     aSignKey,
87     aLSignKey,
88     aNRSignKey,
89     aNRLSignKey,
90     aListPackets,
91     aEditKey,
92     aDeleteKeys,
93     aDeleteSecretKeys,
94     aDeleteSecretAndPublicKeys,
95     aKMode,
96     aKModeC,
97     aImport,
98     aFastImport,
99     aVerify,
100     aVerifyFiles,
101     aListKeys,
102     aListSigs,
103     aListSecretKeys,
104     aSendKeys,
105     aRecvKeys,
106     aSearchKeys,
107     aExport,
108     aExportAll,
109     aExportSecret,
110     aExportSecretSub,
111     aCheckKeys,
112     aGenRevoke,
113     aDesigRevoke,
114     aPrimegen,
115     aPrintMD,
116     aPrintMDs,
117     aCheckTrustDB,
118     aUpdateTrustDB,
119     aFixTrustDB,
120     aListTrustDB,
121     aListTrustPath,
122     aExportOwnerTrust,
123     aListOwnerTrust,
124     aImportOwnerTrust,
125     aDeArmor,
126     aEnArmor,
127     aGenRandom,
128     aPipeMode,
129     aRebuildKeydbCaches,
130     aRefreshKeys,
131     aCardStatus,
132     aChangePIN,
133
134     oTextmode,
135     oNoTextmode,
136     oExpert,
137     oNoExpert,
138     oAskSigExpire,
139     oNoAskSigExpire,
140     oAskCertExpire,
141     oNoAskCertExpire,
142     oFingerprint,
143     oWithFingerprint,
144     oAnswerYes,
145     oAnswerNo,
146     oDefCertCheckLevel,
147     oKeyring,
148     oPrimaryKeyring,
149     oSecretKeyring,
150     oShowKeyring,
151     oDefaultKey,
152     oDefRecipient,
153     oDefRecipientSelf,
154     oNoDefRecipient,
155     oOptions,
156     oDebug,
157     oDebugAll,
158     oStatusFD,
159 #ifdef __riscos__
160     oStatusFile,
161 #endif /* __riscos__ */
162     oAttributeFD,
163 #ifdef __riscos__
164     oAttributeFile,
165 #endif /* __riscos__ */
166     oSKComments,
167     oNoSKComments,
168     oEmitVersion,
169     oNoEmitVersion,
170     oCompletesNeeded,
171     oMarginalsNeeded,
172     oMaxCertDepth,
173     oLoadExtension,
174     oGnuPG,
175     oRFC1991,
176     oOpenPGP,
177     oPGP2,
178     oPGP6,
179     oPGP7,
180     oPGP8,
181     oCipherAlgo,
182     oDigestAlgo,
183     oCertDigestAlgo,
184     oCompressAlgo,
185     oPasswdFD,
186 #ifdef __riscos__
187     oPasswdFile,
188 #endif /* __riscos__ */
189     oCommandFD,
190 #ifdef __riscos__
191     oCommandFile,
192 #endif /* __riscos__ */
193     oQuickRandom,
194     oNoVerbose,
195     oTrustDBName,
196     oNoSecmemWarn,
197     oNoPermissionWarn,
198     oNoMDCWarn,
199     oNoArmor,
200     oNoDefKeyring,
201     oNoGreeting,
202     oNoTTY,
203     oNoOptions,
204     oNoBatch,
205     oHomedir,
206     oWithColons,
207     oWithKeyData,
208     oSkipVerify,
209     oCompressKeys,
210     oCompressSigs,
211     oAlwaysTrust,
212     oTrustModel,
213     oForceOwnertrust,
214     oEmuChecksumBug,
215     oRunAsShmCP,
216     oSetFilename,
217     oForYourEyesOnly,
218     oNoForYourEyesOnly,
219     oSetPolicyURL,
220     oSigPolicyURL,
221     oCertPolicyURL,
222     oShowPolicyURL,
223     oNoShowPolicyURL,
224     oUseEmbeddedFilename,
225     oComment,
226     oDefaultComment,
227     oThrowKeyid,
228     oNoThrowKeyid,
229     oShowPhotos,
230     oNoShowPhotos,
231     oPhotoViewer,
232     oForceV3Sigs,
233     oNoForceV3Sigs,
234     oForceV4Certs,
235     oNoForceV4Certs,
236     oForceMDC,
237     oNoForceMDC,
238     oDisableMDC,
239     oNoDisableMDC,
240     oS2KMode,
241     oS2KDigest,
242     oS2KCipher,
243     oSimpleSKChecksum,                          
244     oCharset,
245     oNotDashEscaped,
246     oEscapeFrom,
247     oNoEscapeFrom,
248     oLockOnce,
249     oLockMultiple,
250     oLockNever,
251     oKeyServer,
252     oKeyServerOptions,
253     oImportOptions,
254     oExportOptions,
255     oListOptions,
256     oVerifyOptions,
257     oTempDir,
258     oExecPath,
259     oEncryptTo,
260     oHiddenEncryptTo,
261     oNoEncryptTo,
262     oLoggerFD,
263 #ifdef __riscos__
264     oLoggerFile,
265 #endif /* __riscos__ */
266     oUtf8Strings,
267     oNoUtf8Strings,
268     oDisableCipherAlgo,
269     oDisablePubkeyAlgo,
270     oAllowNonSelfsignedUID,
271     oNoAllowNonSelfsignedUID,
272     oAllowFreeformUID,
273     oNoAllowFreeformUID,
274     oAllowSecretKeyImport,                      
275     oEnableSpecialFilenames,
276     oNoLiteral,
277     oSetFilesize,
278     oHonorHttpProxy,
279     oFastListMode,
280     oListOnly,
281     oIgnoreTimeConflict,
282     oIgnoreValidFrom,
283     oIgnoreCrcError,
284     oIgnoreMDCError,
285     oShowSessionKey,
286     oOverrideSessionKey,
287     oNoRandomSeedFile,
288     oAutoKeyRetrieve,
289     oNoAutoKeyRetrieve,
290     oUseAgent,
291     oNoUseAgent,
292     oGpgAgentInfo,
293     oMergeOnly,
294     oTryAllSecrets,
295     oTrustedKey,
296     oNoExpensiveTrustChecks,
297     oFixedListMode,
298     oNoSigCache,
299     oNoSigCreateCheck,
300     oAutoCheckTrustDB,
301     oNoAutoCheckTrustDB,
302     oPreservePermissions,
303     oDefaultPreferenceList,
304     oPersonalCipherPreferences,
305     oPersonalDigestPreferences,
306     oPersonalCompressPreferences,
307     oEmuMDEncodeBug,
308     oAgentProgram,
309     oDisplay,
310     oTTYname,
311     oTTYtype,
312     oLCctype,
313     oLCmessages,
314     oGroup,
315     oStrict,
316     oNoStrict,
317     oMangleDosFilenames,
318     oNoMangleDosFilenames,
319     oEnableProgressFilter,                          
320 aTest };
321
322
323 static ARGPARSE_OPTS opts[] = {
324
325     { 300, NULL, 0, N_("@Commands:\n ") },
326
327     { aSign, "sign",      256, N_("|[file]|make a signature")},
328     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature") },
329     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
330     { aEncr, "encrypt",   256, N_("encrypt data")},
331     { aEncrFiles, "encrypt-files", 256, N_("|[files]|encrypt files")},
332     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
333     { aStore, "store",     256, N_("store only")},
334     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
335     { aDecryptFiles, "decrypt-files", 256, N_("|[files]|decrypt files")},
336     { aVerify, "verify"   , 256, N_("verify a signature")},
337     { aVerifyFiles, "verify-files" , 256, "@" },
338     { aListKeys, "list-keys", 256, N_("list keys")},
339     { aListKeys, "list-public-keys", 256, "@" },
340     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
341     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
342     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
343     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
344     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
345     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
346     { aDeleteSecretKeys, "delete-secret-keys",256,
347                                     N_("remove keys from the secret keyring")},
348     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
349     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
350     { aNRSignKey, "nrsign-key"  ,256, N_("sign a key non-revocably")},
351     { aNRLSignKey, "nrlsign-key"  ,256, N_("sign a key locally and non-revocably")},
352     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
353     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
354     { aDesigRevoke, "desig-revoke",256, "@" },
355     { aExport, "export"           , 256, N_("export keys") },
356     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
357     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
358     { aSearchKeys, "search-keys" , 256,
359                                     N_("search for keys on a key server") },
360     { aRefreshKeys, "refresh-keys", 256,
361                                     N_("update all keys from a keyserver")},
362     { aExportAll, "export-all"    , 256, "@" },
363     { aExportSecret, "export-secret-keys" , 256, "@" },
364     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
365     { aImport, "import",      256     , N_("import/merge keys")},
366     { aFastImport, "fast-import",  256 , "@"},
367     { aCardStatus,  "card-status", 256, N_("print the card status")},
368     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
369
370     { aListPackets, "list-packets",256,N_("list only the sequence of packets")},
371     { aExportOwnerTrust,
372               "export-ownertrust", 256, N_("export the ownertrust values")},
373     { aImportOwnerTrust,
374               "import-ownertrust", 256, N_("import ownertrust values")},
375     { aUpdateTrustDB,
376               "update-trustdb",0 , N_("update the trust database")},
377     { aCheckTrustDB,
378               "check-trustdb",0 , N_("unattended trust database update")},
379     { aFixTrustDB, "fix-trustdb",0 , N_("fix a corrupted trust database")},
380     { aDeArmor, "dearmor", 256, N_("De-Armor a file or stdin") },
381     { aDeArmor, "dearmour", 256, "@" },
382     { aEnArmor, "enarmor", 256, N_("En-Armor a file or stdin") },
383     { aEnArmor, "enarmour", 256, "@" },
384     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
385     { aPrimegen, "gen-prime" , 256, "@" },
386     { aGenRandom, "gen-random" , 256, "@" },
387
388     { 301, NULL, 0, N_("@\nOptions:\n ") },
389
390     { oArmor, "armor",     0, N_("create ascii armored output")},
391     { oArmor, "armour",     0, "@" },
392     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
393     { oHiddenRecipient, "hidden-recipient", 2, "@" },
394     { oRecipient, "remote-user", 2, "@"},  /* old option name */
395     { oDefRecipient, "default-recipient" ,2,
396                                   N_("|NAME|use NAME as default recipient")},
397     { oDefRecipientSelf, "default-recipient-self" ,0,
398                                 N_("use the default key as default recipient")},
399     { oNoDefRecipient, "no-default-recipient", 0, "@" },
400     { oTempDir, "temp-directory", 2, "@" },
401     { oExecPath, "exec-path", 2, "@" },
402     { oEncryptTo, "encrypt-to", 2, "@" },
403     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
404     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
405     { oUser, "local-user",2, N_("use this user-id to sign or decrypt")},
406     { oCompress, NULL,        1, N_("|N|set compress level N (0 disables)") },
407     { oTextmodeShort, NULL,   0, "@"},
408     { oTextmode, "textmode",  0, N_("use canonical text mode")},
409     { oNoTextmode, "no-textmode",  0, "@"},
410     { oExpert, "expert",   0, "@"},
411     { oNoExpert, "no-expert",   0, "@"},
412     { oAskSigExpire, "ask-sig-expire",   0, "@"},
413     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
414     { oAskCertExpire, "ask-cert-expire",   0, "@"},
415     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
416     { oOutput, "output",    2, N_("use as output file")},
417     { oVerbose, "verbose",   0, N_("verbose") },
418     { oQuiet,   "quiet",   0, N_("be somewhat more quiet") },
419     { oNoTTY, "no-tty", 0, N_("don't use the terminal at all") },
420     { oForceV3Sigs, "force-v3-sigs", 0, N_("force v3 signatures") },
421     { oNoForceV3Sigs, "no-force-v3-sigs", 0, N_("do not force v3 signatures") },
422     { oForceV4Certs, "force-v4-certs", 0, N_("force v4 key signatures") },
423     { oNoForceV4Certs, "no-force-v4-certs", 0, N_("do not force v4 key signatures") },
424     { oForceMDC, "force-mdc", 0, N_("always use a MDC for encryption") },
425     { oNoForceMDC, "no-force-mdc", 0, "@" },
426     { oDisableMDC, "disable-mdc", 0, N_("never use a MDC for encryption") },
427     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
428     { oDryRun, "dry-run",   0, N_("do not make any changes") },
429     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
430     { oUseAgent, "use-agent",0, N_("use the gpg-agent")},
431     { oNoUseAgent, "no-use-agent",0, "@"},
432     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
433     { oBatch, "batch",     0, N_("batch mode: never ask")},
434     { oAnswerYes, "yes",       0, N_("assume yes on most questions")},
435     { oAnswerNo,  "no",        0, N_("assume no on most questions")},
436     { oKeyring, "keyring"   ,2, N_("add this keyring to the list of keyrings")},
437     { oPrimaryKeyring, "primary-keyring",2, "@" },
438     { oSecretKeyring, "secret-keyring" ,2, N_("add this secret keyring to the list")},
439     { oShowKeyring, "show-keyring", 0, N_("show which keyring a listed key is on")},
440     { oDefaultKey, "default-key" ,2, N_("|NAME|use NAME as default secret key")},
441     { oKeyServer, "keyserver",2, N_("|HOST|use this keyserver to lookup keys")},
442     { oKeyServerOptions, "keyserver-options",2,"@"},
443     { oImportOptions, "import-options",2,"@"},
444     { oExportOptions, "export-options",2,"@"},
445     { oListOptions, "list-options",2,"@"},
446     { oCharset, "charset"   , 2, N_("|NAME|set terminal charset to NAME") },
447     { oOptions, "options"   , 2, N_("read options from file")},
448
449     { oDebug, "debug"     ,4|16, "@"},
450     { oDebugAll, "debug-all" ,0, "@"},
451     { oStatusFD, "status-fd" ,1, N_("|FD|write status info to this FD") },
452 #ifdef __riscos__
453     { oStatusFile, "status-file" ,2, N_("|[file]|write status info to file") },
454 #endif /* __riscos__ */
455     { oAttributeFD, "attribute-fd" ,1, "@" },
456 #ifdef __riscos__
457     { oAttributeFile, "attribute-file" ,2, "@" },
458 #endif /* __riscos__ */
459     { oNoSKComments, "no-comment", 0,   "@"},
460     { oNoSKComments, "no-sk-comments", 0,   "@"},
461     { oSKComments, "sk-comments", 0,   "@"},
462     { oCompletesNeeded, "completes-needed", 1, "@"},
463     { oMarginalsNeeded, "marginals-needed", 1, "@"},
464     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
465     { oTrustedKey, "trusted-key", 2, N_("|KEYID|ultimately trust this key")},
466     { oLoadExtension, "load-extension" ,2, N_("|FILE|load extension module FILE")},
467     { oGnuPG, "gnupg",   0, "@"},
468     { oGnuPG, "no-pgp2", 0, "@"},
469     { oGnuPG, "no-pgp6", 0, "@"},
470     { oGnuPG, "no-pgp7", 0, "@"},
471     { oGnuPG, "no-pgp8", 0, "@"},
472     { oRFC1991, "rfc1991",   0, N_("emulate the mode described in RFC1991")},
473     { oOpenPGP, "openpgp", 0, N_("set all packet, cipher and digest options to OpenPGP behavior")},
474     { oPGP2, "pgp2", 0, N_("set all packet, cipher and digest options to PGP 2.x behavior")},
475     { oPGP6, "pgp6", 0, "@"},
476     { oPGP7, "pgp7", 0, "@"},
477     { oPGP8, "pgp8", 0, "@"},
478     { oS2KMode, "s2k-mode",  1, N_("|N|use passphrase mode N")},
479     { oS2KDigest, "s2k-digest-algo",2,
480                 N_("|NAME|use message digest algorithm NAME for passphrases")},
481     { oS2KCipher, "s2k-cipher-algo",2,
482                 N_("|NAME|use cipher algorithm NAME for passphrases")},
483     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
484     { oCipherAlgo, "cipher-algo", 2 , N_("|NAME|use cipher algorithm NAME")},
485     { oDigestAlgo, "digest-algo", 2 , N_("|NAME|use message digest algorithm NAME")},
486     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
487     { oCompressAlgo,"compress-algo",2,N_("|NAME|use compression algorithm NAME")},
488     { oThrowKeyid, "throw-keyid", 0, N_("throw keyid field of encrypted packets")},
489     { oNoThrowKeyid, "no-throw-keyid", 0, "@" },
490     { oShowPhotos,   "show-photos", 0, "@" },
491     { oNoShowPhotos, "no-show-photos", 0, "@" },
492     { oPhotoViewer,  "photo-viewer", 2, "@" },
493     { oNotation,   "notation-data", 2, "@" },
494     { oSigNotation,   "sig-notation", 2, "@" },
495     { oCertNotation,  "cert-notation", 2, "@" },
496
497     { 302, NULL, 0, N_(
498   "@\n(See the man page for a complete listing of all commands and options)\n"
499                       )},
500
501     { 303, NULL, 0, N_("@\nExamples:\n\n"
502     " -se -r Bob [file]          sign and encrypt for user Bob\n"
503     " --clearsign [file]         make a clear text signature\n"
504     " --detach-sign [file]       make a detached signature\n"
505     " --list-keys [names]        show keys\n"
506     " --fingerprint [names]      show fingerprints\n"  ) },
507
508   /* hidden options */
509     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
510     { oCompressAlgo, "compression-algo", 1, "@"}, /* alias */
511     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
512     { aListTrustDB, "list-trustdb",0 , "@"},
513     /* Not yet used */
514     /* { aListTrustPath, "list-trust-path",0, "@"}, */
515     { aPipeMode,  "pipemode", 0, "@" },
516     { oKOption, NULL,    0, "@"},
517     { oPasswdFD, "passphrase-fd",1, "@" },
518 #ifdef __riscos__
519     { oPasswdFile, "passphrase-file",2, "@" },
520 #endif /* __riscos__ */
521     { oCommandFD, "command-fd",1, "@" },
522 #ifdef __riscos__
523     { oCommandFile, "command-file",2, "@" },
524 #endif /* __riscos__ */
525     { oQuickRandom, "quick-random", 0, "@"},
526     { oNoVerbose, "no-verbose", 0, "@"},
527     { oTrustDBName, "trustdb-name", 2, "@" },
528     { oNoSecmemWarn, "no-secmem-warning", 0, "@" }, /* used only by regression tests */
529     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
530     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
531     { oNoArmor, "no-armor",   0, "@"},
532     { oNoArmor, "no-armour",   0, "@"},
533     { oNoDefKeyring, "no-default-keyring", 0, "@" },
534     { oNoGreeting, "no-greeting", 0, "@" },
535     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
536     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
537     { oNoBatch, "no-batch", 0, "@" },
538     { oWithColons, "with-colons", 0, "@"},
539     { oWithKeyData,"with-key-data", 0, "@"},
540     { aListKeys, "list-key", 0, "@" }, /* alias */
541     { aListSigs, "list-sig", 0, "@" }, /* alias */
542     { aCheckKeys, "check-sig",0, "@" }, /* alias */
543     { oSkipVerify, "skip-verify",0, "@" },
544     { oCompressKeys, "compress-keys",0, "@"},
545     { oCompressSigs, "compress-sigs",0, "@"},
546     { oDefCertCheckLevel, "default-cert-check-level", 1, "@"},
547     { oAlwaysTrust, "always-trust", 0, "@"},
548     { oTrustModel, "trust-model", 2, "@"},
549     { oForceOwnertrust, "force-ownertrust", 2, "@"},
550     { oEmuChecksumBug, "emulate-checksum-bug", 0, "@"},
551     { oRunAsShmCP, "run-as-shm-coprocess", 4, "@" },
552     { oSetFilename, "set-filename", 2, "@" },
553     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
554     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
555     { oSetPolicyURL, "set-policy-url", 2, "@" },
556     { oSigPolicyURL, "sig-policy-url", 2, "@" },
557     { oCertPolicyURL, "cert-policy-url", 2, "@" },
558     { oShowPolicyURL, "show-policy-url", 0, "@" },
559     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
560     { oShowNotation, "show-notation", 0, "@" },
561     { oNoShowNotation, "no-show-notation", 0, "@" },
562     { oComment, "comment", 2, "@" },
563     { oDefaultComment, "default-comment", 0, "@" },
564     { oEmitVersion, "emit-version", 0, "@"},
565     { oNoEmitVersion, "no-emit-version", 0, "@"},
566     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
567     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
568     { oEscapeFrom, "escape-from-lines", 0, "@" },
569     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
570     { oLockOnce, "lock-once", 0, "@" },
571     { oLockMultiple, "lock-multiple", 0, "@" },
572     { oLockNever, "lock-never", 0, "@" },
573     { oLoggerFD, "logger-fd",1, "@" },
574 #ifdef __riscos__
575     { oLoggerFile, "logger-file",2, "@" },
576 #endif /* __riscos__ */
577     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
578     { oUtf8Strings, "utf8-strings", 0, "@" },
579     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
580     { oWithFingerprint, "with-fingerprint", 0, "@" },
581     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
582     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
583     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
584     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
585     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
586     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
587     { oNoLiteral, "no-literal", 0, "@" },
588     { oSetFilesize, "set-filesize", 20, "@" },
589     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
590     { oFastListMode,"fast-list-mode", 0, "@" },
591     { oFixedListMode,"fixed-list-mode", 0, "@" },
592     { oListOnly, "list-only", 0, "@"},
593     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
594     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
595     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
596     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
597     { oShowSessionKey, "show-session-key", 0, "@" },
598     { oOverrideSessionKey, "override-session-key", 2, "@" },
599     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
600     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
601     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
602     { oNoSigCache,         "no-sig-cache", 0, "@" },
603     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
604     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
605     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
606     { oMergeOnly,         "merge-only", 0, "@" },
607     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
608     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
609     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
610     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
611     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
612     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
613     { oPreservePermissions, "preserve-permissions", 0, "@"},
614     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
615     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
616     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
617     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
618     { oEmuMDEncodeBug,  "emulate-md-encode-bug", 0, "@"},
619     { oAgentProgram, "agent-program", 2 , "@" },
620     { oDisplay,    "display",     2, "@" },
621     { oTTYname,    "ttyname",     2, "@" },
622     { oTTYtype,    "ttytype",     2, "@" },
623     { oLCctype,    "lc-ctype",    2, "@" },
624     { oLCmessages, "lc-messages", 2, "@" },
625     { oGroup,      "group",       2, "@" },
626     { oStrict,     "strict",      0, "@" },
627     { oNoStrict,   "no-strict",   0, "@" },
628     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
629     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
630     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
631 {0} };
632
633
634
635 int g10_errors_seen = 0;
636
637 static int utf8_strings = 0;
638 static int maybe_setuid = 1;
639
640 static char *build_list( const char *text, char letter,
641                          const char *(*mapf)(int), int (*chkf)(int) );
642 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
643                         enum cmd_and_opt_values new_cmd );
644 static void print_mds( const char *fname, int algo );
645 static void add_notation_data( const char *string, int which );
646 static void add_policy_url( const char *string, int which );
647 static void emergency_cleanup (void);
648
649 #ifdef __riscos__
650 RISCOS_GLOBAL_STATICS("GnuPG Heap")
651 #endif /* __riscos__ */
652
653 static int
654 pk_test_algo (int algo)
655 {
656   return openpgp_pk_test_algo (algo, 0);
657 }
658
659
660 static const char *
661 my_strusage( int level )
662 {
663   static char *digests, *pubkeys, *ciphers, *zips;
664     const char *p;
665     switch( level ) {
666       case 11: p = "gpg (GnuPG)";
667         break;
668       case 13: p = VERSION; break;
669       case 17: p = PRINTABLE_OS_NAME; break;
670       case 19: p =
671             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
672         break;
673       case 1:
674       case 40:  p =
675             _("Usage: gpg [options] [files] (-h for help)");
676         break;
677       case 41:  p =
678             _("Syntax: gpg [options] [files]\n"
679               "sign, check, encrypt or decrypt\n"
680               "default operation depends on the input data\n");
681         break;
682
683       case 31: p = "\nHome: "; break;
684 #ifndef __riscos__
685       case 32: p = opt.homedir; break;
686 #else /* __riscos__ */
687       case 32: p = make_filename(opt.homedir, NULL); break;
688 #endif /* __riscos__ */
689       case 33: p = _("\nSupported algorithms:\n"); break;
690       case 34:
691         if( !pubkeys )
692             pubkeys = build_list(_("Pubkey: "), 0, gcry_pk_algo_name,
693                                  pk_test_algo );
694         p = pubkeys;
695         break;
696       case 35:
697         if( !ciphers )
698             ciphers = build_list(_("Cipher: "), 'S', gcry_cipher_algo_name,
699                                  openpgp_cipher_test_algo );
700         p = ciphers;
701         break;
702       case 36:
703         if( !digests )
704             digests = build_list(_("Hash: "), 'H', gcry_md_algo_name,
705                                         openpgp_md_test_algo );
706         p = digests;
707         break;
708       case 37:
709         if( !zips )
710             zips = build_list(_("Compression: "),'Z',compress_algo_to_string,
711                                                         check_compress_algo);
712         p = zips;
713         break;
714
715       default:  p = NULL;
716     }
717     return p;
718 }
719
720
721 static char *
722 build_list( const char *text, char letter,
723             const char * (*mapf)(int), int (*chkf)(int) )
724 {
725     int i;
726     const char *s;
727     size_t n=strlen(text)+2;
728     char *list, *p, *line=NULL;
729
730     if( maybe_setuid )
731         gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* drop setuid */
732
733     for(i=0; i <= 110; i++ )
734         if( !chkf(i) && (s=mapf(i)) )
735             n += strlen(s) + 7 + 2;
736     list = xmalloc ( 21 + n ); *list = 0;
737     for(p=NULL, i=0; i <= 110; i++ ) {
738         if( !chkf(i) && (s=mapf(i)) ) {
739             if( !p ) {
740                 p = stpcpy( list, text );
741                 line=p;
742             }
743             else
744                 p = stpcpy( p, ", ");
745
746             if(strlen(line)>60) {
747               int spaces=strlen(text);
748
749               list = xrealloc(list,n+spaces+1);
750               /* realloc could move the block, so find the end again */
751               p=list;
752               while(*p)
753                 p++;
754
755               p=stpcpy(p, "\n");
756               line=p;
757               for(;spaces;spaces--)
758                 p=stpcpy(p, " ");
759             }
760
761             p = stpcpy(p, s );
762             if(opt.verbose && letter)
763               {
764                 char num[8];
765                 sprintf(num," (%c%d)",letter,i);
766                 p = stpcpy(p,num);
767               }
768         }
769     }
770     if( p )
771         p = stpcpy(p, "\n" );
772     return list;
773 }
774
775
776 static void
777 i18n_init(void)
778 {
779 #ifdef USE_SIMPLE_GETTEXT
780     set_gettext_file( PACKAGE );
781 #else
782 #ifdef ENABLE_NLS
783     setlocale( LC_ALL, "" );
784     bindtextdomain( PACKAGE, LOCALEDIR );
785     textdomain( PACKAGE );
786 #endif
787 #endif
788 }
789
790 static void
791 wrong_args( const char *text)
792 {
793     fputs(_("usage: gpg [options] "),stderr);
794     fputs(text,stderr);
795     putc('\n',stderr);
796     g10_exit(2);
797 }
798
799
800 static void
801 log_set_strict (int yesno)
802 {
803   /* FIXME-XXX*/
804 }
805
806 static char *
807 make_username( const char *string )
808 {
809     char *p;
810     if( utf8_strings )
811         p = xstrdup (string);
812     else
813         p = native_to_utf8( string );
814     return p;
815 }
816
817
818 /*
819  * same as add_to_strlist() but if is_utf8 is *not* set a conversion
820  * to UTF8 is done  
821  */
822 static STRLIST
823 add_to_strlist2 ( STRLIST *list, const char *string, int is_utf8)
824 {
825   STRLIST sl;
826   
827   if (is_utf8)
828     sl = add_to_strlist( list, string );
829   else 
830     {
831       char *p = native_to_utf8( string );
832       sl = add_to_strlist( list, p );
833       xfree( p );
834     }
835   return sl;
836 }
837
838
839 static void
840 set_debug(void)
841 {
842   if (opt.debug & DBG_MEMORY_VALUE )
843     memory_debug_mode = 1;
844   if (opt.debug & DBG_MEMSTAT_VALUE )
845     memory_stat_debug_mode = 1;
846   if (opt.debug & DBG_MPI_VALUE)
847     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
848   if (opt.debug & DBG_CIPHER_VALUE )
849     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
850   if (opt.debug & DBG_IOBUF_VALUE )
851     iobuf_debug_mode = 1;
852 }
853
854
855 /* We need the home directory also in some other directories, so make
856    sure that both variables are always in sync. */
857 static void
858 set_homedir (char *dir)
859 {
860   if (!dir)
861     dir = "";
862   g10_opt_homedir = opt.homedir = dir;
863 }
864
865
866 static void
867 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
868 {
869     enum cmd_and_opt_values cmd = *ret_cmd;
870
871     if( !cmd || cmd == new_cmd )
872         cmd = new_cmd;
873     else if( cmd == aSign && new_cmd == aEncr )
874         cmd = aSignEncr;
875     else if( cmd == aEncr && new_cmd == aSign )
876         cmd = aSignEncr;
877     else if( cmd == aSign && new_cmd == aSym )
878         cmd = aSignSym;
879     else if( cmd == aSym && new_cmd == aSign )
880         cmd = aSignSym;
881     else if( cmd == aKMode && new_cmd == aSym )
882         cmd = aKModeC;
883     else if(    ( cmd == aSign     && new_cmd == aClearsign )
884              || ( cmd == aClearsign && new_cmd == aSign )  )
885         cmd = aClearsign;
886     else {
887         log_error(_("conflicting commands\n"));
888         g10_exit(2);
889     }
890
891     *ret_cmd = cmd;
892 }
893
894
895 static void add_group(char *string)
896 {
897   char *name,*value;
898   struct groupitem *item;
899   STRLIST values=NULL;
900
901   /* Break off the group name */
902   name=strsep(&string,"=");
903   if(string==NULL)
904     {
905       log_error(_("no = sign found in group definition \"%s\"\n"),name);
906       return;
907     }
908
909   trim_trailing_ws(name,strlen(name));
910
911   /* Break apart the values */
912   while ((value= strsep(&string," \t")))
913     {
914       if (*value)
915         add_to_strlist2 (&values,value,utf8_strings);
916     }
917
918   item=xmalloc (sizeof(struct groupitem));
919   item->name=name;
920   item->values=values;
921   item->next=opt.grouplist;
922
923   opt.grouplist=item;
924 }
925
926 /* We need to check three things.
927
928    0) The homedir.  It must be x00, a directory, and owned by the
929    user.
930
931    1) The options file.  Okay unless it or its containing directory is
932    group or other writable or not owned by us.  disable exec in this
933    case.
934
935    2) Extensions.  Same as #2.
936
937    Returns true if the item is unsafe. */
938 static int
939 check_permissions(const char *path,int item)
940 {
941 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
942   static int homedir_cache=-1;
943   char *tmppath,*dir;
944   struct stat statbuf,dirbuf;
945   int homedir=0,ret=0,checkonly=0;
946   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
947
948   if(opt.no_perm_warn)
949     return 0;
950
951   assert(item==0 || item==1 || item==2);
952
953   /* extensions may attach a path */
954   if(item==2 && path[0]!=DIRSEP_C)
955     {
956       if(strchr(path,DIRSEP_C))
957         tmppath=make_filename(path,NULL);
958       else
959         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
960     }
961   else
962     tmppath=xstrdup (path);
963
964   /* If the item is located in the homedir, but isn't the homedir,
965      don't continue if we already checked the homedir itself.  This is
966      to avoid user confusion with an extra options file warning which
967      could be rectified if the homedir itself had proper
968      permissions. */
969   if(item!=0 && homedir_cache>-1
970      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
971     {
972       ret=homedir_cache;
973       goto end;
974     }
975
976   /* It's okay if the file or directory doesn't exist */
977   if(stat(tmppath,&statbuf)!=0)
978     {
979       ret=0;
980       goto end;
981     }
982
983   /* Now check the enclosing directory.  Theoretically, we could walk
984      this test up to the root directory /, but for the sake of sanity,
985      I'm stopping at one level down. */
986   dir=make_dirname(tmppath);
987
988   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
989     {
990       /* Weird error */
991       ret=1;
992       goto end;
993     }
994
995   xfree (dir);
996
997   /* Assume failure */
998   ret=1;
999
1000   if(item==0)
1001     {
1002       /* The homedir must be x00, a directory, and owned by the user. */
1003
1004       if(S_ISDIR(statbuf.st_mode))
1005         {
1006           if(statbuf.st_uid==getuid())
1007             {
1008               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1009                 ret=0;
1010               else
1011                 perm=1;
1012             }
1013           else
1014             own=1;
1015
1016           homedir_cache=ret;
1017         }
1018     }
1019   else if(item==1 || item==2)
1020     {
1021       /* The options or extension file.  Okay unless it or its
1022          containing directory is group or other writable or not owned
1023          by us or root. */
1024
1025       if(S_ISREG(statbuf.st_mode))
1026         {
1027           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1028             {
1029               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1030                 {
1031                   /* it's not writable, so make sure the enclosing
1032                      directory is also not writable */
1033                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1034                     {
1035                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1036                         ret=0;
1037                       else
1038                         enc_dir_perm=1;
1039                     }
1040                   else
1041                     enc_dir_own=1;
1042                 }
1043               else
1044                 {
1045                   /* it's writable, so the enclosing directory had
1046                      better not let people get to it. */
1047                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1048                     {
1049                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1050                         ret=0;
1051                       else
1052                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1053                     }
1054                   else
1055                     enc_dir_own=1;
1056                 }
1057             }
1058           else
1059             own=1;
1060         }
1061     }
1062   else
1063     BUG();
1064
1065   if(!checkonly)
1066     {
1067       if(own)
1068         {
1069           if(item==0)
1070             log_info(_("WARNING: unsafe ownership on "
1071                        "homedir \"%s\"\n"),tmppath);
1072           else if(item==1)
1073             log_info(_("WARNING: unsafe ownership on "
1074                        "configuration file \"%s\"\n"),tmppath);
1075           else
1076             log_info(_("WARNING: unsafe ownership on "
1077                        "extension \"%s\"\n"),tmppath);
1078         }
1079       if(perm)
1080         {
1081           if(item==0)
1082             log_info(_("WARNING: unsafe permissions on "
1083                        "homedir \"%s\"\n"),tmppath);
1084           else if(item==1)
1085             log_info(_("WARNING: unsafe permissions on "
1086                        "configuration file \"%s\"\n"),tmppath);
1087           else
1088             log_info(_("WARNING: unsafe permissions on "
1089                        "extension \"%s\"\n"),tmppath);
1090         }
1091       if(enc_dir_own)
1092         {
1093           if(item==0)
1094             log_info(_("WARNING: unsafe enclosing directory ownership on "
1095                        "homedir \"%s\"\n"),tmppath);
1096           else if(item==1)
1097             log_info(_("WARNING: unsafe enclosing directory ownership on "
1098                        "configuration file \"%s\"\n"),tmppath);
1099           else
1100             log_info(_("WARNING: unsafe enclosing directory ownership on "
1101                        "extension \"%s\"\n"),tmppath);
1102         }
1103       if(enc_dir_perm)
1104         {
1105           if(item==0)
1106             log_info(_("WARNING: unsafe enclosing directory permissions on "
1107                        "homedir \"%s\"\n"),tmppath);
1108           else if(item==1)
1109             log_info(_("WARNING: unsafe enclosing directory permissions on "
1110                        "configuration file \"%s\"\n"),tmppath);
1111           else
1112             log_info(_("WARNING: unsafe enclosing directory permissions on "
1113                        "extension \"%s\"\n"),tmppath);
1114         }
1115     }
1116
1117  end:
1118   xfree (tmppath);
1119
1120   if(homedir)
1121     homedir_cache=ret;
1122
1123   return ret;
1124
1125 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1126
1127   return 0;
1128 }
1129
1130 int
1131 main( int argc, char **argv )
1132 {
1133     ARGPARSE_ARGS pargs;
1134     iobuf_t a;
1135     int rc=0;
1136     int orig_argc;
1137     char **orig_argv;
1138     const char *fname;
1139     char *username;
1140     int may_coredump;
1141     STRLIST sl, remusr= NULL, locusr=NULL;
1142     STRLIST nrings=NULL, sec_nrings=NULL;
1143     armor_filter_context_t afx;
1144     int detached_sig = 0;
1145     FILE *configfp = NULL;
1146     char *configname = NULL;
1147     unsigned configlineno;
1148     int parse_debug = 0;
1149     int default_config = 1;
1150     int default_keyring = 1;
1151     int greeting = 0;
1152     int nogreeting = 0;
1153     int use_random_seed = 1;
1154     enum cmd_and_opt_values cmd = 0;
1155     const char *trustdb_name = NULL;
1156     char *def_cipher_string = NULL;
1157     char *def_digest_string = NULL;
1158     char *def_compress_string = NULL;
1159     char *cert_digest_string = NULL;
1160     char *s2k_cipher_string = NULL;
1161     char *s2k_digest_string = NULL;
1162     char *pers_cipher_list = NULL;
1163     char *pers_digest_list = NULL;
1164     char *pers_compress_list = NULL;
1165     int eyes_only=0;
1166     int pwfd = -1;
1167     int with_fpr = 0; /* make an option out of --fingerprint */
1168     int any_explicit_recipient = 0;
1169 #ifdef USE_SHM_COPROCESSING
1170     ulong requested_shm_size=0;
1171 #endif
1172
1173 #ifdef __riscos__
1174     riscos_global_defaults();
1175     opt.lock_once = 1;
1176 #endif /* __riscos__ */
1177
1178     trap_unaligned();
1179     set_strusage (my_strusage);
1180     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1181     /* We don't need any locking in libgcrypt unless we use any kind of
1182        threading. */
1183     gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1184     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1185      * when adding any stuff between here and the call to
1186      * secmem_init()  somewhere after the option parsing
1187      */
1188     log_set_prefix ("gpg", 1);
1189     /* check that the libraries are suitable.  Do it here because the
1190        option parse may need services of the library */
1191     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1192       {
1193         log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
1194                    NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1195       }
1196
1197     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1198
1199     may_coredump = disable_core_dumps();
1200     gnupg_init_signals (0, emergency_cleanup);
1201     create_dotlock (NULL); /* register locking cleanup */
1202     i18n_init();
1203
1204     opt.command_fd = -1; /* no command fd */
1205     opt.compress = -1; /* defaults to standard compress level */
1206     /* note: if you change these lines, look at oOpenPGP */
1207     opt.def_cipher_algo = 0;
1208     opt.def_digest_algo = 0;
1209     opt.cert_digest_algo = 0;
1210     opt.def_compress_algo = -1;
1211     opt.s2k_mode = 3; /* iterated+salted */
1212     opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1213 #ifdef USE_CAST5
1214     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1215 #else
1216     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1217 #endif
1218     opt.completes_needed = 1;
1219     opt.marginals_needed = 3;
1220     opt.max_cert_depth = 5;
1221     opt.pgp2_workarounds = 1;
1222     opt.force_v3_sigs = 1;
1223     opt.escape_from = 1;
1224     opt.import_options=IMPORT_SK2PK;
1225     opt.export_options=
1226       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1227     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1228     opt.keyserver_options.export_options=
1229       EXPORT_INCLUDE_NON_RFC|EXPORT_INCLUDE_ATTRIBUTES;
1230     opt.keyserver_options.include_subkeys=1;
1231     opt.keyserver_options.include_revoked=1;
1232     opt.keyserver_options.try_dns_srv=1;
1233     opt.verify_options=VERIFY_SHOW_POLICY|VERIFY_SHOW_NOTATION;
1234     opt.trust_model=TM_AUTO;
1235     opt.mangle_dos_filenames = 1;
1236     opt.use_agent = 1;
1237
1238 #if defined (__MINGW32__)
1239     set_homedir ( read_w32_registry_string( NULL,
1240                                     "Software\\GNU\\GnuPG", "HomeDir" ));
1241 #else
1242     set_homedir ( getenv("GNUPGHOME") );
1243 #endif
1244     if( !*opt.homedir )
1245         set_homedir ( GNUPG_HOMEDIR );
1246
1247     /* check whether we have a config file on the commandline */
1248     orig_argc = argc;
1249     orig_argv = argv;
1250     pargs.argc = &argc;
1251     pargs.argv = &argv;
1252     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1253     while( arg_parse( &pargs, opts) ) {
1254         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1255             parse_debug++;
1256         else if( pargs.r_opt == oOptions ) {
1257             /* yes there is one, so we do not try the default one, but
1258              * read the option file when it is encountered at the commandline
1259              */
1260             default_config = 0;
1261         }
1262         else if( pargs.r_opt == oNoOptions )
1263             default_config = 0; /* --no-options */
1264         else if( pargs.r_opt == oHomedir )
1265             set_homedir ( pargs.r.ret_str );
1266         else if( pargs.r_opt == oNoPermissionWarn )
1267             opt.no_perm_warn=1;
1268         else if (pargs.r_opt == oStrict )
1269           {
1270             opt.strict=1;
1271             log_set_strict(1);
1272           }
1273         else if (pargs.r_opt == oNoStrict )
1274           {
1275             opt.strict=0;
1276             log_set_strict(0);
1277           }
1278 #ifdef USE_SHM_COPROCESSING
1279         else if( pargs.r_opt == oRunAsShmCP ) {
1280             /* does not make sense in a options file, we do it here,
1281              * so that we are the able to drop setuid as soon as possible */
1282             opt.shm_coprocess = 1;
1283             requested_shm_size = pargs.r.ret_ulong;
1284         }
1285         else if ( pargs.r_opt == oStatusFD ) {
1286             /* this is needed to ensure that the status-fd filedescriptor is
1287              * initialized when init_shm_coprocessing() is called */
1288             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1289         }
1290 #endif
1291     }
1292
1293 #ifdef HAVE_DOSISH_SYSTEM
1294     if ( strchr (opt.homedir,'\\') ) {
1295         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1296         const char *s = opt.homedir;
1297         for (d=buf,s=opt.homedir; *s; s++)
1298             *d++ = *s == '\\'? '/': *s;
1299         *d = 0;
1300         set_homedir (buf);
1301     }
1302 #endif
1303 #ifdef USE_SHM_COPROCESSING
1304     if( opt.shm_coprocess ) {
1305         init_shm_coprocessing(requested_shm_size, 1 );
1306     }
1307 #endif
1308     /* Initialize the secure memory. */
1309     gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1310     maybe_setuid = 0;
1311     /* Okay, we are now working under our real uid */
1312
1313     /* malloc hooks go here ... */
1314     assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1315
1316     set_native_charset (NULL); /* Try to auto set the character set */
1317
1318     if( default_config )
1319       {
1320        /* Try for a version specific config file first */
1321         configname = make_filename(opt.homedir,
1322                                    "gpg" EXTSEP_S "conf-" SAFE_VERSION, NULL );
1323         if(access(configname,R_OK))
1324           {
1325             xfree (configname);
1326             configname = make_filename(opt.homedir,
1327                                        "gpg" EXTSEP_S "conf", NULL );
1328           }
1329         if (!access (configname, R_OK))
1330           { /* Print a warning when both config files are present. */
1331             char *p = make_filename(opt.homedir, "options", NULL );
1332             if (!access (p, R_OK))
1333               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1334             xfree (p);
1335           }
1336         else
1337           { /* Keep on using the old default one. */
1338             xfree (configname);
1339             configname = make_filename(opt.homedir, "options", NULL );
1340           }
1341       }
1342     argc = orig_argc;
1343     argv = orig_argv;
1344     pargs.argc = &argc;
1345     pargs.argv = &argv;
1346     pargs.flags=  1;  /* do not remove the args */
1347
1348     /* By this point we have a homedir, and cannot change it. */
1349     check_permissions(opt.homedir,0);
1350
1351   next_pass:
1352     if( configname ) {
1353       if(check_permissions(configname,1))
1354         {
1355           /* If any options file is unsafe, then disable any external
1356              programs for keyserver calls or photo IDs.  Since the
1357              external program to call is set in the options file, a
1358              unsafe options file can lead to an arbitrary program
1359              being run. */
1360
1361           opt.exec_disable=1;
1362         }
1363
1364         configlineno = 0;
1365         configfp = fopen( configname, "r" );
1366         if( !configfp ) {
1367             if( default_config ) {
1368                 if( parse_debug )
1369                     log_info(_("NOTE: no default option file `%s'\n"),
1370                                                             configname );
1371             }
1372             else {
1373                 log_error(_("option file `%s': %s\n"),
1374                                     configname, strerror(errno) );
1375                 g10_exit(2);
1376             }
1377             xfree (configname); configname = NULL;
1378         }
1379         if( parse_debug && configname )
1380             log_info(_("reading options from `%s'\n"), configname );
1381         default_config = 0;
1382     }
1383
1384     while( optfile_parse( configfp, configname, &configlineno,
1385                                                 &pargs, opts) ) {
1386         switch( pargs.r_opt ) {
1387           case aCheckKeys: set_cmd( &cmd, aCheckKeys); break;
1388           case aListPackets: set_cmd( &cmd, aListPackets); break;
1389           case aImport: set_cmd( &cmd, aImport); break;
1390           case aFastImport: set_cmd( &cmd, aFastImport); break;
1391           case aSendKeys: set_cmd( &cmd, aSendKeys); break;
1392           case aRecvKeys: set_cmd( &cmd, aRecvKeys); break;
1393           case aSearchKeys: set_cmd( &cmd, aSearchKeys); break;
1394           case aRefreshKeys: set_cmd( &cmd, aRefreshKeys); break;
1395           case aExport: set_cmd( &cmd, aExport); break;
1396           case aExportAll: set_cmd( &cmd, aExportAll); break;
1397           case aListKeys: set_cmd( &cmd, aListKeys); break;
1398           case aListSigs: set_cmd( &cmd, aListSigs); break;
1399           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1400           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1401           case aDeleteSecretKeys: set_cmd( &cmd, aDeleteSecretKeys);
1402                                                         greeting=1; break;
1403           case aDeleteSecretAndPublicKeys:
1404             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1405             greeting=1; 
1406             break;
1407           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1408
1409           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1410           case aSym: set_cmd( &cmd, aSym); break;
1411
1412           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1413           case aDecryptFiles: set_cmd( &cmd, aDecryptFiles); break;
1414
1415           case aEncr: set_cmd( &cmd, aEncr); break;
1416           case aEncrFiles: set_cmd( &cmd, aEncrFiles ); break;
1417           case aSign: set_cmd( &cmd, aSign );  break;
1418           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1419           case aSignKey: set_cmd( &cmd, aSignKey); break;
1420           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1421           case aNRSignKey: set_cmd( &cmd, aNRSignKey); break;
1422           case aNRLSignKey: set_cmd( &cmd, aNRLSignKey); break;
1423           case aStore: set_cmd( &cmd, aStore); break;
1424           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1425           case aClearsign: set_cmd( &cmd, aClearsign); break;
1426           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1427           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1428           case aVerify: set_cmd( &cmd, aVerify); break;
1429           case aVerifyFiles: set_cmd( &cmd, aVerifyFiles); break;
1430           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1431           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1432           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1433           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1434           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1435           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1436           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1437           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1438           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1439           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1440           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1441           case aListOwnerTrust:
1442             deprecated_warning(configname,configlineno,
1443                                "--list-ownertrust","--export-ownertrust","");
1444           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1445           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1446           case aPipeMode: set_cmd( &cmd, aPipeMode); break;
1447           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1448
1449           case aCardStatus: set_cmd (&cmd, aCardStatus); break;
1450           case aChangePIN: set_cmd (&cmd, aChangePIN); break;
1451
1452           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1453           case oOutput: opt.outfile = pargs.r.ret_str; break;
1454           case oQuiet: opt.quiet = 1; break;
1455           case oNoTTY: tty_no_terminal(1); break;
1456           case oDryRun: opt.dry_run = 1; break;
1457           case oInteractive: opt.interactive = 1; break;
1458           case oVerbose: g10_opt_verbose++;
1459                     opt.verbose++; opt.list_sigs=1; break;
1460           case oKOption: set_cmd( &cmd, aKMode ); break;
1461
1462           case oBatch: opt.batch = 1; nogreeting = 1; break;
1463           case oUseAgent:
1464 #ifndef __riscos__
1465             opt.use_agent = 1;
1466 #else /* __riscos__ */
1467             opt.use_agent = 0;
1468             riscos_not_implemented("use-agent");
1469 #endif /* __riscos__ */
1470             break;
1471           case oNoUseAgent: opt.use_agent = 0; break;
1472           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
1473           case oAnswerYes: opt.answer_yes = 1; break;
1474           case oAnswerNo: opt.answer_no = 1; break;
1475           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
1476           case oPrimaryKeyring:
1477             sl=append_to_strlist( &nrings, pargs.r.ret_str);
1478             sl->flags=2;
1479             break;
1480           case oShowKeyring: opt.list_options|=LIST_SHOW_KEYRING; break;
1481           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
1482           case oDebugAll: opt.debug = ~0; break;
1483           case oStatusFD:
1484             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
1485             break;
1486 #ifdef __riscos__
1487           case oStatusFile:
1488             set_status_fd( iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1489             break;
1490 #endif /* __riscos__ */
1491           case oAttributeFD:
1492             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
1493             break;
1494 #ifdef __riscos__
1495           case oAttributeFile:
1496             set_attrib_fd(iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1497             break;
1498 #endif /* __riscos__ */
1499           case oLoggerFD:
1500             log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
1501             break;
1502 #ifdef __riscos__
1503           case oLoggerFile:
1504             log_set_logfile( NULL,
1505                              iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 1), 1) );
1506             break;
1507 #endif /* __riscos__ */
1508           case oWithFingerprint:
1509             opt.with_fingerprint = 1;
1510             with_fpr=1; /*fall thru*/
1511           case oFingerprint: opt.fingerprint++; break;
1512           case oSecretKeyring: append_to_strlist( &sec_nrings, pargs.r.ret_str); break;
1513           case oOptions:
1514             /* config files may not be nested (silently ignore them) */
1515             if( !configfp ) {
1516                 xfree (configname);
1517                 configname = xstrdup (pargs.r.ret_str);
1518                 goto next_pass;
1519             }
1520             break;
1521           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
1522           case oNoDefKeyring: default_keyring = 0; break;
1523           case oDefCertCheckLevel: opt.def_cert_check_level=pargs.r.ret_int; break;
1524           case oNoGreeting: nogreeting = 1; break;
1525           case oNoVerbose: g10_opt_verbose = 0;
1526                            opt.verbose = 0; opt.list_sigs=0; break;
1527       /* disabled for now: 
1528           case oQuickRandom: quick_random_gen(1); break; */
1529           case oSKComments: opt.sk_comments=1; break;
1530           case oNoSKComments: opt.sk_comments=0; break;
1531           case oEmitVersion: opt.no_version=0; break;
1532           case oNoEmitVersion: opt.no_version=1; break;
1533           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
1534           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
1535           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
1536           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
1537           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
1538           case oDefRecipient:
1539                     if( *pargs.r.ret_str )
1540                         opt.def_recipient = make_username(pargs.r.ret_str);
1541                     break;
1542           case oDefRecipientSelf:
1543                     xfree (opt.def_recipient); opt.def_recipient = NULL;
1544                     opt.def_recipient_self = 1;
1545                     break;
1546           case oNoDefRecipient:
1547                     xfree (opt.def_recipient); opt.def_recipient = NULL;
1548                     opt.def_recipient_self = 0;
1549                     break;
1550           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
1551           case oHomedir: break;
1552           case oNoBatch: opt.batch = 0; break;
1553           case oWithKeyData: opt.with_key_data=1; /* fall thru */
1554           case oWithColons: opt.with_colons=':'; break;
1555
1556           case oSkipVerify: opt.skip_verify=1; break;
1557           case oCompressKeys: opt.compress_keys = 1; break;
1558           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
1559             /* There are many programs (like mutt) that call gpg with
1560                --always-trust so keep this option around for a long
1561                time. */
1562           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
1563           case oTrustModel:
1564             if(ascii_strcasecmp(pargs.r.ret_str,"pgp")==0)
1565               opt.trust_model=TM_PGP;
1566             else if(ascii_strcasecmp(pargs.r.ret_str,"classic")==0)
1567               opt.trust_model=TM_CLASSIC;
1568             else if(ascii_strcasecmp(pargs.r.ret_str,"always")==0)
1569               opt.trust_model=TM_ALWAYS;
1570             else if(ascii_strcasecmp(pargs.r.ret_str,"auto")==0)
1571               opt.trust_model=TM_AUTO;
1572             else
1573               log_error("unknown trust model \"%s\"\n",pargs.r.ret_str);
1574             break;
1575           case oForceOwnertrust:
1576             log_info(_("NOTE: %s is not for normal use!\n"),
1577                      "--force-ownertrust");
1578             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
1579             if(opt.force_ownertrust==-1)
1580               {
1581                 log_error("invalid ownertrust \"%s\"\n",pargs.r.ret_str);
1582                 opt.force_ownertrust=0;
1583               }
1584             break;
1585           case oLoadExtension:
1586 #ifndef __riscos__
1587 #if defined(USE_DYNAMIC_LINKING) || defined(__MINGW32__)
1588             if(check_permissions(pargs.r.ret_str,2))
1589               log_info(_("cipher extension \"%s\" not loaded due to "
1590                          "unsafe permissions\n"),pargs.r.ret_str);
1591             else
1592               register_cipher_extension(orig_argc? *orig_argv:NULL,
1593                                         pargs.r.ret_str);
1594 #endif
1595 #else /* __riscos__ */
1596             riscos_not_implemented("load-extension");
1597 #endif /* __riscos__ */
1598             break;
1599           case oRFC1991:
1600             opt.compliance = CO_RFC1991;
1601             opt.force_v4_certs = 0;
1602             opt.disable_mdc = 1;
1603             opt.escape_from = 1;
1604             break;
1605           case oOpenPGP:
1606             /* TODO: When 2440bis becomes a RFC, these may need
1607                changing. */
1608             opt.compliance = CO_RFC2440;
1609             opt.disable_mdc = 1;
1610             opt.allow_non_selfsigned_uid = 1;
1611             opt.allow_freeform_uid = 1;
1612             opt.pgp2_workarounds = 0;
1613             opt.escape_from = 0;
1614             opt.force_v3_sigs = 0;
1615             opt.compress_keys = 0;          /* not mandated  but we do it */
1616             opt.compress_sigs = 0;          /* ditto. */
1617             opt.not_dash_escaped = 0;
1618             opt.def_cipher_algo = 0;
1619             opt.def_digest_algo = 0;
1620             opt.cert_digest_algo = 0;
1621             opt.def_compress_algo = -1;
1622             opt.s2k_mode = 3; /* iterated+salted */
1623             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
1624             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1625             break;
1626           case oPGP2:  opt.compliance = CO_PGP2;  break;
1627           case oPGP6:  opt.compliance = CO_PGP6;  break;
1628           case oPGP7:  opt.compliance = CO_PGP7;  break;
1629           case oPGP8:  opt.compliance = CO_PGP8;  break;
1630           case oGnuPG: opt.compliance = CO_GNUPG; break;
1631           case oEmuMDEncodeBug: opt.emulate_bugs |= EMUBUG_MDENCODE; break;
1632           case oCompressSigs: opt.compress_sigs = 1; break;
1633           case oRunAsShmCP:
1634 #ifndef __riscos__
1635 # ifndef USE_SHM_COPROCESSING
1636             /* not possible in the option file,
1637              * but we print the warning here anyway */
1638             log_error("shared memory coprocessing is not available\n");
1639 # endif
1640 #else /* __riscos__ */
1641             riscos_not_implemented("run-as-shm-coprocess");
1642 #endif /* __riscos__ */
1643             break;
1644           case oSetFilename: opt.set_filename = pargs.r.ret_str; break;
1645           case oForYourEyesOnly: eyes_only = 1; break;
1646           case oNoForYourEyesOnly: eyes_only = 0; break;
1647           case oSetPolicyURL:
1648             add_policy_url(pargs.r.ret_str,0);
1649             add_policy_url(pargs.r.ret_str,1);
1650             break;
1651           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
1652           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
1653           case oShowPolicyURL:
1654             opt.list_options|=LIST_SHOW_POLICY;
1655             opt.verify_options|=VERIFY_SHOW_POLICY;
1656             break;
1657           case oNoShowPolicyURL:
1658             opt.list_options&=~LIST_SHOW_POLICY;
1659             opt.verify_options&=~VERIFY_SHOW_POLICY;
1660             break;
1661           case oUseEmbeddedFilename: opt.use_embedded_filename = 1; break;
1662           case oComment: opt.comment_string = pargs.r.ret_str; break;
1663           case oDefaultComment: opt.comment_string = NULL; break;
1664           case oThrowKeyid: opt.throw_keyid = 1; break;
1665           case oNoThrowKeyid: opt.throw_keyid = 0; break;
1666           case oShowPhotos: 
1667             opt.list_options|=LIST_SHOW_PHOTOS;
1668             opt.verify_options|=VERIFY_SHOW_PHOTOS;
1669             break;
1670           case oNoShowPhotos:
1671             opt.list_options&=~LIST_SHOW_PHOTOS;
1672             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
1673             break;
1674           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
1675           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
1676           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
1677           case oForceV4Certs: opt.force_v4_certs = 1; break;
1678           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
1679           case oForceMDC: opt.force_mdc = 1; break;
1680           case oNoForceMDC: opt.force_mdc = 0; break;
1681           case oDisableMDC: opt.disable_mdc = 1; break;
1682           case oNoDisableMDC: opt.disable_mdc = 0; break;
1683           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
1684           case oS2KDigest: s2k_digest_string = xstrdup (pargs.r.ret_str); break;
1685           case oS2KCipher: s2k_cipher_string = xstrdup (pargs.r.ret_str); break;
1686           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
1687           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
1688           case oEncryptTo: /* store the recipient in the second list */
1689             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1690             sl->flags = 1;
1691             break;
1692           case oHiddenEncryptTo: /* store the recipient in the second list */
1693             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1694             sl->flags = 1|2;
1695             break;
1696           case oRecipient: /* store the recipient */
1697             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1698             any_explicit_recipient = 1;
1699             break;
1700           case oHiddenRecipient: /* store the recipient with a flag */
1701             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
1702             sl->flags = 2;
1703             any_explicit_recipient = 1;
1704             break;
1705           case oTextmodeShort: opt.textmode = 2; break;
1706           case oTextmode: opt.textmode=1;  break;
1707           case oNoTextmode: opt.textmode=0;  break;
1708           case oExpert: opt.expert = 1; break;
1709           case oNoExpert: opt.expert = 0; break;
1710           case oAskSigExpire: opt.ask_sig_expire = 1; break;
1711           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
1712           case oAskCertExpire: opt.ask_cert_expire = 1; break;
1713           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
1714           case oUser: /* store the local users */
1715             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
1716             break;
1717           case oCompress: opt.compress = pargs.r.ret_int; break;
1718           case oPasswdFD:
1719             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1720             break;
1721 #ifdef __riscos__
1722           case oPasswdFile:
1723             pwfd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1724             break;
1725 #endif /* __riscos__ */
1726           case oCommandFD:
1727             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
1728             break;
1729 #ifdef __riscos__
1730           case oCommandFile:
1731             opt.command_fd = iobuf_translate_file_handle ( riscos_fdopenfile (pargs.r.ret_str, 0), 0);
1732             break;
1733 #endif /* __riscos__ */
1734           case oCipherAlgo: def_cipher_string = xstrdup (pargs.r.ret_str); break;
1735           case oDigestAlgo: def_digest_string = xstrdup (pargs.r.ret_str); break;
1736           case oCompressAlgo:
1737             /* If it is all digits, stick a Z in front of it for
1738                later.  This is for backwards compatibility with
1739                versions that took the compress algorithm number. */
1740             {
1741               char *pt=pargs.r.ret_str;
1742               while(*pt)
1743                 {
1744                   if(!isdigit(*pt))
1745                     break;
1746
1747                   pt++;
1748                 }
1749
1750               if(*pt=='\0')
1751                 {
1752                   def_compress_string=xmalloc (strlen(pargs.r.ret_str)+2);
1753                   strcpy(def_compress_string,"Z");
1754                   strcat(def_compress_string,pargs.r.ret_str);
1755                 }
1756               else
1757                 def_compress_string = xstrdup (pargs.r.ret_str);
1758             }
1759             break;
1760           case oCertDigestAlgo: cert_digest_string = xstrdup (pargs.r.ret_str); break;
1761           case oNoSecmemWarn:
1762 #warning add secmem_get_flags
1763 /*              secmem_set_flags( secmem_get_flags() | 1 ); */
1764             break;
1765           case oNoPermissionWarn: opt.no_perm_warn=1; break;
1766           case oNoMDCWarn: opt.no_mdc_warn=1; break;
1767           case oCharset:
1768             if( set_native_charset( pargs.r.ret_str ) )
1769                 log_error(_("%s is not a valid character set\n"),
1770                                                     pargs.r.ret_str);
1771             break;
1772           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
1773           case oEscapeFrom: opt.escape_from = 1; break;
1774           case oNoEscapeFrom: opt.escape_from = 0; break;
1775           case oLockOnce: opt.lock_once = 1; break;
1776           case oLockNever: disable_dotlock(); break;
1777           case oLockMultiple:
1778 #ifndef __riscos__
1779             opt.lock_once = 0;
1780 #else /* __riscos__ */
1781             riscos_not_implemented("lock-multiple");
1782 #endif /* __riscos__ */
1783             break;
1784           case oKeyServer:
1785             opt.keyserver_uri=xstrdup (pargs.r.ret_str);
1786             if(parse_keyserver_uri(pargs.r.ret_str,configname,configlineno))
1787               log_error(_("could not parse keyserver URI\n"));
1788             break;
1789           case oKeyServerOptions:
1790             parse_keyserver_options(pargs.r.ret_str);
1791             break;
1792           case oImportOptions:
1793             if(!parse_import_options(pargs.r.ret_str,&opt.import_options))
1794               {
1795                 if(configname)
1796                   log_error(_("%s:%d: invalid import options\n"),
1797                             configname,configlineno);
1798                 else
1799                   log_error(_("invalid import options\n"));
1800               }
1801             break;
1802           case oExportOptions:
1803             if(!parse_export_options(pargs.r.ret_str,&opt.export_options))
1804               {
1805                 if(configname)
1806                   log_error(_("%s:%d: invalid export options\n"),
1807                             configname,configlineno);
1808                 else
1809                   log_error(_("invalid export options\n"));
1810               }
1811             break;
1812           case oListOptions:
1813             {
1814               struct parse_options lopts[]=
1815                 {
1816                   {"show-photos",LIST_SHOW_PHOTOS},
1817                   {"show-policy-url",LIST_SHOW_POLICY},
1818                   {"show-notation",LIST_SHOW_NOTATION},
1819                   {"show-keyring",LIST_SHOW_KEYRING},
1820                   {"show-validity",LIST_SHOW_VALIDITY},
1821                   {"show-long-keyid",LIST_SHOW_LONG_KEYID},
1822                   {NULL,0}
1823                 };
1824
1825               if(!parse_options(pargs.r.ret_str,&opt.list_options,lopts))
1826                 {
1827                   if(configname)
1828                     log_error(_("%s:%d: invalid list options\n"),
1829                               configname,configlineno);
1830                   else
1831                     log_error(_("invalid list options\n"));
1832                 }
1833             }
1834             break;
1835           case oVerifyOptions:
1836             {
1837               struct parse_options vopts[]=
1838                 {
1839                   {"show-photos",VERIFY_SHOW_PHOTOS},
1840                   {"show-policy-url",VERIFY_SHOW_POLICY},
1841                   {"show-notation",VERIFY_SHOW_NOTATION},
1842                   {NULL,0}
1843                 };
1844
1845               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts))
1846                 {
1847                   if(configname)
1848                     log_error(_("%s:%d: invalid verify options\n"),
1849                               configname,configlineno);
1850                   else
1851                     log_error(_("invalid verify options\n"));
1852                 }
1853             }
1854             break;
1855           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
1856           case oExecPath:
1857             if(set_exec_path(pargs.r.ret_str,0))
1858               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
1859             else
1860               opt.exec_path_set=1;
1861             break;
1862           case oNotation:
1863             add_notation_data( pargs.r.ret_str, 0 );
1864             add_notation_data( pargs.r.ret_str, 1 );
1865             break;
1866           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
1867           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
1868           case oShowNotation:
1869             opt.list_options|=LIST_SHOW_NOTATION;
1870             opt.verify_options|=VERIFY_SHOW_NOTATION;
1871             break;
1872           case oNoShowNotation:
1873             opt.list_options&=~LIST_SHOW_NOTATION;
1874             opt.verify_options&=~VERIFY_SHOW_NOTATION;
1875             break;
1876           case oUtf8Strings: utf8_strings = 1; break;
1877           case oNoUtf8Strings: utf8_strings = 0; break;
1878           case oDisableCipherAlgo:
1879             {
1880               int algo = gcry_cipher_map_name (pargs.r.ret_str);
1881               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO,
1882                                &algo, sizeof algo);
1883             }
1884             break;
1885           case oDisablePubkeyAlgo:
1886             {
1887               int algo = gcry_pk_map_name (pargs.r.ret_str);
1888               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO,
1889                            &algo, sizeof algo );
1890             }
1891             break;
1892           case oNoSigCache: opt.no_sig_cache = 1; break;
1893           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
1894           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
1895           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
1896           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
1897           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
1898           case oNoLiteral: opt.no_literal = 1; break;
1899           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
1900           case oHonorHttpProxy:
1901                 opt.keyserver_options.honor_http_proxy = 1;
1902                 deprecated_warning(configname,configlineno,
1903                                    "--honor-http-proxy",
1904                                    "--keyserver-options ",
1905                                    "honor-http-proxy");
1906                 break;
1907           case oFastListMode: opt.fast_list_mode = 1; break;
1908           case oFixedListMode: opt.fixed_list_mode = 1; break;
1909           case oListOnly: opt.list_only=1; break;
1910           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
1911           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
1912           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
1913           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
1914           case oNoRandomSeedFile: use_random_seed = 0; break;
1915           case oAutoKeyRetrieve:
1916           case oNoAutoKeyRetrieve:
1917                 opt.keyserver_options.auto_key_retrieve=
1918                                              (pargs.r_opt==oAutoKeyRetrieve);
1919                 deprecated_warning(configname,configlineno,
1920                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
1921                                "--no-auto-key-retrieve","--keyserver-options ",
1922                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
1923                                "no-auto-key-retrieve");
1924                 break;
1925           case oShowSessionKey: opt.show_session_key = 1; break;
1926           case oOverrideSessionKey:
1927                 opt.override_session_key = pargs.r.ret_str;
1928                 break;
1929           case oMergeOnly: opt.merge_only = 1; break;
1930           case oAllowSecretKeyImport: /* obsolete */ break;
1931           case oTryAllSecrets: opt.try_all_secrets = 1; break;
1932           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
1933           case oEnableSpecialFilenames:
1934             iobuf_enable_special_filenames (1);
1935             break;
1936           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
1937           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
1938           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
1939           case oPreservePermissions: opt.preserve_permissions=1; break;
1940           case oDefaultPreferenceList:
1941             opt.def_preference_list = pargs.r.ret_str;
1942             break;
1943           case oPersonalCipherPreferences:
1944             pers_cipher_list=pargs.r.ret_str;
1945             break;
1946           case oPersonalDigestPreferences:
1947             pers_digest_list=pargs.r.ret_str;
1948             break;
1949           case oPersonalCompressPreferences:
1950             pers_compress_list=pargs.r.ret_str;
1951             break;
1952           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
1953           case oDisplay: opt.display = pargs.r.ret_str; break;
1954           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
1955           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
1956           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
1957           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
1958           case oGroup: add_group(pargs.r.ret_str); break;
1959           case oStrict: opt.strict=1; log_set_strict(1); break;
1960           case oNoStrict: opt.strict=0; log_set_strict(0); break;
1961
1962           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
1963           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
1964
1965           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
1966
1967           default : pargs.err = configfp? 1:2; break;
1968         }
1969     }
1970
1971     if( configfp ) {
1972         fclose( configfp );
1973         configfp = NULL;
1974         xfree (configname); configname = NULL;
1975         goto next_pass;
1976     }
1977     xfree ( configname ); configname = NULL;
1978     if( log_get_errorcount(0) )
1979         g10_exit(2);
1980     if( nogreeting )
1981         greeting = 0;
1982
1983     if( greeting ) {
1984         fprintf(stderr, "%s %s; %s\n",
1985                         strusage(11), strusage(13), strusage(14) );
1986         fprintf(stderr, "%s\n", strusage(15) );
1987     }
1988 #ifdef IS_DEVELOPMENT_VERSION
1989     if( !opt.batch ) {
1990         log_info("NOTE: THIS IS A DEVELOPMENT VERSION!\n");
1991         log_info("It is only intended for test purposes and should NOT be\n");
1992         log_info("used in a production environment or with production keys!\n");
1993     }
1994 #endif
1995
1996 #warning locking does not work - disabled
1997     disable_dotlock ();
1998
1999     if (opt.verbose > 2)
2000         log_info ("using character set `%s'\n", get_native_charset ());
2001
2002     if( may_coredump && !opt.quiet )
2003         log_info(_("WARNING: program may create a core file!\n"));
2004
2005     if (eyes_only) {
2006       if (opt.set_filename)
2007           log_info(_("WARNING: %s overrides %s\n"),
2008                    "--for-your-eyes-only","--set-filename");
2009
2010       opt.set_filename="_CONSOLE";
2011     }
2012
2013     if (opt.no_literal) {
2014         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2015         if (opt.textmode)
2016             log_error(_("%s not allowed with %s!\n"),
2017                        "--textmode", "--no-literal" );
2018         if (opt.set_filename)
2019             log_error(_("%s makes no sense with %s!\n"),
2020                         eyes_only?"--for-your-eyes-only":"--set-filename",
2021                         "--no-literal" );
2022     }
2023
2024     if (opt.set_filesize)
2025         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2026     if( opt.batch )
2027         tty_batchmode( 1 );
2028
2029 #warning fix that
2030 #if 0
2031     secmem_set_flags( secmem_get_flags() & ~2 ); /* resume warnings */
2032 #endif
2033     set_debug();
2034
2035     /* Do these after the switch(), so they can override settings. */
2036     if(PGP2)
2037       {
2038         int unusable=0;
2039
2040         if(cmd==aSign && !detached_sig)
2041           {
2042             log_info(_("you can only make detached or clear signatures "
2043                        "while in --pgp2 mode\n"));
2044             unusable=1;
2045           }
2046         else if(cmd==aSignEncr || cmd==aSignSym)
2047           {
2048             log_info(_("you can't sign and encrypt at the "
2049                        "same time while in --pgp2 mode\n"));
2050             unusable=1;
2051           }
2052         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2053           {
2054             log_info(_("you must use files (and not a pipe) when "
2055                        "working with --pgp2 enabled.\n"));
2056             unusable=1;
2057           }
2058         else if(cmd==aEncr || cmd==aSym)
2059           {
2060             /* Everything else should work without IDEA (except using
2061                a secret key encrypted with IDEA and setting an IDEA
2062                preference, but those have their own error
2063                messages). */
2064
2065             if(openpgp_cipher_test_algo (CIPHER_ALGO_IDEA))
2066               {
2067                 log_info(_("encrypting a message in --pgp2 mode requires "
2068                            "the IDEA cipher\n"));
2069                 idea_cipher_warn(1);
2070                 unusable=1;
2071               }
2072             else if(cmd==aSym)
2073               {
2074                 /* This only sets IDEA for symmetric encryption
2075                    since it is set via select_algo_from_prefs for
2076                    pk encryption. */
2077                 xfree (def_cipher_string);
2078                 def_cipher_string = xstrdup ("idea");
2079               }
2080
2081             /* PGP2 can't handle the output from the textmode
2082                filter, so we disable it for anything that could
2083                create a literal packet (only encryption and
2084                symmetric encryption, since we disable signing
2085                above). */
2086             if(!unusable)
2087               opt.textmode=0;
2088           }
2089
2090         if(unusable)
2091           compliance_failure();
2092         else
2093           {
2094             opt.force_mdc = 0;
2095             opt.disable_mdc = 1;
2096             opt.force_v4_certs = 0;
2097             opt.sk_comments = 0;
2098             opt.escape_from = 1;
2099             opt.force_v3_sigs = 1;
2100             opt.pgp2_workarounds = 1;
2101             opt.ask_sig_expire = 0;
2102             opt.ask_cert_expire = 0;
2103             xfree (def_digest_string);
2104             def_digest_string = xstrdup ("md5");
2105             opt.def_compress_algo = 1;
2106           }
2107       }
2108     else if(PGP6)
2109       {
2110         opt.sk_comments=0;
2111         opt.escape_from=1;
2112         opt.force_v3_sigs=1;
2113         opt.ask_sig_expire=0;
2114         opt.force_mdc=0;
2115         opt.disable_mdc=1;
2116       }
2117     else if(PGP7)
2118       {
2119         opt.sk_comments=0;
2120         opt.escape_from=1;
2121         opt.force_v3_sigs=1;
2122         opt.ask_sig_expire=0;
2123       }
2124     else if(PGP8)
2125       {
2126         opt.escape_from=1;
2127       }
2128
2129     /* must do this after dropping setuid, because string_to...
2130      * may try to load an module */
2131     if( def_cipher_string ) {
2132         opt.def_cipher_algo = gcry_cipher_map_name (def_cipher_string);
2133         if(opt.def_cipher_algo==0 &&
2134            (ascii_strcasecmp(def_cipher_string,"idea")==0
2135             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2136           idea_cipher_warn(1);
2137         xfree (def_cipher_string); def_cipher_string = NULL;
2138         if( openpgp_cipher_test_algo (opt.def_cipher_algo) )
2139             log_error(_("selected cipher algorithm is invalid\n"));
2140     }
2141     if( def_digest_string ) {
2142         opt.def_digest_algo = gcry_md_map_name (def_digest_string);
2143         xfree (def_digest_string); def_digest_string = NULL;
2144         if( openpgp_md_test_algo (opt.def_digest_algo) )
2145             log_error(_("selected digest algorithm is invalid\n"));
2146     }
2147     if( def_compress_string ) {
2148         opt.def_compress_algo = string_to_compress_algo(def_compress_string);
2149         xfree (def_compress_string); def_compress_string = NULL;
2150         if( check_compress_algo(opt.def_compress_algo) )
2151             log_error(_("selected compression algorithm is invalid\n"));
2152     }
2153     if( cert_digest_string ) {
2154         opt.cert_digest_algo = gcry_md_map_name (cert_digest_string);
2155         xfree (cert_digest_string); cert_digest_string = NULL;
2156         if( openpgp_md_test_algo(opt.cert_digest_algo) )
2157             log_error(_("selected certification digest algorithm is invalid\n"));
2158     }
2159     if( s2k_cipher_string ) {
2160         opt.s2k_cipher_algo = gcry_cipher_map_name (s2k_cipher_string);
2161         xfree (s2k_cipher_string); s2k_cipher_string = NULL;
2162         if( openpgp_cipher_test_algo (opt.s2k_cipher_algo) )
2163             log_error(_("selected cipher algorithm is invalid\n"));
2164     }
2165     if( s2k_digest_string ) {
2166         opt.s2k_digest_algo = gcry_md_map_name (s2k_digest_string);
2167         xfree (s2k_digest_string); s2k_digest_string = NULL;
2168         if( openpgp_md_test_algo (opt.s2k_digest_algo) )
2169             log_error(_("selected digest algorithm is invalid\n"));
2170     }
2171     if( opt.completes_needed < 1 )
2172         log_error(_("completes-needed must be greater than 0\n"));
2173     if( opt.marginals_needed < 2 )
2174         log_error(_("marginals-needed must be greater than 1\n"));
2175     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2176         log_error(_("max-cert-depth must be in range 1 to 255\n"));
2177     switch( opt.s2k_mode ) {
2178       case 0:
2179         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2180         break;
2181       case 1: case 3: break;
2182       default:
2183         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2184     }
2185
2186     if(opt.def_cert_check_level<0 || opt.def_cert_check_level>3)
2187       log_error(_("invalid default-check-level; must be 0, 1, 2, or 3\n"));
2188
2189     /* This isn't actually needed, but does serve to error out if the
2190        string is invalid. */
2191     if(opt.def_preference_list &&
2192         keygen_set_std_prefs(opt.def_preference_list,0))
2193       log_error(_("invalid default preferences\n"));
2194
2195     /* We provide defaults for the personal digest list */
2196     if(!pers_digest_list)
2197       pers_digest_list="h2";
2198
2199     if(pers_cipher_list &&
2200        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2201       log_error(_("invalid personal cipher preferences\n"));
2202
2203     if(pers_digest_list &&
2204        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2205       log_error(_("invalid personal digest preferences\n"));
2206
2207     if(pers_compress_list &&
2208        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2209       log_error(_("invalid personal compress preferences\n"));
2210
2211     if( log_get_errorcount(0) )
2212         g10_exit(2);
2213
2214     /* Check our chosen algorithms against the list of legal
2215        algorithms. */
2216
2217     if(!GNUPG)
2218       {
2219         const char *badalg=NULL;
2220         preftype_t badtype=PREFTYPE_NONE;
2221
2222         if (opt.def_cipher_algo
2223             && !algo_available (PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2224           {
2225             badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
2226             badtype = PREFTYPE_SYM;
2227           }
2228         else if (opt.def_digest_algo
2229                 && !algo_available (PREFTYPE_HASH,opt.def_digest_algo,NULL))
2230           {
2231             badalg = gcry_md_algo_name (opt.def_digest_algo);
2232             badtype = PREFTYPE_HASH;
2233           }
2234         else if (opt.cert_digest_algo
2235                  && !algo_available (PREFTYPE_HASH,opt.cert_digest_algo,NULL))
2236           {
2237             badalg = gcry_md_algo_name (opt.cert_digest_algo);
2238             badtype = PREFTYPE_HASH;
2239           }
2240         else if (opt.def_compress_algo!=-1
2241                  && !algo_available (PREFTYPE_ZIP,opt.def_compress_algo,NULL))
2242           {
2243             badalg = compress_algo_to_string (opt.def_compress_algo);
2244             badtype = PREFTYPE_ZIP;
2245           }
2246
2247         if (badalg)
2248           {
2249             switch(badtype)
2250               {
2251               case PREFTYPE_SYM:
2252                 log_info(_("you may not use cipher algorithm \"%s\" "
2253                            "while in %s mode\n"),
2254                          badalg,compliance_option_string());
2255                 break;
2256               case PREFTYPE_HASH:
2257                 log_info(_("you may not use digest algorithm \"%s\" "
2258                            "while in %s mode\n"),
2259                          badalg,compliance_option_string());
2260                 break;
2261               case PREFTYPE_ZIP:
2262                 log_info(_("you may not use compression algorithm \"%s\" "
2263                            "while in %s mode\n"),
2264                          badalg,compliance_option_string());
2265                 break;
2266               default:
2267                 BUG();
2268               }
2269
2270             compliance_failure();
2271           }
2272       }
2273
2274     /* set the random seed file */
2275     if( use_random_seed ) {
2276         char *p = make_filename(opt.homedir, "random_seed", NULL );
2277 #warning No random seed file yet
2278 #if 0
2279         set_random_seed_file(p);
2280 #endif
2281         xfree (p);
2282     }
2283
2284     if( !cmd && opt.fingerprint && !with_fpr ) {
2285         set_cmd( &cmd, aListKeys);
2286     }
2287
2288     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
2289         if( cmd == aKModeC ) {
2290             opt.fingerprint = 1;
2291             cmd = aKMode;
2292         }
2293         opt.list_sigs = 0;
2294         if( opt.verbose > 2 )
2295             opt.check_sigs++;
2296         if( opt.verbose > 1 )
2297             opt.list_sigs++;
2298
2299         opt.verbose = opt.verbose > 1;
2300         g10_opt_verbose = opt.verbose;
2301     }
2302
2303     /* Compression algorithm 0 means no compression at all */
2304     if( opt.def_compress_algo == 0)
2305         opt.compress = 0;
2306
2307     /* kludge to let -sat generate a clear text signature */
2308     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
2309         cmd = aClearsign;
2310
2311     if( opt.verbose > 1 )
2312         set_packet_list_mode(1);
2313
2314     /* Add the keyrings, but not for some special commands and not in
2315        case of "-kvv userid keyring".  Also avoid adding the secret
2316        keyring for a couple of commands to avoid unneeded access in
2317        case the secrings are stored on a floppy */
2318     if( cmd != aDeArmor && cmd != aEnArmor
2319         && !(cmd == aKMode && argc == 2 ) ) 
2320       {
2321         if (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
2322             && cmd != aVerify && cmd != aVerifyFiles
2323             && cmd != aSym)
2324           {
2325             if (!sec_nrings || default_keyring) /* add default secret rings */
2326               keydb_add_resource ("secring" EXTSEP_S "gpg", 0, 1);
2327             for (sl = sec_nrings; sl; sl = sl->next)
2328               keydb_add_resource ( sl->d, 0, 1 );
2329           }
2330         if( !nrings || default_keyring )  /* add default ring */
2331             keydb_add_resource ("pubring" EXTSEP_S "gpg", 0, 0);
2332         for(sl = nrings; sl; sl = sl->next )
2333             keydb_add_resource ( sl->d, sl->flags, 0 );
2334       }
2335     FREE_STRLIST(nrings);
2336     FREE_STRLIST(sec_nrings);
2337
2338
2339     if( pwfd != -1 )  /* read the passphrase now. */
2340         read_passphrase_from_fd( pwfd );
2341
2342     fname = argc? *argv : NULL;
2343
2344     switch( cmd ) {
2345       case aPrimegen:
2346       case aPrintMD:
2347       case aPrintMDs:
2348       case aGenRandom:
2349       case aDeArmor:
2350       case aEnArmor:
2351       case aFixTrustDB:
2352       case aCardStatus:
2353       case aChangePIN:
2354         break;
2355       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
2356       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
2357       default: rc = setup_trustdb(1, trustdb_name ); break;
2358     }
2359     if( rc )
2360         log_error(_("failed to initialize the TrustDB: %s\n"), gpg_strerror (rc));
2361
2362
2363     switch (cmd) {
2364       case aStore: 
2365       case aSym:  
2366       case aSign: 
2367       case aSignSym: 
2368       case aClearsign: 
2369         if (!opt.quiet && any_explicit_recipient)
2370           log_info (_("WARNING: recipients (-r) given "
2371                       "without using public key encryption\n"));
2372         break;
2373       default:
2374         break;
2375     }
2376
2377     switch( cmd ) {
2378       case aStore: /* only store the file */
2379         if( argc > 1 )
2380             wrong_args(_("--store [filename]"));
2381         if( (rc = encode_store(fname)) )
2382             log_error ("\b%s: store failed: %s\n",
2383                        print_fname_stdin(fname), gpg_strerror (rc) );
2384         break;
2385       case aSym: /* encrypt the given file only with the symmetric cipher */
2386         if( argc > 1 )
2387             wrong_args(_("--symmetric [filename]"));
2388         if( (rc = encode_symmetric(fname)) )
2389             log_error ("\b%s: symmetric encryption failed: %s\n",
2390                        print_fname_stdin(fname), gpg_strerror (rc) );
2391         break;
2392
2393       case aEncr: /* encrypt the given file */
2394         if( argc > 1 )
2395             wrong_args(_("--encrypt [filename]"));
2396         if( (rc = encode_crypt(fname,remusr)) )
2397             log_error("%s: encryption failed: %s\n",
2398                       print_fname_stdin(fname), gpg_strerror (rc) );
2399         break;
2400
2401       case aEncrFiles: /* encrypt the given files */
2402         encode_crypt_files(argc, argv, remusr);
2403         break;
2404           
2405       case aSign: /* sign the given file */
2406         sl = NULL;
2407         if( detached_sig ) { /* sign all files */
2408             for( ; argc; argc--, argv++ )
2409                 add_to_strlist( &sl, *argv );
2410         }
2411         else {
2412             if( argc > 1 )
2413                 wrong_args(_("--sign [filename]"));
2414             if( argc ) {
2415                 sl = xcalloc (1, sizeof *sl + strlen(fname));
2416                 strcpy(sl->d, fname);
2417             }
2418         }
2419         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
2420             log_error("signing failed: %s\n", gpg_strerror (rc) );
2421         free_strlist(sl);
2422         break;
2423
2424       case aSignEncr: /* sign and encrypt the given file */
2425         if( argc > 1 )
2426             wrong_args(_("--sign --encrypt [filename]"));
2427         if( argc ) {
2428             sl = xcalloc (1, sizeof *sl + strlen(fname));
2429             strcpy(sl->d, fname);
2430         }
2431         else
2432             sl = NULL;
2433         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
2434             log_error("%s: sign+encrypt failed: %s\n", print_fname_stdin(fname), gpg_strerror (rc) );
2435         free_strlist(sl);
2436         break;
2437
2438       case aSignSym: /* sign and conventionally encrypt the given file */
2439         if (argc > 1)
2440             wrong_args(_("--sign --symmetric [filename]"));
2441         rc = sign_symencrypt_file (fname, locusr);
2442         if (rc)
2443             log_error("%s: sign+symmetric failed: %s\n",
2444                       print_fname_stdin(fname), gpg_strerror (rc) );
2445         break;
2446
2447       case aClearsign: /* make a clearsig */
2448         if( argc > 1 )
2449             wrong_args(_("--clearsign [filename]"));
2450         if( (rc = clearsign_file(fname, locusr, NULL)) )
2451             log_error("%s: clearsign failed: %s\n",
2452                       print_fname_stdin(fname), gpg_strerror (rc) );
2453         break;
2454
2455       case aVerify:
2456         if( (rc = verify_signatures( argc, argv ) ))
2457             log_error("verify signatures failed: %s\n", gpg_strerror (rc) );
2458         break;
2459
2460       case aVerifyFiles:
2461         if( (rc = verify_files( argc, argv ) ))
2462             log_error("verify files failed: %s\n", gpg_strerror (rc) );
2463         break;
2464
2465       case aDecrypt:
2466         if( argc > 1 )
2467             wrong_args(_("--decrypt [filename]"));
2468         if( (rc = decrypt_message( fname ) ))
2469             log_error("decrypt_message failed: %s\n", gpg_strerror (rc) );
2470         break;
2471
2472       case aDecryptFiles:
2473         decrypt_messages(argc, argv);
2474         break;
2475             
2476       case aSignKey: /* sign the key given as argument */
2477         if( argc != 1 )
2478             wrong_args(_("--sign-key user-id"));
2479         username = make_username( fname );
2480         keyedit_menu(fname, locusr, NULL, 1 );
2481         xfree (username);
2482         break;
2483
2484       case aLSignKey:
2485         if( argc != 1 )
2486             wrong_args(_("--lsign-key user-id"));
2487         username = make_username( fname );
2488         keyedit_menu(fname, locusr, NULL, 2 );
2489         xfree (username);
2490         break;
2491
2492       case aNRSignKey:
2493         if( argc != 1 )
2494             wrong_args(_("--nrsign-key user-id"));
2495         username = make_username( fname );
2496         keyedit_menu(fname, locusr, NULL, 3 );
2497         xfree (username);
2498         break;
2499
2500       case aNRLSignKey:
2501         if( argc != 1 )
2502             wrong_args(_("--nrlsign-key user-id"));
2503         username = make_username( fname );
2504         keyedit_menu(fname, locusr, NULL, 4 );
2505         xfree (username);
2506         break;
2507
2508       case aEditKey: /* Edit a key signature */
2509         if( !argc )
2510             wrong_args(_("--edit-key user-id [commands]"));
2511         username = make_username( fname );
2512         if( argc > 1 ) {
2513             sl = NULL;
2514             for( argc--, argv++ ; argc; argc--, argv++ )
2515                 append_to_strlist( &sl, *argv );
2516             keyedit_menu( username, locusr, sl, 0 );
2517             free_strlist(sl);
2518         }
2519         else
2520             keyedit_menu(username, locusr, NULL, 0 );
2521         xfree (username);
2522         break;
2523
2524       case aDeleteKeys:
2525       case aDeleteSecretKeys:
2526       case aDeleteSecretAndPublicKeys:
2527         sl = NULL;
2528         /* I'm adding these in reverse order as add_to_strlist2
2529            reverses them again, and it's easier to understand in the
2530            proper order :) */
2531         for( ; argc; argc-- )
2532           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
2533         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
2534         free_strlist(sl);
2535         break;
2536
2537       case aCheckKeys:
2538         opt.check_sigs = 1;
2539       case aListSigs:
2540         opt.list_sigs = 1;
2541       case aListKeys:
2542         sl = NULL;
2543         for( ; argc; argc--, argv++ )
2544             add_to_strlist2( &sl, *argv, utf8_strings );
2545         public_key_list( sl );
2546         free_strlist(sl);
2547         break;
2548       case aListSecretKeys:
2549         sl = NULL;
2550         for( ; argc; argc--, argv++ )
2551             add_to_strlist2( &sl, *argv, utf8_strings );
2552         secret_key_list( sl );
2553         free_strlist(sl);
2554         break;
2555
2556       case aKMode: /* list keyring -- NOTE: This will be removed soon */
2557         if( argc < 2 ) { /* -kv [userid] */
2558             sl = NULL;
2559             if (argc && **argv)
2560                 add_to_strlist2( &sl, *argv, utf8_strings );
2561             public_key_list( sl );
2562             free_strlist(sl);
2563         }
2564         else if( argc == 2 ) { /* -kv userid keyring */
2565             if( access( argv[1], R_OK ) ) {
2566                 log_error(_("can't open %s: %s\n"),
2567                                print_fname_stdin(argv[1]), strerror(errno));
2568             }
2569             else {
2570                 /* add keyring (default keyrings are not registered in this
2571                  * special case */
2572                 keydb_add_resource( argv[1], 0, 0 );
2573                 sl = NULL;
2574                 if (**argv)
2575                     add_to_strlist2( &sl, *argv, utf8_strings );
2576                 public_key_list( sl );
2577                 free_strlist(sl);
2578             }
2579         }
2580         else
2581             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
2582         break;
2583
2584       case aKeygen: /* generate a key */
2585         if( opt.batch ) {
2586             if( argc > 1 )
2587                 wrong_args("--gen-key [parameterfile]");
2588             generate_keypair( argc? *argv : NULL );
2589         }
2590         else {
2591             if( argc )
2592                 wrong_args("--gen-key");
2593             generate_keypair(NULL);
2594         }
2595         break;
2596
2597       case aFastImport:
2598         opt.import_options |= IMPORT_FAST_IMPORT;
2599       case aImport:
2600         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
2601         break;
2602
2603       case aExport:
2604       case aExportAll:
2605       case aSendKeys:
2606       case aRecvKeys:
2607         sl = NULL;
2608         for( ; argc; argc--, argv++ )
2609             add_to_strlist2( &sl, *argv, utf8_strings );
2610         if( cmd == aSendKeys )
2611             rc=keyserver_export( sl );
2612         else if( cmd == aRecvKeys )
2613             rc=keyserver_import( sl );
2614         else
2615             rc=export_pubkeys( sl, opt.export_options );
2616         if(rc)
2617           {
2618             if(cmd==aSendKeys)
2619               log_error(_("keyserver send failed: %s\n"),gpg_strerror (rc));
2620             else if(cmd==aRecvKeys)
2621               log_error(_("keyserver receive failed: %s\n"),gpg_strerror (rc));
2622             else
2623               log_error(_("key export failed: %s\n"),gpg_strerror (rc));
2624           }
2625         free_strlist(sl);
2626         break;
2627
2628      case aSearchKeys:
2629         sl = NULL;
2630         for( ; argc; argc--, argv++ )
2631           {
2632             if (utf8_strings)
2633               sl = append_to_strlist ( &sl, *argv );
2634             else
2635               {
2636                 char *p = native_to_utf8 ( *argv );
2637                 sl = append_to_strlist( &sl, p );
2638                 xfree( p );
2639               }
2640           }
2641
2642         rc=keyserver_search( sl );
2643         if(rc)
2644           log_error(_("keyserver search failed: %s\n"),gpg_strerror (rc));
2645         free_strlist(sl);
2646         break;
2647
2648       case aRefreshKeys:
2649         sl = NULL;
2650         for( ; argc; argc--, argv++ )
2651             add_to_strlist2( &sl, *argv, utf8_strings );
2652         rc=keyserver_refresh(sl);
2653         if(rc)
2654           log_error(_("keyserver refresh failed: %s\n"),gpg_strerror (rc));
2655         free_strlist(sl);
2656         break;
2657
2658       case aExportSecret:
2659         sl = NULL;
2660         for( ; argc; argc--, argv++ )
2661             add_to_strlist2( &sl, *argv, utf8_strings );
2662         export_seckeys( sl );
2663         free_strlist(sl);
2664         break;
2665
2666       case aExportSecretSub:
2667         sl = NULL;
2668         for( ; argc; argc--, argv++ )
2669             add_to_strlist2( &sl, *argv, utf8_strings );
2670         export_secsubkeys( sl );
2671         free_strlist(sl);
2672         break;
2673
2674       case aGenRevoke:
2675         if( argc != 1 )
2676             wrong_args("--gen-revoke user-id");
2677         username =  make_username(*argv);
2678         gen_revoke( username );
2679         xfree ( username );
2680         break;
2681
2682       case aDesigRevoke:
2683         if( argc != 1 )
2684             wrong_args("--desig-revoke user-id");
2685         username =  make_username(*argv);
2686         gen_desig_revoke( username );
2687         xfree ( username );
2688         break;
2689
2690       case aDeArmor:
2691         if( argc > 1 )
2692             wrong_args("--dearmor [file]");
2693         rc = dearmor_file( argc? *argv: NULL );
2694         if( rc )
2695             log_error(_("dearmoring failed: %s\n"), gpg_strerror (rc));
2696         break;
2697
2698       case aEnArmor:
2699         if( argc > 1 )
2700             wrong_args("--enarmor [file]");
2701         rc = enarmor_file( argc? *argv: NULL );
2702         if( rc )
2703             log_error(_("enarmoring failed: %s\n"), gpg_strerror (rc));
2704         break;
2705
2706
2707       case aPrimegen:
2708 #if 0 /*FIXME-XXX*/
2709         {   int mode = argc < 2 ? 0 : atoi(*argv);
2710
2711             if( mode == 1 && argc == 2 ) {
2712                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
2713             }
2714             else if( mode == 2 && argc == 3 ) {
2715                 mpi_print( stdout, generate_elg_prime(
2716                                              0, atoi(argv[1]),
2717                                              atoi(argv[2]), NULL,NULL ), 1);
2718             }
2719             else if( mode == 3 && argc == 3 ) {
2720                 gcry_mpi_t *factors;
2721                 mpi_print( stdout, generate_elg_prime(
2722                                              1, atoi(argv[1]),
2723                                              atoi(argv[2]), NULL,&factors ), 1);
2724                 putchar('\n');
2725                 mpi_print( stdout, factors[0], 1 ); /* print q */
2726             }
2727             else if( mode == 4 && argc == 3 ) {
2728                 gcry_mpi_t g = mpi_alloc(1);
2729                 mpi_print( stdout, generate_elg_prime(
2730                                                  0, atoi(argv[1]),
2731                                                  atoi(argv[2]), g, NULL ), 1);
2732                 putchar('\n');
2733                 mpi_print( stdout, g, 1 );
2734                 mpi_free(g);
2735             }
2736             else
2737                 wrong_args("--gen-prime mode bits [qbits] ");
2738             putchar('\n');
2739         }
2740 #endif
2741         break;
2742
2743       case aGenRandom:
2744         {
2745             int level = argc ? atoi(*argv):0;
2746             int count = argc > 1 ? atoi(argv[1]): 0;
2747             int endless = !count;
2748
2749             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
2750                 wrong_args("--gen-random 0|1|2 [count]");
2751
2752             while( endless || count ) {
2753                 byte *p;
2754                 /* Wee need a multiple of 3, so that in case of
2755                    armored output we get a correct string.  No
2756                    linefolding is done, as it is best to levae this to
2757                    other tools */
2758                 size_t n = !endless && count < 99? count : 99;
2759
2760                 p = gcry_random_bytes (n, level);
2761 #ifdef HAVE_DOSISH_SYSTEM
2762                 setmode ( fileno(stdout), O_BINARY );
2763 #endif
2764                 if (opt.armor) {
2765                     char *tmp = make_radix64_string (p, n);
2766                     fputs (tmp, stdout);
2767                     xfree (tmp);
2768                     if (n%3 == 1)
2769                       putchar ('=');
2770                     if (n%3)
2771                       putchar ('=');
2772                 } else {
2773                     fwrite( p, n, 1, stdout );
2774                 }
2775                 xfree (p);
2776                 if( !endless )
2777                     count -= n;
2778             }
2779             if (opt.armor)
2780                 putchar ('\n');
2781         }
2782         break;
2783
2784       case aPrintMD:
2785         if( argc < 1)
2786             wrong_args("--print-md algo [files]");
2787         {
2788             int all_algos = (**argv=='*' && !(*argv)[1]);
2789             int algo = all_algos? 0 : gcry_md_map_name (*argv);
2790
2791             if( !algo && !all_algos )
2792                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
2793             else {
2794                 argc--; argv++;
2795                 if( !argc )
2796                     print_mds(NULL, algo);
2797                 else {
2798                     for(; argc; argc--, argv++ )
2799                         print_mds(*argv, algo);
2800                 }
2801             }
2802         }
2803         break;
2804
2805       case aPrintMDs: /* old option */
2806         if( !argc )
2807             print_mds(NULL,0);
2808         else {
2809             for(; argc; argc--, argv++ )
2810                 print_mds(*argv,0);
2811         }
2812         break;
2813
2814       case aListTrustDB:
2815         if( !argc )
2816             list_trustdb(NULL);
2817         else {
2818             for( ; argc; argc--, argv++ )
2819                 list_trustdb( *argv );
2820         }
2821         break;
2822
2823       case aUpdateTrustDB:
2824         if( argc )
2825             wrong_args("--update-trustdb");
2826         update_trustdb();
2827         break;
2828
2829       case aCheckTrustDB:
2830         /* Old versions allowed for arguments - ignore them */
2831         check_trustdb();
2832         break;
2833
2834       case aFixTrustDB:
2835         log_error("this command is not yet implemented.\n");
2836         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
2837         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
2838         break;
2839
2840       case aListTrustPath:
2841         if( !argc )
2842             wrong_args("--list-trust-path <user-ids>");
2843         for( ; argc; argc--, argv++ ) {
2844             username = make_username( *argv );
2845             list_trust_path( username );
2846             xfree (username);
2847         }
2848         break;
2849
2850       case aExportOwnerTrust:
2851         if( argc )
2852             wrong_args("--export-ownertrust");
2853         export_ownertrust();
2854         break;
2855
2856       case aImportOwnerTrust:
2857         if( argc > 1 )
2858             wrong_args("--import-ownertrust [file]");
2859         import_ownertrust( argc? *argv:NULL );
2860         break;
2861       
2862       case aPipeMode:
2863         if ( argc )
2864             wrong_args ("--pipemode");
2865         run_in_pipemode ();
2866         break;
2867
2868       case aRebuildKeydbCaches:
2869         if (argc)
2870             wrong_args ("--rebuild-keydb-caches");
2871         keydb_rebuild_caches ();
2872         break;
2873
2874     case aCardStatus:
2875       if (argc)
2876         wrong_args ("--card-status");
2877       card_status (stdout);
2878       break;
2879
2880     case aChangePIN:
2881       if (!argc)
2882         change_pin (0);
2883       else if (argc == 1)
2884         change_pin ( atoi (*argv));
2885       else
2886         wrong_args ("--change-pin [no]");
2887       break;
2888
2889       case aListPackets:
2890         opt.list_packets=2;
2891       default:
2892         if( argc > 1 )
2893             wrong_args(_("[filename]"));
2894         /* Issue some output for the unix newbie */
2895         if( !fname && !opt.outfile && isatty( fileno(stdin) )
2896                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
2897             log_info(_("Go ahead and type your message ...\n"));
2898
2899         if( !(a = iobuf_open(fname)) )
2900             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
2901         else {
2902
2903             if( !opt.no_armor ) {
2904                 if( use_armor_filter( a ) ) {
2905                     memset( &afx, 0, sizeof afx);
2906                     iobuf_push_filter( a, armor_filter, &afx );
2907                 }
2908             }
2909             if( cmd == aListPackets ) {
2910                 set_packet_list_mode(1);
2911                 opt.list_packets=1;
2912             }
2913             rc = proc_packets(NULL, a );
2914             if( rc )
2915                 log_error("processing message failed: %s\n", gpg_strerror (rc) );
2916             iobuf_close(a);
2917         }
2918         break;
2919     }
2920
2921     /* cleanup */
2922     FREE_STRLIST(remusr);
2923     FREE_STRLIST(locusr);
2924     g10_exit(0);
2925     return 8; /*NEVER REACHED*/
2926 }
2927
2928 /* Note: This function is used by signal handlers!. */
2929 static void
2930 emergency_cleanup (void)
2931 {
2932   gcry_control (GCRYCTL_TERM_SECMEM );
2933 }
2934
2935
2936 void
2937 g10_exit( int rc )
2938 {
2939   /* FIXME-XX update_random_seed_file(); */
2940 /*      if( opt.debug & DBG_MEMSTAT_VALUE ) { */
2941 /*          m_print_stats("on exit"); */
2942 /*      random_dump_stats(); */
2943 /*      } */
2944 /*      if( opt.debug ) */
2945 /*      secmem_dump_stats(); */
2946     gcry_control (GCRYCTL_TERM_SECMEM );
2947     rc = rc? rc : log_get_errorcount(0)? 2 :
2948                         g10_errors_seen? 1 : 0;
2949     exit(rc );
2950 }
2951
2952
2953 /* Pretty-print hex hashes.  This assumes at least an 80-character
2954    display, but there are a few other similar assumptions in the
2955    display code. */
2956 static void
2957 print_hex( MD_HANDLE md, int algo, const char *fname )
2958 {
2959   int i,n,count,indent=0;
2960   const byte *p;
2961
2962   if(fname)
2963     indent=printf("%s: ",fname);
2964
2965   if(indent>40)
2966     {
2967       printf("\n");
2968       indent=0;
2969     }
2970
2971   if(algo==DIGEST_ALGO_RMD160)
2972     indent+=printf("RMD160 = ");
2973   else if(algo==DIGEST_ALGO_TIGER)
2974     indent+=printf(" TIGER = ");
2975   else if(algo>0)
2976     indent+=printf("%6s = ", gcry_md_algo_name (algo));
2977   else
2978     algo=abs(algo);
2979
2980   count=indent;
2981
2982   p = gcry_md_read (md, algo);
2983   n = gcry_md_get_algo_dlen (algo);
2984
2985   count+=printf("%02X",*p++);
2986
2987   for(i=1;i<n;i++,p++)
2988     {
2989       if(n==16)
2990         {
2991           if(count+2>79)
2992             {
2993               printf("\n%*s",indent," ");
2994               count=indent;
2995             }
2996           else
2997             count+=printf(" ");
2998
2999           if(!(i%8))
3000             count+=printf(" ");
3001         }
3002       else if (n==20)
3003         {
3004           if(!(i%2))
3005             {
3006               if(count+4>79)
3007                 {
3008                   printf("\n%*s",indent," ");
3009                   count=indent;
3010                 }
3011               else
3012                 count+=printf(" ");
3013             }
3014
3015           if(!(i%10))
3016             count+=printf(" ");
3017         }
3018       else
3019         {
3020           if(!(i%4))
3021             {
3022               if(count+8>79)
3023                 {
3024                   printf("\n%*s",indent," ");
3025                   count=indent;
3026                 }
3027               else
3028                 count+=printf(" ");
3029             }
3030         }
3031
3032       count+=printf("%02X",*p);
3033     }
3034
3035   printf("\n");
3036 }
3037
3038 static void
3039 print_hashline( MD_HANDLE md, int algo, const char *fname )
3040 {
3041     int i, n;
3042     const byte *p;
3043     
3044     if ( fname ) {
3045         for (p = fname; *p; p++ ) {
3046             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3047                 printf("%%%02X", *p );
3048             else 
3049                 putchar( *p );
3050         }
3051     }
3052     putchar(':');
3053     printf("%d:", algo );
3054     p = gcry_md_read (md, algo );
3055     n = gcry_md_get_algo_dlen (algo);
3056     for(i=0; i < n ; i++, p++ ) 
3057         printf("%02X", *p );
3058     putchar(':');
3059     putchar('\n');
3060 }
3061
3062 static void
3063 print_mds( const char *fname, int algo )
3064 {
3065     FILE *fp;
3066     char buf[1024];
3067     size_t n;
3068     MD_HANDLE md;
3069
3070     if( !fname ) {
3071         fp = stdin;
3072 #ifdef HAVE_DOSISH_SYSTEM
3073         setmode ( fileno(fp) , O_BINARY );
3074 #endif
3075     }
3076     else {
3077         fp = fopen( fname, "rb" );
3078     }
3079     if( !fp ) {
3080         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3081         return;
3082     }
3083
3084     gcry_md_open (&md, 0, 0 );
3085     if( algo )
3086         gcry_md_enable ( md, algo );
3087     else {
3088         gcry_md_enable (md, GCRY_MD_MD5 );
3089         gcry_md_enable (md, GCRY_MD_SHA1 );
3090         gcry_md_enable (md, GCRY_MD_RMD160 );
3091 #ifdef USE_TIGER192
3092         gcry_md_enable (md, GCRY_MD_TIGER );
3093 #endif
3094 #ifdef USE_SHA256
3095         gcry_md_enable (md, GCRY_MD_SHA256 );
3096 #endif
3097 #ifdef USE_SHA512
3098         gcry_md_enable (md, GCRY_MD_SHA384 );
3099         gcry_md_enable (md, GCRY_MD_SHA512 );
3100 #endif
3101     }
3102
3103     while( (n=fread( buf, 1, DIM(buf), fp )) )
3104         gcry_md_write (md, buf, n);
3105     if( ferror(fp) )
3106         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3107     else {
3108         gcry_md_final (md);
3109         if ( opt.with_colons ) {
3110             if ( algo ) 
3111                 print_hashline( md, algo, fname );
3112             else {
3113                 print_hashline( md, GCRY_MD_MD5, fname );
3114                 print_hashline( md, GCRY_MD_SHA1, fname );
3115                 print_hashline( md, GCRY_MD_RMD160, fname );
3116 #ifdef USE_TIGER192
3117                 print_hashline( md, GCRY_MD_TIGER, fname );
3118 #endif
3119 #ifdef USE_SHA256
3120                 print_hashline( md, GCRY_MD_SHA256, fname );
3121 #endif
3122 #ifdef USE_SHA512
3123                 print_hashline( md, GCRY_MD_SHA384, fname );
3124                 print_hashline( md, GCRY_MD_SHA512, fname );
3125 #endif
3126             }
3127         }
3128         else {
3129             if( algo )
3130                print_hex(md,-algo,fname);
3131             else {
3132                 print_hex( md, GCRY_MD_MD5, fname );
3133                 print_hex( md, GCRY_MD_SHA1, fname );
3134                 print_hex( md, GCRY_MD_RMD160, fname );
3135 #ifdef USE_TIGER192
3136                 print_hex( md, GCRY_MD_TIGER, fname );
3137 #endif
3138 #ifdef USE_SHA256
3139                 print_hex( md, GCRY_MD_SHA256, fname );
3140 #endif
3141 #ifdef USE_SHA512
3142                 print_hex( md, GCRY_MD_SHA384, fname );
3143                 print_hex( md, GCRY_MD_SHA512, fname );
3144 #endif
3145             }
3146         }
3147     }
3148     gcry_md_close (md);
3149
3150     if( fp != stdin )
3151         fclose(fp);
3152 }
3153
3154
3155 /****************
3156  * Check the supplied name,value string and add it to the notation
3157  * data to be used for signatures.  which==0 for sig notations, and 1
3158  * for cert notations.
3159 */
3160 static void
3161 add_notation_data( const char *string, int which )
3162 {
3163     const char *s;
3164     STRLIST sl,*notation_data;
3165     int critical=0;
3166     int highbit=0;
3167     int saw_at=0;
3168
3169     if(which)
3170       notation_data=&opt.cert_notation_data;
3171     else
3172       notation_data=&opt.sig_notation_data;
3173
3174     if( *string == '!' ) {
3175         critical = 1;
3176         string++;
3177     }
3178
3179     /* If and when the IETF assigns some official name tags, we'll
3180        have to add them here. */
3181
3182     for( s=string ; *s != '='; s++ )
3183       {
3184         if( *s=='@')
3185           saw_at=1;
3186
3187         if( !*s || (*s & 0x80) || (!isgraph(*s) && !isspace(*s)) )
3188           {
3189             log_error(_("a notation name must have only printable characters "
3190                         "or spaces, and end with an '='\n") );
3191             return;
3192           }
3193       }
3194
3195     if(!saw_at && !opt.expert)
3196       {
3197         log_error(
3198                 _("a user notation name must contain the '@' character\n"));
3199         return;
3200       }
3201
3202     /* we only support printable text - therefore we enforce the use
3203      * of only printable characters (an empty value is valid) */
3204     for( s++; *s ; s++ ) {
3205         if( iscntrl(*s) ) {
3206             log_error(_("a notation value must not use "
3207                         "any control characters\n") );
3208             return;
3209         }
3210         else if( *s & 0x80 )
3211             highbit = 1;
3212     }
3213
3214     if( highbit )   /* must use UTF8 encoding */
3215         sl = add_to_strlist2( notation_data, string, utf8_strings );
3216     else
3217         sl = add_to_strlist( notation_data, string );
3218
3219     if( critical )
3220         sl->flags |= 1;
3221 }
3222
3223
3224 static void
3225 add_policy_url( const char *string, int which )
3226 {
3227   int i,critical=0;
3228   STRLIST sl;
3229
3230   if(*string=='!')
3231     {
3232       string++;
3233       critical=1;
3234     }
3235
3236   for(i=0;i<strlen(string);i++)
3237     if(string[i]&0x80 || iscntrl(string[i]))
3238       break;
3239
3240   if(i==0 || i<strlen(string))
3241     {
3242       if(which)
3243         log_error(_("the given certification policy URL is invalid\n"));
3244       else
3245         log_error(_("the given signature policy URL is invalid\n"));
3246     }
3247
3248   if(which)
3249     sl=add_to_strlist( &opt.cert_policy_url, string );
3250   else
3251     sl=add_to_strlist( &opt.sig_policy_url, string );
3252
3253   if(critical)
3254     sl->flags |= 1;    
3255 }