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