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