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