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