Still making gpg2 work.
[gnupg.git] / g10 / gpg.c
1 /* gpg.c - The GnuPG utility (main for gpg)
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3  *               2006 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <errno.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <ctype.h>
29 #include <unistd.h>
30 #include <assert.h>
31 #ifdef HAVE_DOSISH_SYSTEM
32 #include <fcntl.h> /* for setmode() */
33 #endif
34 #ifdef HAVE_STAT
35 #include <sys/stat.h> /* for stat() */
36 #endif
37 #include <fcntl.h>
38 #include <assuan.h>
39 #ifdef HAVE_W32_SYSTEM
40 #include <windows.h>
41 #endif
42
43 #define INCLUDED_BY_MAIN_MODULE 1
44 #include "gpg.h"
45 #include "packet.h"
46 #include "../common/iobuf.h"
47 #include "util.h"
48 #include "main.h"
49 #include "options.h"
50 #include "keydb.h"
51 #include "trustdb.h"
52 #include "cipher.h"
53 #include "filter.h"
54 #include "ttyio.h"
55 #include "i18n.h"
56 #include "status.h"
57 #include "keyserver-internal.h"
58 #include "exec.h"
59
60
61 #if defined(HAVE_DOSISH_SYSTEM) || defined(__CYGWIN__)
62 #define MY_O_BINARY  O_BINARY
63 #ifndef S_IRGRP
64 # define S_IRGRP 0
65 # define S_IWGRP 0
66 #endif
67 #else
68 #define MY_O_BINARY  0
69 #endif
70
71
72 enum cmd_and_opt_values
73   {
74     aNull = 0,
75     oArmor        = 'a',
76     aDetachedSign = 'b',
77     aSym          = 'c',
78     aDecrypt      = 'd',
79     aEncr         = 'e',
80     oInteractive  = 'i',
81     oKOption      = 'k',
82     oDryRun       = 'n',
83     oOutput       = 'o',
84     oQuiet        = 'q',
85     oRecipient    = 'r',
86     oHiddenRecipient = 'R',
87     aSign         = 's',
88     oTextmodeShort= 't',
89     oLocalUser    = 'u',
90     oVerbose      = 'v',
91     oCompress     = 'z',
92     oSetNotation  = 'N',
93     aListSecretKeys = 'K',
94     oBatch        = 500,
95     oMaxOutput,
96     oSigNotation,
97     oCertNotation,
98     oShowNotation,
99     oNoShowNotation,
100     aEncrFiles,
101     aEncrSym,
102     aDecryptFiles,
103     aClearsign,
104     aStore,
105     aKeygen,
106     aSignEncr,
107     aSignEncrSym,
108     aSignSym,
109     aSignKey,
110     aLSignKey,
111     aListConfig,
112     aGPGConfList,
113     aListPackets,
114     aEditKey,
115     aDeleteKeys,
116     aDeleteSecretKeys,
117     aDeleteSecretAndPublicKeys,
118     aKMode,
119     aKModeC,
120     aImport,
121     aFastImport,
122     aVerify,
123     aVerifyFiles,
124     aListKeys,
125     aListSigs,
126     aSendKeys,
127     aRecvKeys,
128     aSearchKeys,
129     aRefreshKeys,
130     aFetchKeys,
131     aExport,
132     aExportSecret,
133     aExportSecretSub,
134     aCheckKeys,
135     aGenRevoke,
136     aDesigRevoke,
137     aPrimegen,
138     aPrintMD,
139     aPrintMDs,
140     aCheckTrustDB,
141     aUpdateTrustDB,
142     aFixTrustDB,
143     aListTrustDB,
144     aListTrustPath,
145     aExportOwnerTrust,
146     aListOwnerTrust,
147     aImportOwnerTrust,
148     aDeArmor,
149     aEnArmor,
150     aGenRandom,
151     aRebuildKeydbCaches,
152     aCardStatus,
153     aCardEdit,
154     aChangePIN,
155
156     oTextmode,
157     oNoTextmode,
158     oExpert,
159     oNoExpert,
160     oDefSigExpire,
161     oAskSigExpire,
162     oNoAskSigExpire,
163     oDefCertExpire,
164     oAskCertExpire,
165     oNoAskCertExpire,
166     oDefCertLevel,
167     oMinCertLevel,
168     oAskCertLevel,
169     oNoAskCertLevel,
170     oFingerprint,
171     oWithFingerprint,
172     oAnswerYes,
173     oAnswerNo,
174     oKeyring,
175     oPrimaryKeyring,
176     oSecretKeyring,
177     oShowKeyring,
178     oDefaultKey,
179     oDefRecipient,
180     oDefRecipientSelf,
181     oNoDefRecipient,
182     oOptions,
183     oDebug,
184     oDebugLevel,
185     oDebugAll,
186     oDebugCCIDDriver,
187     oStatusFD,
188     oStatusFile,
189     oAttributeFD,
190     oAttributeFile,
191     oEmitVersion,
192     oNoEmitVersion,
193     oCompletesNeeded,
194     oMarginalsNeeded,
195     oMaxCertDepth,
196     oLoadExtension,
197     oGnuPG,
198     oRFC1991,
199     oRFC2440,
200     oOpenPGP,
201     oPGP2,
202     oPGP6,
203     oPGP7,
204     oPGP8,
205     oRFC2440Text,
206     oNoRFC2440Text,
207     oCipherAlgo,
208     oDigestAlgo,
209     oCertDigestAlgo,
210     oCompressAlgo,
211     oCompressLevel,
212     oBZ2CompressLevel,
213     oBZ2DecompressLowmem,
214     oPasswd,
215     oPasswdFD,
216     oPasswdFile,
217     oCommandFD,
218     oCommandFile,
219     oQuickRandom,
220     oNoVerbose,
221     oTrustDBName,
222     oNoSecmemWarn,
223     oRequireSecmem,
224     oNoRequireSecmem,
225     oNoPermissionWarn,
226     oNoMDCWarn,
227     oNoArmor,
228     oNoDefKeyring,
229     oNoGreeting,
230     oNoTTY,
231     oNoOptions,
232     oNoBatch,
233     oHomedir,
234     oWithColons,
235     oWithKeyData,
236     oSkipVerify,
237     oCompressKeys,
238     oCompressSigs,
239     oAlwaysTrust,
240     oTrustModel,
241     oForceOwnertrust,
242     oSetFilename,
243     oForYourEyesOnly,
244     oNoForYourEyesOnly,
245     oSetPolicyURL,
246     oSigPolicyURL,
247     oCertPolicyURL,
248     oShowPolicyURL,
249     oNoShowPolicyURL,
250     oSigKeyserverURL,
251     oUseEmbeddedFilename,
252     oNoUseEmbeddedFilename,
253     oComment,
254     oDefaultComment,
255     oNoComments,
256     oThrowKeyids,
257     oNoThrowKeyids,
258     oShowPhotos,
259     oNoShowPhotos,
260     oPhotoViewer,
261     oForceV3Sigs,
262     oNoForceV3Sigs,
263     oForceV4Certs,
264     oNoForceV4Certs,
265     oForceMDC,
266     oNoForceMDC,
267     oDisableMDC,
268     oNoDisableMDC,
269     oS2KMode,
270     oS2KDigest,
271     oS2KCipher,
272     oSimpleSKChecksum,                          
273     oDisplayCharset,
274     oNotDashEscaped,
275     oEscapeFrom,
276     oNoEscapeFrom,
277     oLockOnce,
278     oLockMultiple,
279     oLockNever,
280     oKeyServer,
281     oKeyServerOptions,
282     oImportOptions,
283     oExportOptions,
284     oListOptions,
285     oVerifyOptions,
286     oTempDir,
287     oExecPath,
288     oEncryptTo,
289     oHiddenEncryptTo,
290     oNoEncryptTo,
291     oLoggerFD,
292     oLoggerFile,
293     oUtf8Strings,
294     oNoUtf8Strings,
295     oDisableCipherAlgo,
296     oDisablePubkeyAlgo,
297     oAllowNonSelfsignedUID,
298     oNoAllowNonSelfsignedUID,
299     oAllowFreeformUID,
300     oNoAllowFreeformUID,
301     oAllowSecretKeyImport,                      
302     oEnableSpecialFilenames,
303     oNoLiteral,
304     oSetFilesize,
305     oHonorHttpProxy,
306     oFastListMode,
307     oListOnly,
308     oIgnoreTimeConflict,
309     oIgnoreValidFrom,
310     oIgnoreCrcError,
311     oIgnoreMDCError,
312     oShowSessionKey,
313     oOverrideSessionKey,
314     oNoRandomSeedFile,
315     oAutoKeyRetrieve,
316     oNoAutoKeyRetrieve,
317     oUseAgent,
318     oNoUseAgent,
319     oGpgAgentInfo,
320     oMergeOnly,
321     oTryAllSecrets,
322     oTrustedKey,
323     oNoExpensiveTrustChecks,
324     oFixedListMode,
325     oNoSigCache,
326     oNoSigCreateCheck,
327     oAutoCheckTrustDB,
328     oNoAutoCheckTrustDB,
329     oPreservePermissions,
330     oDefaultPreferenceList,
331     oPersonalCipherPreferences,
332     oPersonalDigestPreferences,
333     oPersonalCompressPreferences,
334     oAgentProgram,
335     oDisplay,
336     oTTYname,
337     oTTYtype,
338     oLCctype,
339     oLCmessages,
340     oGroup,
341     oUnGroup,
342     oNoGroups,
343     oStrict,
344     oNoStrict,
345     oMangleDosFilenames,
346     oNoMangleDosFilenames,
347     oEnableProgressFilter,
348     oMultifile,
349     oKeyidFormat,
350     oExitOnStatusWriteError,
351     oLimitCardInsertTries,
352     oRequireCrossCert,
353     oNoRequireCrossCert,
354     oAutoKeyLocate,
355     oNoAutoKeyLocate,
356     oAllowMultisigVerification,
357     oEnableDSA2,
358     oDisableDSA2,
359
360     oNoop
361   };
362
363
364 static ARGPARSE_OPTS opts[] = {
365
366     { 300, NULL, 0, N_("@Commands:\n ") },
367
368     { aSign, "sign",      256, N_("|[file]|make a signature")},
369     { aClearsign, "clearsign", 256, N_("|[file]|make a clear text signature")},
370     { aDetachedSign, "detach-sign", 256, N_("make a detached signature")},
371     { aEncr, "encrypt",   256, N_("encrypt data")},
372     { aEncrFiles, "encrypt-files", 256, "@"},
373     { aSym, "symmetric", 256, N_("encryption only with symmetric cipher")},
374     { aStore, "store",     256, "@"},
375     { aDecrypt, "decrypt",   256, N_("decrypt data (default)")},
376     { aDecryptFiles, "decrypt-files", 256, "@"},
377     { aVerify, "verify"   , 256, N_("verify a signature")},
378     { aVerifyFiles, "verify-files" , 256, "@" },
379     { aListKeys, "list-keys", 256, N_("list keys")},
380     { aListKeys, "list-public-keys", 256, "@" },
381     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
382     { aCheckKeys, "check-sigs",256, N_("list and check key signatures")},
383     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
384     { aListSecretKeys, "list-secret-keys", 256, N_("list secret keys")},
385     { aKeygen,     "gen-key",  256, N_("generate a new key pair")},
386     { aDeleteKeys,"delete-keys",256,N_("remove keys from the public keyring")},
387     { aDeleteSecretKeys, "delete-secret-keys",256,
388                                     N_("remove keys from the secret keyring")},
389     { aSignKey,  "sign-key"   ,256, N_("sign a key")},
390     { aLSignKey, "lsign-key"  ,256, N_("sign a key locally")},
391     { aEditKey,  "edit-key"   ,256, N_("sign or edit a key")},
392     { aGenRevoke, "gen-revoke",256, N_("generate a revocation certificate")},
393     { aDesigRevoke, "desig-revoke",256, "@" },
394     { aExport, "export"           , 256, N_("export keys") },
395     { aSendKeys, "send-keys"     , 256, N_("export keys to a key server") },
396     { aRecvKeys, "recv-keys"     , 256, N_("import keys from a key server") },
397     { aSearchKeys, "search-keys" , 256,
398                                     N_("search for keys on a key server") },
399     { aRefreshKeys, "refresh-keys", 256,
400                                     N_("update all keys from a keyserver")},
401     { aFetchKeys, "fetch-keys" , 256, "@" },
402     { aExportSecret, "export-secret-keys" , 256, "@" },
403     { aExportSecretSub, "export-secret-subkeys" , 256, "@" },
404     { aImport, "import",      256     , N_("import/merge keys")},
405     { aFastImport, "fast-import",  256 , "@"},
406 #ifdef ENABLE_CARD_SUPPORT
407     { aCardStatus,  "card-status", 256, N_("print the card status")},
408     { aCardEdit,   "card-edit",  256, N_("change data on a card")},
409     { aChangePIN,  "change-pin", 256, N_("change a card's PIN")},
410 #endif
411     { aListConfig, "list-config", 256, "@"},
412     { aGPGConfList, "gpgconf-list", 256, "@" },
413     { aListPackets, "list-packets",256, "@"},
414     { aExportOwnerTrust, "export-ownertrust", 256, "@"},
415     { aImportOwnerTrust, "import-ownertrust", 256, "@"},
416     { aUpdateTrustDB,
417               "update-trustdb",0 , N_("update the trust database")},
418     { aCheckTrustDB, "check-trustdb", 0, "@"},
419     { aFixTrustDB, "fix-trustdb", 0, "@"},
420     { aDeArmor, "dearmor", 256, "@"},
421     { aDeArmor, "dearmour", 256, "@"},
422     { aEnArmor, "enarmor", 256, "@"},
423     { aEnArmor, "enarmour", 256, "@"},
424     { aPrintMD,  "print-md" , 256, N_("|algo [files]|print message digests")},
425     { aPrimegen, "gen-prime" , 256, "@" },
426     { aGenRandom, "gen-random" , 256, "@" },
427
428     { 301, NULL, 0, N_("@\nOptions:\n ") },
429
430     { oArmor, "armor",     0, N_("create ascii armored output")},
431     { oArmor, "armour",     0, "@" },
432     { oRecipient, "recipient", 2, N_("|NAME|encrypt for NAME")},
433     { oHiddenRecipient, "hidden-recipient", 2, "@" },
434     { oRecipient, "remote-user", 2, "@"},  /* old option name */
435     { oDefRecipient, "default-recipient", 2, "@"},
436     { oDefRecipientSelf, "default-recipient-self", 0, "@"},
437     { oNoDefRecipient, "no-default-recipient", 0, "@" },
438     { oTempDir, "temp-directory", 2, "@" },
439     { oExecPath, "exec-path", 2, "@" },
440     { oEncryptTo, "encrypt-to", 2, "@" },
441     { oHiddenEncryptTo, "hidden-encrypt-to", 2, "@" },
442     { oNoEncryptTo, "no-encrypt-to", 0, "@" },
443     { oLocalUser, "local-user",2, N_("use this user-id to sign or decrypt")},
444     { oCompress, NULL, 1, N_("|N|set compress level N (0 disables)") },
445     { oCompressLevel, "compress-level", 1, "@" },
446     { oBZ2CompressLevel, "bzip2-compress-level", 1, "@" },
447     { oBZ2DecompressLowmem, "bzip2-decompress-lowmem", 0, "@" },
448     { oTextmodeShort, NULL,   0, "@"},
449     { oTextmode, "textmode",  0, N_("use canonical text mode")},
450     { oNoTextmode, "no-textmode",  0, "@"},
451     { oExpert, "expert",   0, "@"},
452     { oNoExpert, "no-expert",   0, "@"},
453     { oDefSigExpire, "default-sig-expire", 2, "@"},
454     { oAskSigExpire, "ask-sig-expire",   0, "@"},
455     { oNoAskSigExpire, "no-ask-sig-expire",   0, "@"},
456     { oDefCertExpire, "default-cert-expire", 2, "@"},
457     { oAskCertExpire, "ask-cert-expire",   0, "@"},
458     { oNoAskCertExpire, "no-ask-cert-expire",   0, "@"},
459     { oDefCertLevel, "default-cert-level", 1, "@"},
460     { oMinCertLevel, "min-cert-level", 1, "@"},
461     { oAskCertLevel, "ask-cert-level",   0, "@"},
462     { oNoAskCertLevel, "no-ask-cert-level",   0, "@"},
463     { oOutput, "output",    2, N_("use as output file")},
464     { oMaxOutput, "max-output", 16|4, "@" },
465     { oVerbose, "verbose",   0, N_("verbose") },
466     { oQuiet,   "quiet",   0, "@"},
467     { oNoTTY, "no-tty", 0, "@"},
468     { oForceV3Sigs, "force-v3-sigs", 0, "@"},
469     { oNoForceV3Sigs, "no-force-v3-sigs", 0, "@"},
470     { oForceV4Certs, "force-v4-certs", 0, "@"},
471     { oNoForceV4Certs, "no-force-v4-certs", 0, "@"},
472     { oForceMDC, "force-mdc", 0, "@"},
473     { oNoForceMDC, "no-force-mdc", 0, "@" },
474     { oDisableMDC, "disable-mdc", 0, "@"},
475     { oNoDisableMDC, "no-disable-mdc", 0, "@" },
476     { oDryRun, "dry-run",   0, N_("do not make any changes") },
477     { oInteractive, "interactive", 0, N_("prompt before overwriting") },
478     { oUseAgent, "use-agent",0, "@"},
479     { oNoUseAgent, "no-use-agent",0, "@"},
480     { oGpgAgentInfo, "gpg-agent-info",2, "@"},
481     { oBatch, "batch", 0, "@"},
482     { oAnswerYes, "yes", 0, "@"},
483     { oAnswerNo, "no", 0, "@"},
484     { oKeyring, "keyring", 2, "@"},
485     { oPrimaryKeyring, "primary-keyring",2, "@" },
486     { oSecretKeyring, "secret-keyring", 2, "@"},
487     { oShowKeyring, "show-keyring", 0, "@"},
488     { oDefaultKey, "default-key", 2, "@"},
489     { oKeyServer, "keyserver", 2, "@"},
490     { oKeyServerOptions, "keyserver-options",2,"@"},
491     { oImportOptions, "import-options",2,"@"},
492     { oExportOptions, "export-options",2,"@"},
493     { oListOptions, "list-options",2,"@"},
494     { oVerifyOptions, "verify-options",2,"@"},
495     { oDisplayCharset, "display-charset", 2, "@"},
496     { oDisplayCharset, "charset", 2, "@"},
497     { oOptions, "options", 2, "@"},
498     { oDebug, "debug"     ,4|16, "@"},
499     { oDebugLevel, "debug-level" ,2, "@"},
500     { oDebugAll, "debug-all" ,0, "@"},
501     { oStatusFD, "status-fd" ,1, "@"},
502     { oStatusFile, "status-file" ,2, "@"},
503     { oAttributeFD, "attribute-fd" ,1, "@" },
504     { oAttributeFile, "attribute-file" ,2, "@" },
505     { oNoop, "sk-comments", 0,   "@"},
506     { oNoop, "no-sk-comments", 0,   "@"},
507     { oCompletesNeeded, "completes-needed", 1, "@"},
508     { oMarginalsNeeded, "marginals-needed", 1, "@"},
509     { oMaxCertDepth,    "max-cert-depth", 1, "@" },
510     { oTrustedKey, "trusted-key", 2, "@"},
511     { oLoadExtension, "load-extension", 2, "@"},
512     { oGnuPG, "gnupg",   0, "@"},
513     { oGnuPG, "no-pgp2", 0, "@"},
514     { oGnuPG, "no-pgp6", 0, "@"},
515     { oGnuPG, "no-pgp7", 0, "@"},
516     { oGnuPG, "no-pgp8", 0, "@"},
517     { oRFC1991, "rfc1991",   0, "@"},
518     { oRFC2440, "rfc2440", 0, "@" },
519     { oOpenPGP, "openpgp", 0, N_("use strict OpenPGP behavior")},
520     { oPGP2, "pgp2", 0, N_("generate PGP 2.x compatible messages")},
521     { oPGP6, "pgp6", 0, "@"},
522     { oPGP7, "pgp7", 0, "@"},
523     { oPGP8, "pgp8", 0, "@"},
524     { oRFC2440Text, "rfc2440-text", 0, "@"},
525     { oNoRFC2440Text, "no-rfc2440-text", 0, "@"},
526     { oS2KMode, "s2k-mode", 1, "@"},
527     { oS2KDigest, "s2k-digest-algo", 2, "@"},
528     { oS2KCipher, "s2k-cipher-algo", 2, "@"},
529     { oSimpleSKChecksum, "simple-sk-checksum", 0, "@"},
530     { oCipherAlgo, "cipher-algo", 2, "@"},
531     { oDigestAlgo, "digest-algo", 2, "@"},
532     { oCertDigestAlgo, "cert-digest-algo", 2 , "@" },
533     { oCompressAlgo,"compress-algo", 2, "@"},
534     { oCompressAlgo, "compression-algo", 2, "@"}, /* Alias */
535     { oThrowKeyids, "throw-keyid", 0, "@"},
536     { oThrowKeyids, "throw-keyids", 0, "@"},
537     { oNoThrowKeyids, "no-throw-keyid", 0, "@" },
538     { oNoThrowKeyids, "no-throw-keyids", 0, "@" },
539     { oShowPhotos,   "show-photos", 0, "@" },
540     { oNoShowPhotos, "no-show-photos", 0, "@" },
541     { oPhotoViewer,  "photo-viewer", 2, "@" },
542     { oSetNotation,  "set-notation", 2, "@" },
543     { oSetNotation,  "notation-data", 2, "@" }, /* Alias */
544     { oSigNotation,  "sig-notation", 2, "@" },
545     { oCertNotation, "cert-notation", 2, "@" },
546
547     { 302, NULL, 0, N_(
548   "@\n(See the man page for a complete listing of all commands and options)\n"
549                       )},
550
551     { 303, NULL, 0, N_("@\nExamples:\n\n"
552     " -se -r Bob [file]          sign and encrypt for user Bob\n"
553     " --clearsign [file]         make a clear text signature\n"
554     " --detach-sign [file]       make a detached signature\n"
555     " --list-keys [names]        show keys\n"
556     " --fingerprint [names]      show fingerprints\n"  ) },
557
558   /* hidden options */
559     { aListOwnerTrust, "list-ownertrust", 256, "@"}, /* deprecated */
560     { aPrintMDs, "print-mds" , 256, "@"}, /* old */
561     { aListTrustDB, "list-trustdb",0 , "@"},
562     /* Not yet used */
563     /* { aListTrustPath, "list-trust-path",0, "@"}, */
564     { oKOption, NULL,    0, "@"},
565     { oPasswd, "passphrase",2, "@" },
566     { oPasswdFD, "passphrase-fd",1, "@" },
567     { oPasswdFile, "passphrase-file",2, "@" },
568     { oCommandFD, "command-fd",1, "@" },
569     { oCommandFile, "command-file",2, "@" },
570     { oQuickRandom, "quick-random", 0, "@"},
571     { oNoVerbose, "no-verbose", 0, "@"},
572     { oTrustDBName, "trustdb-name", 2, "@" },
573     { oNoSecmemWarn, "no-secmem-warning", 0, "@" },
574     { oRequireSecmem,"require-secmem", 0, "@" },
575     { oNoRequireSecmem,"no-require-secmem", 0, "@" },
576     { oNoPermissionWarn, "no-permission-warning", 0, "@" },
577     { oNoMDCWarn, "no-mdc-warning", 0, "@" },
578     { oNoArmor, "no-armor",   0, "@"},
579     { oNoArmor, "no-armour",   0, "@"},
580     { oNoDefKeyring, "no-default-keyring", 0, "@" },
581     { oNoGreeting, "no-greeting", 0, "@" },
582     { oNoOptions, "no-options", 0, "@" }, /* shortcut for --options /dev/null */
583     { oHomedir, "homedir", 2, "@" },   /* defaults to "~/.gnupg" */
584     { oNoBatch, "no-batch", 0, "@" },
585     { oWithColons, "with-colons", 0, "@"},
586     { oWithKeyData,"with-key-data", 0, "@"},
587     { aListKeys, "list-key", 0, "@" }, /* alias */
588     { aListSigs, "list-sig", 0, "@" }, /* alias */
589     { aCheckKeys, "check-sig",0, "@" }, /* alias */
590     { oSkipVerify, "skip-verify",0, "@" },
591     { oCompressKeys, "compress-keys",0, "@"},
592     { oCompressSigs, "compress-sigs",0, "@"},
593     { oDefCertLevel, "default-cert-check-level", 1, "@"}, /* Old option */
594     { oAlwaysTrust, "always-trust", 0, "@"},
595     { oTrustModel, "trust-model", 2, "@"},
596     { oForceOwnertrust, "force-ownertrust", 2, "@"},
597     { oSetFilename, "set-filename", 2, "@" },
598     { oForYourEyesOnly, "for-your-eyes-only", 0, "@" },
599     { oNoForYourEyesOnly, "no-for-your-eyes-only", 0, "@" },
600     { oSetPolicyURL, "set-policy-url", 2, "@" },
601     { oSigPolicyURL, "sig-policy-url", 2, "@" },
602     { oCertPolicyURL, "cert-policy-url", 2, "@" },
603     { oShowPolicyURL, "show-policy-url", 0, "@" },
604     { oNoShowPolicyURL, "no-show-policy-url", 0, "@" },
605     { oSigKeyserverURL, "sig-keyserver-url", 2, "@" },
606     { oShowNotation, "show-notation", 0, "@" },
607     { oNoShowNotation, "no-show-notation", 0, "@" },
608     { oComment, "comment", 2, "@" },
609     { oDefaultComment, "default-comment", 0, "@" },
610     { oNoComments, "no-comments", 0, "@" },
611     { oEmitVersion, "emit-version", 0, "@"},
612     { oNoEmitVersion, "no-emit-version", 0, "@"},
613     { oNoEmitVersion, "no-version", 0, "@"}, /* alias */
614     { oNotDashEscaped, "not-dash-escaped", 0, "@" },
615     { oEscapeFrom, "escape-from-lines", 0, "@" },
616     { oNoEscapeFrom, "no-escape-from-lines", 0, "@" },
617     { oLockOnce, "lock-once", 0, "@" },
618     { oLockMultiple, "lock-multiple", 0, "@" },
619     { oLockNever, "lock-never", 0, "@" },
620     { oLoggerFD, "logger-fd",1, "@" },
621     { oLoggerFile, "log-file",2, "@" },
622     { oUseEmbeddedFilename, "use-embedded-filename", 0, "@" },
623     { oNoUseEmbeddedFilename, "no-use-embedded-filename", 0, "@" },
624     { oUtf8Strings, "utf8-strings", 0, "@" },
625     { oNoUtf8Strings, "no-utf8-strings", 0, "@" },
626     { oWithFingerprint, "with-fingerprint", 0, "@" },
627     { oDisableCipherAlgo,  "disable-cipher-algo", 2, "@" },
628     { oDisablePubkeyAlgo,  "disable-pubkey-algo", 2, "@" },
629     { oAllowNonSelfsignedUID, "allow-non-selfsigned-uid", 0, "@" },
630     { oNoAllowNonSelfsignedUID, "no-allow-non-selfsigned-uid", 0, "@" },
631     { oAllowFreeformUID, "allow-freeform-uid", 0, "@" },
632     { oNoAllowFreeformUID, "no-allow-freeform-uid", 0, "@" },
633     { oNoLiteral, "no-literal", 0, "@" },
634     { oSetFilesize, "set-filesize", 20, "@" },
635     { oHonorHttpProxy,"honor-http-proxy", 0, "@" },
636     { oFastListMode,"fast-list-mode", 0, "@" },
637     { oFixedListMode,"fixed-list-mode", 0, "@" },
638     { oListOnly, "list-only", 0, "@"},
639     { oIgnoreTimeConflict, "ignore-time-conflict", 0, "@" },
640     { oIgnoreValidFrom,    "ignore-valid-from",    0, "@" },
641     { oIgnoreCrcError, "ignore-crc-error", 0,"@" },
642     { oIgnoreMDCError, "ignore-mdc-error", 0,"@" },
643     { oShowSessionKey, "show-session-key", 0, "@" },
644     { oOverrideSessionKey, "override-session-key", 2, "@" },
645     { oNoRandomSeedFile,  "no-random-seed-file", 0, "@" },
646     { oAutoKeyRetrieve, "auto-key-retrieve", 0, "@" },
647     { oNoAutoKeyRetrieve, "no-auto-key-retrieve", 0, "@" },
648     { oNoSigCache,         "no-sig-cache", 0, "@" },
649     { oNoSigCreateCheck,   "no-sig-create-check", 0, "@" },
650     { oAutoCheckTrustDB, "auto-check-trustdb", 0, "@"},
651     { oNoAutoCheckTrustDB, "no-auto-check-trustdb", 0, "@"},
652     { oMergeOnly,         "merge-only", 0, "@" },
653     { oAllowSecretKeyImport, "allow-secret-key-import", 0, "@" },
654     { oTryAllSecrets,  "try-all-secrets", 0, "@" },
655     { oEnableSpecialFilenames, "enable-special-filenames", 0, "@" },
656     { oNoExpensiveTrustChecks, "no-expensive-trust-checks", 0, "@" },
657     { aDeleteSecretAndPublicKeys, "delete-secret-and-public-keys",256, "@" },
658     { aRebuildKeydbCaches, "rebuild-keydb-caches", 256, "@"},
659     { oPreservePermissions, "preserve-permissions", 0, "@"},
660     { oDefaultPreferenceList,  "default-preference-list", 2, "@"},
661     { oPersonalCipherPreferences,  "personal-cipher-preferences", 2, "@"},
662     { oPersonalDigestPreferences,  "personal-digest-preferences", 2, "@"},
663     { oPersonalCompressPreferences,  "personal-compress-preferences", 2, "@"},
664     /* Aliases.  I constantly mistype these, and assume other people
665        do as well. */
666     { oPersonalCipherPreferences, "personal-cipher-prefs", 2, "@"},
667     { oPersonalDigestPreferences, "personal-digest-prefs", 2, "@"},
668     { oPersonalCompressPreferences, "personal-compress-prefs", 2, "@"},
669     { oAgentProgram, "agent-program", 2 , "@" },
670     { oDisplay,    "display",     2, "@" },
671     { oTTYname,    "ttyname",     2, "@" },
672     { oTTYtype,    "ttytype",     2, "@" },
673     { oLCctype,    "lc-ctype",    2, "@" },
674     { oLCmessages, "lc-messages", 2, "@" },
675     { oGroup,      "group",       2, "@" },
676     { oUnGroup,    "ungroup",     2, "@" },
677     { oNoGroups,   "no-groups",    0, "@" },
678     { oStrict,     "strict",      0, "@" },
679     { oNoStrict,   "no-strict",   0, "@" },
680     { oMangleDosFilenames, "mangle-dos-filenames", 0, "@" },
681     { oNoMangleDosFilenames, "no-mangle-dos-filenames", 0, "@" },
682     { oEnableProgressFilter, "enable-progress-filter", 0, "@" },
683     { oMultifile, "multifile", 0, "@" },
684     { oKeyidFormat, "keyid-format", 2, "@" },
685     { oExitOnStatusWriteError, "exit-on-status-write-error", 0, "@" },
686     { oLimitCardInsertTries, "limit-card-insert-tries", 1, "@"},
687
688     { oAllowMultisigVerification, "allow-multisig-verification", 0, "@"},
689     { oEnableDSA2, "enable-dsa2", 0, "@"},
690     { oDisableDSA2, "disable-dsa2", 0, "@"},
691
692     /* These two are aliases to help users of the PGP command line
693        product use gpg with minimal pain.  Many commands are common
694        already as they seem to have borrowed commands from us.  Now
695        I'm returning the favor. */
696     { oLocalUser, "sign-with", 2, "@" },
697     { oRecipient, "user", 2, "@" },
698     { oRequireCrossCert, "require-backsigs", 0, "@"},
699     { oRequireCrossCert, "require-cross-certification", 0, "@"},
700     { oNoRequireCrossCert, "no-require-backsigs", 0, "@"},
701     { oNoRequireCrossCert, "no-require-cross-certification", 0, "@"},
702     { oAutoKeyLocate, "auto-key-locate", 2, "@"},
703     { oNoAutoKeyLocate, "no-auto-key-locate", 0, "@"},
704     {0,NULL,0,NULL}
705 };
706
707
708 #ifdef ENABLE_SELINUX_HACKS
709 #define ALWAYS_ADD_KEYRINGS 1
710 #else
711 #define ALWAYS_ADD_KEYRINGS 0
712 #endif
713
714
715 int g10_errors_seen = 0;
716
717 static int utf8_strings = 0;
718 static int maybe_setuid = 1;
719
720 static char *build_list( const char *text, char letter,
721                          const char *(*mapf)(int), int (*chkf)(int) );
722 static void set_cmd( enum cmd_and_opt_values *ret_cmd,
723                         enum cmd_and_opt_values new_cmd );
724 static void print_mds( const char *fname, int algo );
725 static void add_notation_data( const char *string, int which );
726 static void add_policy_url( const char *string, int which );
727 static void add_keyserver_url( const char *string, int which );
728 static void emergency_cleanup (void);
729
730
731 static const char *
732 my_strusage( int level )
733 {
734   static char *digests, *pubkeys, *ciphers, *zips;
735     const char *p;
736     switch( level ) {
737       case 11: p = "gpg (GnuPG)";
738         break;
739       case 13: p = VERSION; break;
740       case 17: p = PRINTABLE_OS_NAME; break;
741       case 19: p =
742             _("Please report bugs to <gnupg-bugs@gnu.org>.\n");
743         break;
744
745 #ifdef IS_DEVELOPMENT_VERSION
746       case 20:
747         p="NOTE: THIS IS A DEVELOPMENT VERSION!";
748         break;
749       case 21:
750         p="It is only intended for test purposes and should NOT be";
751         break;
752       case 22:
753         p="used in a production environment or with production keys!";
754         break;
755 #endif
756
757       case 1:
758       case 40:  p =
759             _("Usage: gpg [options] [files] (-h for help)");
760         break;
761       case 41:  p =
762             _("Syntax: gpg [options] [files]\n"
763               "sign, check, encrypt or decrypt\n"
764               "default operation depends on the input data\n");
765         break;
766
767       case 31: p = "\nHome: "; break;
768 #ifndef __riscos__
769       case 32: p = opt.homedir; break;
770 #else /* __riscos__ */
771       case 32: p = make_filename(opt.homedir, NULL); break;
772 #endif /* __riscos__ */
773       case 33: p = _("\nSupported algorithms:\n"); break;
774       case 34:
775         if (!pubkeys)
776             pubkeys = build_list (_("Pubkey: "), 0,
777                                   gcry_pk_algo_name,
778                                   openpgp_pk_test_algo );
779         p = pubkeys;
780         break;
781       case 35:
782         if( !ciphers )
783             ciphers = build_list(_("Cipher: "), 'S', 
784                                  gcry_cipher_algo_name,
785                                  openpgp_cipher_test_algo );
786         p = ciphers;
787         break;
788       case 36:
789         if( !digests )
790             digests = build_list(_("Hash: "), 'H', 
791                                  gcry_md_algo_name,
792                                  openpgp_md_test_algo );
793         p = digests;
794         break;
795       case 37:
796         if( !zips )
797             zips = build_list(_("Compression: "),'Z',
798                               compress_algo_to_string,
799                               check_compress_algo);
800         p = zips;
801         break;
802
803       default:  p = NULL;
804     }
805     return p;
806 }
807
808
809 static char *
810 build_list( const char *text, char letter,
811             const char * (*mapf)(int), int (*chkf)(int) )
812 {
813     int i;
814     const char *s;
815     size_t n=strlen(text)+2;
816     char *list, *p, *line=NULL;
817
818     if (maybe_setuid)
819       gcry_control (GCRYCTL_INIT_SECMEM, 0, 0);  /* Drop setuid. */
820
821     for(i=0; i <= 110; i++ )
822         if( !chkf(i) && (s=mapf(i)) )
823             n += strlen(s) + 7 + 2;
824     list = xmalloc( 21 + n ); *list = 0;
825     for(p=NULL, i=0; i <= 110; i++ ) {
826         if( !chkf(i) && (s=mapf(i)) ) {
827             if( !p ) {
828                 p = stpcpy( list, text );
829                 line=p;
830             }
831             else
832                 p = stpcpy( p, ", ");
833
834             if(strlen(line)>60) {
835               int spaces=strlen(text);
836
837               list=xrealloc(list,n+spaces+1);
838               /* realloc could move the block, so find the end again */
839               p=list;
840               while(*p)
841                 p++;
842
843               p=stpcpy(p, "\n");
844               line=p;
845               for(;spaces;spaces--)
846                 p=stpcpy(p, " ");
847             }
848
849             p = stpcpy(p, s );
850             if(opt.verbose && letter)
851               {
852                 char num[8];
853                 sprintf(num," (%c%d)",letter,i);
854                 p = stpcpy(p,num);
855               }
856         }
857     }
858     if( p )
859         p = stpcpy(p, "\n" );
860     return list;
861 }
862
863
864 static void
865 i18n_init(void)
866 {
867 #ifdef USE_SIMPLE_GETTEXT
868   set_gettext_file (PACKAGE_GT, "Software\\GNU\\GnuPG");
869 #else
870 #ifdef ENABLE_NLS
871   setlocale (LC_ALL, "");
872   bindtextdomain (PACKAGE_GT, LOCALEDIR);
873   textdomain (PACKAGE_GT);
874 #endif
875 #endif
876 }
877
878 static void
879 wrong_args( const char *text)
880 {
881     fputs(_("usage: gpg [options] "),stderr);
882     fputs(text,stderr);
883     putc('\n',stderr);
884     g10_exit(2);
885 }
886
887
888 static char *
889 make_username( const char *string )
890 {
891     char *p;
892     if( utf8_strings )
893         p = xstrdup(string);
894     else
895         p = native_to_utf8( string );
896     return p;
897 }
898
899
900 /* Setup the debugging.  With a LEVEL of NULL only the active debug
901    flags are propagated to the subsystems.  With LEVEL set, a specific
902    set of debug flags is set; thus overriding all flags already
903    set. */
904 static void
905 set_debug (const char *level)
906 {
907   if (!level)
908     ;
909   else if (!strcmp (level, "none"))
910     opt.debug = 0;
911   else if (!strcmp (level, "basic"))
912     opt.debug = DBG_MEMSTAT_VALUE;
913   else if (!strcmp (level, "advanced"))
914     opt.debug = DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE;
915   else if (!strcmp (level, "expert"))
916     opt.debug = (DBG_MEMSTAT_VALUE|DBG_TRUST_VALUE|DBG_EXTPROG_VALUE
917                  |DBG_CACHE_VALUE|DBG_FILTER_VALUE|DBG_PACKET_VALUE);
918   else if (!strcmp (level, "guru"))
919     opt.debug = ~0;
920   else
921     {
922       log_error (_("invalid debug-level `%s' given\n"), level);
923       g10_exit (2);
924     }
925
926   if (opt.debug & DBG_MEMORY_VALUE )
927     memory_debug_mode = 1;
928   if (opt.debug & DBG_MEMSTAT_VALUE )
929     memory_stat_debug_mode = 1;
930   if (opt.debug & DBG_MPI_VALUE)
931     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
932   if (opt.debug & DBG_CIPHER_VALUE )
933     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
934   if (opt.debug & DBG_IOBUF_VALUE )
935     iobuf_debug_mode = 1;
936   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
937 }
938
939
940
941 /* We need the home directory also in some other directories, so make
942    sure that both variables are always in sync. */
943 static void
944 set_homedir (const char *dir)
945 {
946   if (!dir)
947     dir = "";
948   opt.homedir = dir;
949 }
950
951
952 /* We set the screen dimensions for UI purposes.  Do not allow screens
953    smaller than 80x24 for the sake of simplicity. */
954 static void
955 set_screen_dimensions(void)
956 {
957 #ifndef HAVE_W32_SYSTEM
958   char *str;
959
960   str=getenv("COLUMNS");
961   if(str)
962     opt.screen_columns=atoi(str);
963
964   str=getenv("LINES");
965   if(str)
966     opt.screen_lines=atoi(str);
967 #endif
968
969   if(opt.screen_columns<80 || opt.screen_columns>255)
970     opt.screen_columns=80;
971
972   if(opt.screen_lines<24 || opt.screen_lines>255)
973     opt.screen_lines=24;
974 }
975
976
977 /* Helper to open a file FNAME either for reading or writing to be
978    used with --status-file etc functions.  Not generally useful but it
979    avoids the riscos specific functions and well some Windows people
980    might like it too.  Prints an error message and returns -1 on
981    error. On success the file descriptor is returned.  */
982 static int
983 open_info_file (const char *fname, int for_write)
984 {
985 #ifdef __riscos__
986   return riscos_fdopenfile (fname, for_write);
987 #elif defined (ENABLE_SELINUX_HACKS)
988   /* We can't allow these even when testing for a secured filename
989      because files to be secured might not yet been secured.  This is
990      similar to the option file but in that case it is unlikely that
991      sensitive information may be retrieved by means of error
992      messages.  */
993   return -1;
994 #else 
995   int fd;
996
997 /*   if (is_secured_filename (fname)) */
998 /*     { */
999 /*       fd = -1; */
1000 /*       errno = EPERM; */
1001 /*     } */
1002 /*   else */
1003 /*     { */
1004       do
1005         {
1006           if (for_write)
1007             fd = open (fname, O_CREAT | O_TRUNC | O_WRONLY,
1008                         S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
1009           else
1010             fd = open (fname, O_RDONLY | MY_O_BINARY);
1011         }
1012       while (fd == -1 && errno == EINTR);
1013 /*     } */
1014   if ( fd == -1)
1015     log_error ( for_write? _("can't create `%s': %s\n")
1016                          : _("can't open `%s': %s\n"), fname, strerror(errno));
1017   
1018   return fd;
1019 #endif
1020 }
1021
1022 static void
1023 set_cmd( enum cmd_and_opt_values *ret_cmd, enum cmd_and_opt_values new_cmd )
1024 {
1025     enum cmd_and_opt_values cmd = *ret_cmd;
1026
1027     if( !cmd || cmd == new_cmd )
1028         cmd = new_cmd;
1029     else if( cmd == aSign && new_cmd == aEncr )
1030         cmd = aSignEncr;
1031     else if( cmd == aEncr && new_cmd == aSign )
1032         cmd = aSignEncr;
1033     else if( cmd == aSign && new_cmd == aSym )
1034         cmd = aSignSym;
1035     else if( cmd == aSym && new_cmd == aSign )
1036         cmd = aSignSym;
1037     else if( cmd == aSym && new_cmd == aEncr )
1038         cmd = aEncrSym;
1039     else if( cmd == aEncr && new_cmd == aSym )
1040         cmd = aEncrSym;
1041     else if( cmd == aKMode && new_cmd == aSym )
1042         cmd = aKModeC;
1043     else if (cmd == aSignEncr && new_cmd == aSym)
1044         cmd = aSignEncrSym;
1045     else if (cmd == aSignSym && new_cmd == aEncr)
1046         cmd = aSignEncrSym;
1047     else if (cmd == aEncrSym && new_cmd == aSign)
1048         cmd = aSignEncrSym;
1049     else if(    ( cmd == aSign     && new_cmd == aClearsign )
1050              || ( cmd == aClearsign && new_cmd == aSign )  )
1051         cmd = aClearsign;
1052     else {
1053         log_error(_("conflicting commands\n"));
1054         g10_exit(2);
1055     }
1056
1057     *ret_cmd = cmd;
1058 }
1059
1060
1061 static void
1062 add_group(char *string)
1063 {
1064   char *name,*value;
1065   struct groupitem *item;
1066
1067   /* Break off the group name */
1068   name=strsep(&string,"=");
1069   if(string==NULL)
1070     {
1071       log_error(_("no = sign found in group definition `%s'\n"),name);
1072       return;
1073     }
1074
1075   trim_trailing_ws(name,strlen(name));
1076
1077   /* Does this group already exist? */
1078   for(item=opt.grouplist;item;item=item->next)
1079     if(strcasecmp(item->name,name)==0)
1080       break;
1081
1082   if(!item)
1083     {
1084       item=xmalloc(sizeof(struct groupitem));
1085       item->name=name;
1086       item->next=opt.grouplist;
1087       item->values=NULL;
1088       opt.grouplist=item;
1089     }
1090
1091   /* Break apart the values */
1092   while ((value= strsep(&string," \t")))
1093     {
1094       if (*value)
1095         add_to_strlist2(&item->values,value,utf8_strings);
1096     }
1097 }
1098
1099
1100 static void
1101 rm_group(char *name)
1102 {
1103   struct groupitem *item,*last=NULL;
1104
1105   trim_trailing_ws(name,strlen(name));
1106
1107   for(item=opt.grouplist;item;last=item,item=item->next)
1108     {
1109       if(strcasecmp(item->name,name)==0)
1110         {
1111           if(last)
1112             last->next=item->next;
1113           else
1114             opt.grouplist=item->next;
1115
1116           free_strlist(item->values);
1117           xfree(item);
1118           break;
1119         }
1120     }
1121 }
1122
1123
1124 /* We need to check three things.
1125
1126    0) The homedir.  It must be x00, a directory, and owned by the
1127    user.
1128
1129    1) The options/gpg.conf file.  Okay unless it or its containing
1130    directory is group or other writable or not owned by us.  Disable
1131    exec in this case.
1132
1133    2) Extensions.  Same as #1.
1134
1135    Returns true if the item is unsafe. */
1136 static int
1137 check_permissions(const char *path,int item)
1138 {
1139 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
1140   static int homedir_cache=-1;
1141   char *tmppath,*dir;
1142   struct stat statbuf,dirbuf;
1143   int homedir=0,ret=0,checkonly=0;
1144   int perm=0,own=0,enc_dir_perm=0,enc_dir_own=0;
1145
1146   if(opt.no_perm_warn)
1147     return 0;
1148
1149   assert(item==0 || item==1 || item==2);
1150
1151   /* extensions may attach a path */
1152   if(item==2 && path[0]!=DIRSEP_C)
1153     {
1154       if(strchr(path,DIRSEP_C))
1155         tmppath=make_filename(path,NULL);
1156       else
1157         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
1158     }
1159   else
1160     tmppath=xstrdup(path);
1161
1162   /* If the item is located in the homedir, but isn't the homedir,
1163      don't continue if we already checked the homedir itself.  This is
1164      to avoid user confusion with an extra options file warning which
1165      could be rectified if the homedir itself had proper
1166      permissions. */
1167   if(item!=0 && homedir_cache>-1
1168      && ascii_strncasecmp(opt.homedir,tmppath,strlen(opt.homedir))==0)
1169     {
1170       ret=homedir_cache;
1171       goto end;
1172     }
1173
1174   /* It's okay if the file or directory doesn't exist */
1175   if(stat(tmppath,&statbuf)!=0)
1176     {
1177       ret=0;
1178       goto end;
1179     }
1180
1181   /* Now check the enclosing directory.  Theoretically, we could walk
1182      this test up to the root directory /, but for the sake of sanity,
1183      I'm stopping at one level down. */
1184   dir=make_dirname(tmppath);
1185
1186   if(stat(dir,&dirbuf)!=0 || !S_ISDIR(dirbuf.st_mode))
1187     {
1188       /* Weird error */
1189       ret=1;
1190       goto end;
1191     }
1192
1193   xfree(dir);
1194
1195   /* Assume failure */
1196   ret=1;
1197
1198   if(item==0)
1199     {
1200       /* The homedir must be x00, a directory, and owned by the user. */
1201
1202       if(S_ISDIR(statbuf.st_mode))
1203         {
1204           if(statbuf.st_uid==getuid())
1205             {
1206               if((statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1207                 ret=0;
1208               else
1209                 perm=1;
1210             }
1211           else
1212             own=1;
1213
1214           homedir_cache=ret;
1215         }
1216     }
1217   else if(item==1 || item==2)
1218     {
1219       /* The options or extension file.  Okay unless it or its
1220          containing directory is group or other writable or not owned
1221          by us or root. */
1222
1223       if(S_ISREG(statbuf.st_mode))
1224         {
1225           if(statbuf.st_uid==getuid() || statbuf.st_uid==0)
1226             {
1227               if((statbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1228                 {
1229                   /* it's not writable, so make sure the enclosing
1230                      directory is also not writable */
1231                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1232                     {
1233                       if((dirbuf.st_mode & (S_IWGRP|S_IWOTH))==0)
1234                         ret=0;
1235                       else
1236                         enc_dir_perm=1;
1237                     }
1238                   else
1239                     enc_dir_own=1;
1240                 }
1241               else
1242                 {
1243                   /* it's writable, so the enclosing directory had
1244                      better not let people get to it. */
1245                   if(dirbuf.st_uid==getuid() || dirbuf.st_uid==0)
1246                     {
1247                       if((dirbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
1248                         ret=0;
1249                       else
1250                         perm=enc_dir_perm=1; /* unclear which one to fix! */
1251                     }
1252                   else
1253                     enc_dir_own=1;
1254                 }
1255             }
1256           else
1257             own=1;
1258         }
1259     }
1260   else
1261     BUG();
1262
1263   if(!checkonly)
1264     {
1265       if(own)
1266         {
1267           if(item==0)
1268             log_info(_("WARNING: unsafe ownership on"
1269                        " homedir `%s'\n"),tmppath);
1270           else if(item==1)
1271             log_info(_("WARNING: unsafe ownership on"
1272                        " configuration file `%s'\n"),tmppath);
1273           else
1274             log_info(_("WARNING: unsafe ownership on"
1275                        " extension `%s'\n"),tmppath);
1276         }
1277       if(perm)
1278         {
1279           if(item==0)
1280             log_info(_("WARNING: unsafe permissions on"
1281                        " homedir `%s'\n"),tmppath);
1282           else if(item==1)
1283             log_info(_("WARNING: unsafe permissions on"
1284                        " configuration file `%s'\n"),tmppath);
1285           else
1286             log_info(_("WARNING: unsafe permissions on"
1287                        " extension `%s'\n"),tmppath);
1288         }
1289       if(enc_dir_own)
1290         {
1291           if(item==0)
1292             log_info(_("WARNING: unsafe enclosing directory ownership on"
1293                        " homedir `%s'\n"),tmppath);
1294           else if(item==1)
1295             log_info(_("WARNING: unsafe enclosing directory ownership on"
1296                        " configuration file `%s'\n"),tmppath);
1297           else
1298             log_info(_("WARNING: unsafe enclosing directory ownership on"
1299                        " extension `%s'\n"),tmppath);
1300         }
1301       if(enc_dir_perm)
1302         {
1303           if(item==0)
1304             log_info(_("WARNING: unsafe enclosing directory permissions on"
1305                        " homedir `%s'\n"),tmppath);
1306           else if(item==1)
1307             log_info(_("WARNING: unsafe enclosing directory permissions on"
1308                        " configuration file `%s'\n"),tmppath);
1309           else
1310             log_info(_("WARNING: unsafe enclosing directory permissions on"
1311                        " extension `%s'\n"),tmppath);
1312         }
1313     }
1314
1315  end:
1316   xfree(tmppath);
1317
1318   if(homedir)
1319     homedir_cache=ret;
1320
1321   return ret;
1322
1323 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
1324
1325   return 0;
1326 }
1327
1328
1329 static void
1330 print_algo_numbers(int (*checker)(int))
1331 {
1332   int i,first=1;
1333
1334   for(i=0;i<=110;i++)
1335     {
1336       if(!checker(i))
1337         {
1338           if(first)
1339             first=0;
1340           else
1341             printf(";");
1342           printf("%d",i);
1343         }
1344     }
1345 }
1346
1347
1348 /* In the future, we can do all sorts of interesting configuration
1349    output here.  For now, just give "group" as the Enigmail folks need
1350    it, and pubkey, cipher, hash, and compress as they may be useful
1351    for frontends. */
1352 static void
1353 list_config(char *items)
1354 {
1355   int show_all=(items==NULL);
1356   char *name=NULL;
1357
1358   if(!opt.with_colons)
1359     return;
1360
1361   while(show_all || (name=strsep(&items," ")))
1362     {
1363       int any=0;
1364
1365       if(show_all || ascii_strcasecmp(name,"group")==0)
1366         {
1367           struct groupitem *iter;
1368
1369           for(iter=opt.grouplist;iter;iter=iter->next)
1370             {
1371               STRLIST sl;
1372
1373               printf("cfg:group:");
1374               print_string(stdout,iter->name,strlen(iter->name),':');
1375               printf(":");
1376
1377               for(sl=iter->values;sl;sl=sl->next)
1378                 {
1379                   print_sanitized_string2 (stdout, sl->d, ':',';');
1380                   if(sl->next)
1381                     printf(";");
1382                 }
1383
1384               printf("\n");
1385             }
1386
1387           any=1;
1388         }
1389
1390       if(show_all || ascii_strcasecmp(name,"version")==0)
1391         {
1392           printf("cfg:version:");
1393           print_string(stdout,VERSION,strlen(VERSION),':');
1394           printf("\n");
1395           any=1;
1396         }
1397
1398       if(show_all || ascii_strcasecmp(name,"pubkey")==0)
1399         {
1400           printf("cfg:pubkey:");
1401           print_algo_numbers (openpgp_pk_test_algo);
1402           printf("\n");
1403           any=1;
1404         }
1405
1406       if(show_all || ascii_strcasecmp(name,"cipher")==0)
1407         {
1408           printf("cfg:cipher:");
1409           print_algo_numbers(openpgp_cipher_test_algo);
1410           printf("\n");
1411           any=1;
1412         }
1413
1414       if(show_all
1415          || ascii_strcasecmp(name,"digest")==0
1416          || ascii_strcasecmp(name,"hash")==0)
1417         {
1418           printf("cfg:digest:");
1419           print_algo_numbers(openpgp_md_test_algo);
1420           printf("\n");
1421           any=1;
1422         }
1423
1424       if(show_all || ascii_strcasecmp(name,"compress")==0)
1425         {
1426           printf("cfg:compress:");
1427           print_algo_numbers(check_compress_algo);
1428           printf("\n");
1429           any=1;
1430         }
1431
1432       if(show_all || ascii_strcasecmp(name,"ccid-reader-id")==0)
1433         {
1434 #if defined(ENABLE_CARD_SUPPORT) && defined(HAVE_LIBUSB)
1435           char *p, *p2, *list = ccid_get_reader_list ();
1436
1437           for (p=list; p && (p2 = strchr (p, '\n')); p = p2+1)
1438             {
1439               *p2 = 0;
1440               printf("cfg:ccid-reader-id:%s\n", p);
1441             }
1442           free (list);
1443 #endif
1444           any=1;
1445         }
1446
1447       if(show_all)
1448         break;
1449
1450       if(!any)
1451         log_error(_("unknown configuration item `%s'\n"),name);
1452     }
1453 }
1454
1455
1456 /* List options and default values in the GPG Conf format.  This is a
1457    new tool distributed with gnupg 1.9.x but we also want some limited
1458    support in older gpg versions.  The output is the name of the
1459    configuration file and a list of options available for editing by
1460    gpgconf.  */
1461 static void
1462 gpgconf_list (const char *configfile)
1463 {
1464   /* The following definitions are taken from gnupg/tools/gpgconf-comp.c.  */
1465 #define GC_OPT_FLAG_NONE        0UL
1466 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
1467
1468   printf ("gpgconf-gpg.conf:%lu:\"%s\n",
1469           GC_OPT_FLAG_DEFAULT,configfile?configfile:"/dev/null");
1470   printf ("verbose:%lu:\n", GC_OPT_FLAG_NONE);
1471   printf ("quiet:%lu:\n",   GC_OPT_FLAG_NONE);
1472   printf ("keyserver:%lu:\n", GC_OPT_FLAG_NONE);
1473   printf ("reader-port:%lu:\n", GC_OPT_FLAG_NONE);
1474 }
1475
1476
1477 static int
1478 parse_subpacket_list(char *list)
1479 {
1480   char *tok;
1481   byte subpackets[128],i;
1482   int count=0;
1483
1484   if(!list)
1485     {
1486       /* No arguments means all subpackets */
1487       memset(subpackets+1,1,sizeof(subpackets)-1);
1488       count=127;
1489     }
1490   else
1491     {
1492       memset(subpackets,0,sizeof(subpackets));
1493
1494       /* Merge with earlier copy */
1495       if(opt.show_subpackets)
1496         {
1497           byte *in;
1498
1499           for(in=opt.show_subpackets;*in;in++)
1500             {
1501               if(*in>127 || *in<1)
1502                 BUG();
1503
1504               if(!subpackets[*in])
1505                 count++;
1506               subpackets[*in]=1;
1507             }
1508         }
1509
1510       while((tok=strsep(&list," ,")))
1511         {
1512           if(!*tok)
1513             continue;
1514
1515           i=atoi(tok);
1516           if(i>127 || i<1)
1517             return 0;
1518
1519           if(!subpackets[i])
1520             count++;
1521           subpackets[i]=1;
1522         }
1523     }
1524
1525   xfree(opt.show_subpackets);
1526   opt.show_subpackets=xmalloc(count+1);
1527   opt.show_subpackets[count--]=0;
1528
1529   for(i=1;i<128 && count>=0;i++)
1530     if(subpackets[i])
1531       opt.show_subpackets[count--]=i;
1532
1533   return 1;
1534 }
1535
1536
1537 static int
1538 parse_list_options(char *str)
1539 {
1540   char *subpackets=""; /* something that isn't NULL */
1541   struct parse_options lopts[]=
1542     {
1543       {"show-photos",LIST_SHOW_PHOTOS,NULL,
1544        N_("display photo IDs during key listings")},
1545       {"show-policy-urls",LIST_SHOW_POLICY_URLS,NULL,
1546        N_("show policy URLs during signature listings")},
1547       {"show-notations",LIST_SHOW_NOTATIONS,NULL,
1548        N_("show all notations during signature listings")},
1549       {"show-std-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1550        N_("show IETF standard notations during signature listings")},
1551       {"show-standard-notations",LIST_SHOW_STD_NOTATIONS,NULL,
1552        NULL},
1553       {"show-user-notations",LIST_SHOW_USER_NOTATIONS,NULL,
1554        N_("show user-supplied notations during signature listings")},
1555       {"show-keyserver-urls",LIST_SHOW_KEYSERVER_URLS,NULL,
1556        N_("show preferred keyserver URLs during signature listings")},
1557       {"show-uid-validity",LIST_SHOW_UID_VALIDITY,NULL,
1558        N_("show user ID validity during key listings")},
1559       {"show-unusable-uids",LIST_SHOW_UNUSABLE_UIDS,NULL,
1560        N_("show revoked and expired user IDs in key listings")},
1561       {"show-unusable-subkeys",LIST_SHOW_UNUSABLE_SUBKEYS,NULL,
1562        N_("show revoked and expired subkeys in key listings")},
1563       {"show-keyring",LIST_SHOW_KEYRING,NULL,
1564        N_("show the keyring name in key listings")},
1565       {"show-sig-expire",LIST_SHOW_SIG_EXPIRE,NULL,
1566        N_("show expiration dates during signature listings")},
1567       {"show-sig-subpackets",LIST_SHOW_SIG_SUBPACKETS,NULL,
1568        NULL},
1569       {NULL,0,NULL,NULL}
1570     };
1571
1572   /* C99 allows for non-constant initializers, but we'd like to
1573      compile everywhere, so fill in the show-sig-subpackets argument
1574      here.  Note that if the parse_options array changes, we'll have
1575      to change the subscript here. */
1576   lopts[12].value=&subpackets;
1577
1578   if(parse_options(str,&opt.list_options,lopts,1))
1579     {
1580       if(opt.list_options&LIST_SHOW_SIG_SUBPACKETS)
1581         {
1582           /* Unset so users can pass multiple lists in. */
1583           opt.list_options&=~LIST_SHOW_SIG_SUBPACKETS;
1584           if(!parse_subpacket_list(subpackets))
1585             return 0;
1586         }
1587       else if(subpackets==NULL && opt.show_subpackets)
1588         {
1589           /* User did 'no-show-subpackets' */
1590           xfree(opt.show_subpackets);
1591           opt.show_subpackets=NULL;
1592         }
1593
1594       return 1;
1595     }
1596   else
1597     return 0;
1598 }
1599
1600
1601 /* Collapses argc/argv into a single string that must be freed */
1602 static char *
1603 collapse_args(int argc,char *argv[])
1604 {
1605   char *str=NULL;
1606   int i,first=1,len=0;
1607
1608   for(i=0;i<argc;i++)
1609     {
1610       len+=strlen(argv[i])+2;
1611       str=xrealloc(str,len);
1612       if(first)
1613         {
1614           str[0]='\0';
1615           first=0;
1616         }
1617       else
1618         strcat(str," ");
1619
1620       strcat(str,argv[i]);
1621     }
1622
1623   return str;
1624 }
1625
1626 static void
1627 parse_trust_model(const char *model)
1628 {
1629   if(ascii_strcasecmp(model,"pgp")==0)
1630     opt.trust_model=TM_PGP;
1631   else if(ascii_strcasecmp(model,"classic")==0)
1632     opt.trust_model=TM_CLASSIC;
1633   else if(ascii_strcasecmp(model,"always")==0)
1634     opt.trust_model=TM_ALWAYS;
1635   else if(ascii_strcasecmp(model,"direct")==0)
1636     opt.trust_model=TM_DIRECT;
1637   else if(ascii_strcasecmp(model,"auto")==0)
1638     opt.trust_model=TM_AUTO;
1639   else
1640     log_error("unknown trust model `%s'\n",model);
1641 }
1642
1643 int
1644 main (int argc, char **argv )
1645 {
1646     ARGPARSE_ARGS pargs;
1647     IOBUF a;
1648     int rc=0;
1649     int orig_argc;
1650     char **orig_argv;
1651     const char *fname;
1652     char *username;
1653     int may_coredump;
1654     STRLIST sl, remusr= NULL, locusr=NULL;
1655     STRLIST nrings=NULL, sec_nrings=NULL;
1656     armor_filter_context_t afx;
1657     int detached_sig = 0;
1658     FILE *configfp = NULL;
1659     char *configname = NULL;
1660     char *save_configname = NULL;
1661     unsigned configlineno;
1662     int parse_debug = 0;
1663     int default_config = 1;
1664     int default_keyring = 1;
1665     int greeting = 0;
1666     int nogreeting = 0;
1667     char *logfile = NULL;
1668     int use_random_seed = 1;
1669     enum cmd_and_opt_values cmd = 0;
1670     const char *debug_level = NULL;
1671     const char *trustdb_name = NULL;
1672     char *def_cipher_string = NULL;
1673     char *def_digest_string = NULL;
1674     char *compress_algo_string = NULL;
1675     char *cert_digest_string = NULL;
1676     char *s2k_cipher_string = NULL;
1677     char *s2k_digest_string = NULL;
1678     char *pers_cipher_list = NULL;
1679     char *pers_digest_list = NULL;
1680     char *pers_compress_list = NULL;
1681     int eyes_only=0;
1682     int multifile=0;
1683     int pwfd = -1;
1684     int with_fpr = 0; /* make an option out of --fingerprint */
1685     int any_explicit_recipient = 0;
1686     int require_secmem=0,got_secmem=0;
1687
1688 #ifdef __riscos__
1689     opt.lock_once = 1;
1690 #endif /* __riscos__ */
1691
1692
1693     /* Please note that we may running SUID(ROOT), so be very CAREFUL
1694        when adding any stuff between here and the call to
1695        secmem_init() somewhere after the option parsing. */
1696
1697     trap_unaligned();
1698     set_strusage (my_strusage);
1699     gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
1700     /* We don't need any locking in libgcrypt unless we use any kind of
1701        threading. */
1702     gcry_control (GCRYCTL_DISABLE_INTERNAL_LOCKING);
1703     log_set_prefix ("gpg", 1);
1704
1705     /* Check that the libraries are suitable.  Do it right here because the
1706        option parsing may need services of the library.  */
1707     if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
1708       {
1709         log_fatal ( _("libgcrypt is too old (need %s, have %s)\n"),
1710                     NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
1711       }
1712
1713     /* Put random number into secure memory */
1714     gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
1715
1716     may_coredump = disable_core_dumps();
1717
1718     gnupg_init_signals (0, emergency_cleanup);
1719
1720     create_dotlock(NULL); /* Register locking cleanup. */
1721
1722     i18n_init();
1723
1724     opt.command_fd = -1; /* no command fd */
1725     opt.compress_level = -1; /* defaults to standard compress level */
1726     opt.bz2_compress_level = -1; /* defaults to standard compress level */
1727     /* note: if you change these lines, look at oOpenPGP */
1728     opt.def_cipher_algo = 0;
1729     opt.def_digest_algo = 0;
1730     opt.cert_digest_algo = 0;
1731     opt.compress_algo = -1; /* defaults to DEFAULT_COMPRESS_ALGO */
1732     opt.s2k_mode = 3; /* iterated+salted */
1733 #ifdef USE_CAST5
1734     opt.s2k_cipher_algo = CIPHER_ALGO_CAST5;
1735 #else
1736     opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
1737 #endif
1738     opt.completes_needed = 1;
1739     opt.marginals_needed = 3;
1740     opt.max_cert_depth = 5;
1741     opt.pgp2_workarounds = 1;
1742     opt.force_v3_sigs = 1;
1743     opt.escape_from = 1;
1744     opt.import_options=IMPORT_SK2PK;
1745     opt.export_options=EXPORT_ATTRIBUTES;
1746     opt.keyserver_options.import_options=IMPORT_REPAIR_PKS_SUBKEY_BUG;
1747     opt.keyserver_options.export_options=EXPORT_ATTRIBUTES;
1748     opt.keyserver_options.options=
1749       KEYSERVER_HONOR_KEYSERVER_URL|KEYSERVER_HONOR_PKA_RECORD;
1750     opt.verify_options=
1751       VERIFY_SHOW_POLICY_URLS|VERIFY_SHOW_STD_NOTATIONS|VERIFY_SHOW_KEYSERVER_URLS;
1752     opt.trust_model=TM_AUTO;
1753     opt.mangle_dos_filenames=0;
1754     opt.min_cert_level=2;
1755     set_screen_dimensions();
1756     opt.keyid_format=KF_SHORT;
1757     opt.rfc2440_text=1;
1758     opt.def_sig_expire="0";
1759     opt.def_cert_expire="0";
1760     set_homedir ( default_homedir () );
1761
1762     /* Check whether we have a config file on the command line.  */
1763     orig_argc = argc;
1764     orig_argv = argv;
1765     pargs.argc = &argc;
1766     pargs.argv = &argv;
1767     pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
1768     while( arg_parse( &pargs, opts) ) {
1769         if( pargs.r_opt == oDebug || pargs.r_opt == oDebugAll )
1770             parse_debug++;
1771         else if( pargs.r_opt == oOptions ) {
1772             /* yes there is one, so we do not try the default one, but
1773              * read the option file when it is encountered at the commandline
1774              */
1775             default_config = 0;
1776         }
1777         else if( pargs.r_opt == oNoOptions )
1778             default_config = 0; /* --no-options */
1779         else if( pargs.r_opt == oHomedir )
1780             set_homedir ( pargs.r.ret_str );
1781         else if( pargs.r_opt == oNoPermissionWarn )
1782             opt.no_perm_warn=1;
1783         else if (pargs.r_opt == oStrict )
1784           {
1785             /* Not used */
1786           }
1787         else if (pargs.r_opt == oNoStrict )
1788           {
1789             /* Not used */
1790           }
1791     }
1792
1793 #ifdef HAVE_DOSISH_SYSTEM
1794     if ( strchr (opt.homedir,'\\') ) {
1795         char *d, *buf = xmalloc (strlen (opt.homedir)+1);
1796         const char *s = opt.homedir;
1797         for (d=buf,s=opt.homedir; *s; s++)
1798           {
1799             *d++ = *s == '\\'? '/': *s;
1800 #ifdef HAVE_W32_SYSTEM
1801             if (s[1] && IsDBCSLeadByte (*s))
1802               *d++ = *++s;
1803 #endif
1804           }
1805         *d = 0;
1806         set_homedir (buf);
1807     }
1808 #endif
1809
1810     /* Initialize the secure memory. */
1811     gcry_control (GCRYCTL_INIT_SECMEM, 32768, 0);
1812     got_secmem = 1; /* FIXME: gcry_control should return an indicator. */
1813 #if defined(HAVE_GETUID) && defined(HAVE_GETEUID)
1814     /* There should be no way to get to this spot while still carrying
1815        setuid privs.  Just in case, bomb out if we are. */
1816     if(getuid()!=geteuid())
1817       BUG();
1818 #endif
1819     maybe_setuid = 0;
1820
1821     /* Okay, we are now working under our real uid */
1822
1823     /* malloc hooks go here ... */
1824     assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
1825
1826
1827     set_native_charset (NULL); /* Try to auto set the character set */
1828
1829     /* Try for a version specific config file first */
1830     if( default_config )
1831       {
1832         char *name=xstrdup("gpg" EXTSEP_S "conf-" SAFE_VERSION);
1833         char *ver=&name[strlen("gpg" EXTSEP_S "conf-")];
1834
1835         do
1836           {
1837             if(configname)
1838               {
1839                 char *tok;
1840
1841                 xfree(configname);
1842                 configname=NULL;
1843
1844                 if((tok=strrchr(ver,SAFE_VERSION_DASH)))
1845                   *tok='\0';
1846                 else if((tok=strrchr(ver,SAFE_VERSION_DOT)))
1847                   *tok='\0';
1848                 else
1849                   break;
1850               }
1851
1852             configname = make_filename(opt.homedir,name,NULL);
1853           }
1854         while(access(configname,R_OK));
1855
1856         xfree(name);
1857
1858         if(!configname)
1859           configname=make_filename(opt.homedir, "gpg" EXTSEP_S "conf", NULL );
1860         if (!access (configname, R_OK))
1861           { /* Print a warning when both config files are present. */
1862             char *p = make_filename(opt.homedir, "options", NULL );
1863             if (!access (p, R_OK))
1864               log_info (_("NOTE: old default options file `%s' ignored\n"), p);
1865             xfree (p);
1866           }
1867         else
1868           { /* Keep on using the old default one. */
1869             xfree (configname);
1870             configname = make_filename(opt.homedir, "options", NULL );
1871           }
1872       }
1873     argc = orig_argc;
1874     argv = orig_argv;
1875     pargs.argc = &argc;
1876     pargs.argv = &argv;
1877     pargs.flags=  1;  /* do not remove the args */
1878
1879     /* By this point we have a homedir, and cannot change it. */
1880     check_permissions(opt.homedir,0);
1881
1882   next_pass:
1883     if( configname ) {
1884       if(check_permissions(configname,1))
1885         {
1886           /* If any options file is unsafe, then disable any external
1887              programs for keyserver calls or photo IDs.  Since the
1888              external program to call is set in the options file, a
1889              unsafe options file can lead to an arbitrary program
1890              being run. */
1891
1892           opt.exec_disable=1;
1893         }
1894
1895         configlineno = 0;
1896         configfp = fopen( configname, "r" );
1897         if (configfp && is_secured_file (fileno (configfp)))
1898           {
1899             fclose (configfp);
1900             configfp = NULL;
1901             errno = EPERM;
1902           }
1903         if( !configfp ) {
1904             if( default_config ) {
1905                 if( parse_debug )
1906                     log_info(_("NOTE: no default option file `%s'\n"),
1907                                                             configname );
1908             }
1909             else {
1910                 log_error(_("option file `%s': %s\n"),
1911                                     configname, strerror(errno) );
1912                 g10_exit(2);
1913             }
1914             xfree(configname); configname = NULL;
1915         }
1916         if( parse_debug && configname )
1917             log_info(_("reading options from `%s'\n"), configname );
1918         default_config = 0;
1919     }
1920
1921     while( optfile_parse( configfp, configname, &configlineno,
1922                                                 &pargs, opts) )
1923       {
1924         switch( pargs.r_opt )
1925           {
1926           case aCheckKeys: 
1927           case aListConfig:
1928           case aGPGConfList:
1929           case aListPackets:
1930           case aImport: 
1931           case aFastImport: 
1932           case aSendKeys: 
1933           case aRecvKeys: 
1934           case aSearchKeys:
1935           case aRefreshKeys:
1936           case aFetchKeys:
1937           case aExport: 
1938             set_cmd (&cmd, pargs.r_opt);
1939             break;
1940           case aListKeys: set_cmd( &cmd, aListKeys); break;
1941           case aListSigs: set_cmd( &cmd, aListSigs); break;
1942           case aExportSecret: set_cmd( &cmd, aExportSecret); break;
1943           case aExportSecretSub: set_cmd( &cmd, aExportSecretSub); break;
1944           case aDeleteSecretKeys:
1945             set_cmd( &cmd, aDeleteSecretKeys);
1946             greeting=1;
1947             break;
1948           case aDeleteSecretAndPublicKeys:
1949             set_cmd( &cmd, aDeleteSecretAndPublicKeys);
1950             greeting=1; 
1951             break;
1952           case aDeleteKeys: set_cmd( &cmd, aDeleteKeys); greeting=1; break;
1953
1954           case aDetachedSign: detached_sig = 1; set_cmd( &cmd, aSign ); break;
1955           case aSym: set_cmd( &cmd, aSym); break;
1956
1957           case aDecryptFiles: multifile=1; /* fall through */
1958           case aDecrypt: set_cmd( &cmd, aDecrypt); break;
1959
1960           case aEncrFiles: multifile=1; /* fall through */
1961           case aEncr: set_cmd( &cmd, aEncr); break;
1962
1963           case aVerifyFiles: multifile=1; /* fall through */
1964           case aVerify: set_cmd( &cmd, aVerify); break;
1965
1966           case aSign: set_cmd( &cmd, aSign );  break;
1967           case aKeygen: set_cmd( &cmd, aKeygen); greeting=1; break;
1968           case aSignKey: set_cmd( &cmd, aSignKey); break;
1969           case aLSignKey: set_cmd( &cmd, aLSignKey); break;
1970           case aStore: set_cmd( &cmd, aStore); break;
1971           case aEditKey: set_cmd( &cmd, aEditKey); greeting=1; break;
1972           case aClearsign: set_cmd( &cmd, aClearsign); break;
1973           case aGenRevoke: set_cmd( &cmd, aGenRevoke); break;
1974           case aDesigRevoke: set_cmd( &cmd, aDesigRevoke); break;
1975           case aPrimegen: set_cmd( &cmd, aPrimegen); break;
1976           case aGenRandom: set_cmd( &cmd, aGenRandom); break;
1977           case aPrintMD: set_cmd( &cmd, aPrintMD); break;
1978           case aPrintMDs: set_cmd( &cmd, aPrintMDs); break;
1979           case aListTrustDB: set_cmd( &cmd, aListTrustDB); break;
1980           case aCheckTrustDB: set_cmd( &cmd, aCheckTrustDB); break;
1981           case aUpdateTrustDB: set_cmd( &cmd, aUpdateTrustDB); break;
1982           case aFixTrustDB: set_cmd( &cmd, aFixTrustDB); break;
1983           case aListTrustPath: set_cmd( &cmd, aListTrustPath); break;
1984           case aDeArmor: set_cmd( &cmd, aDeArmor); break;
1985           case aEnArmor: set_cmd( &cmd, aEnArmor); break;
1986           case aListOwnerTrust:
1987             deprecated_warning(configname,configlineno,
1988                                "--list-ownertrust","--export-ownertrust","");
1989           case aExportOwnerTrust: set_cmd( &cmd, aExportOwnerTrust); break;
1990           case aImportOwnerTrust: set_cmd( &cmd, aImportOwnerTrust); break;
1991           case aRebuildKeydbCaches: set_cmd( &cmd, aRebuildKeydbCaches); break;
1992
1993           case oArmor: opt.armor = 1; opt.no_armor=0; break;
1994           case oOutput: opt.outfile = pargs.r.ret_str; break;
1995           case oMaxOutput: opt.max_output = pargs.r.ret_ulong; break;
1996           case oQuiet: opt.quiet = 1; break;
1997           case oNoTTY: tty_no_terminal(1); break;
1998           case oDryRun: opt.dry_run = 1; break;
1999           case oInteractive: opt.interactive = 1; break;
2000           case oVerbose:
2001             opt.verbose++;
2002             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2003             opt.list_options|=LIST_SHOW_UNUSABLE_UIDS;
2004             opt.list_options|=LIST_SHOW_UNUSABLE_SUBKEYS;
2005             break;
2006           case oKOption: set_cmd( &cmd, aKMode ); break;
2007
2008           case oBatch: opt.batch = 1; nogreeting = 1; break;
2009           case oUseAgent:
2010 #ifndef __riscos__
2011             opt.use_agent = 1;
2012 #else /* __riscos__ */
2013             opt.use_agent = 0;
2014             riscos_not_implemented("use-agent");
2015 #endif /* __riscos__ */
2016             break;
2017           case oNoUseAgent: opt.use_agent = 0; break;
2018           case oGpgAgentInfo: opt.gpg_agent_info = pargs.r.ret_str; break;
2019           case oAnswerYes: opt.answer_yes = 1; break;
2020           case oAnswerNo: opt.answer_no = 1; break;
2021           case oKeyring: append_to_strlist( &nrings, pargs.r.ret_str); break;
2022           case oPrimaryKeyring:
2023             sl=append_to_strlist( &nrings, pargs.r.ret_str);
2024             sl->flags=2;
2025             break;
2026           case oShowKeyring:
2027             deprecated_warning(configname,configlineno,"--show-keyring",
2028                                "--list-options ","show-keyring");
2029             opt.list_options|=LIST_SHOW_KEYRING;
2030             break;
2031
2032           case oDebug: opt.debug |= pargs.r.ret_ulong; break;
2033           case oDebugAll: opt.debug = ~0; break;
2034           case oDebugLevel: debug_level = pargs.r.ret_str; break;
2035
2036           case oStatusFD:
2037             set_status_fd( iobuf_translate_file_handle (pargs.r.ret_int, 1) );
2038             break;
2039           case oStatusFile:
2040             set_status_fd ( open_info_file (pargs.r.ret_str, 1) );
2041             break;
2042           case oAttributeFD:
2043             set_attrib_fd(iobuf_translate_file_handle (pargs.r.ret_int, 1));
2044             break;
2045           case oAttributeFile:
2046             set_attrib_fd ( open_info_file (pargs.r.ret_str, 1) );
2047             break;
2048           case oLoggerFD:
2049             log_set_fd (iobuf_translate_file_handle (pargs.r.ret_int, 1));
2050             break;
2051           case oLoggerFile:
2052             logfile = pargs.r.ret_str;
2053             break;
2054
2055           case oWithFingerprint:
2056             opt.with_fingerprint = 1;
2057             with_fpr=1; /*fall thru*/
2058           case oFingerprint: opt.fingerprint++; break;
2059           case oSecretKeyring:
2060             append_to_strlist( &sec_nrings, pargs.r.ret_str);
2061             break;
2062           case oOptions:
2063             /* config files may not be nested (silently ignore them) */
2064             if( !configfp ) {
2065                 xfree(configname);
2066                 configname = xstrdup(pargs.r.ret_str);
2067                 goto next_pass;
2068             }
2069             break;
2070           case oNoArmor: opt.no_armor=1; opt.armor=0; break;
2071           case oNoDefKeyring: default_keyring = 0; break;
2072           case oNoGreeting: nogreeting = 1; break;
2073           case oNoVerbose: 
2074             opt.verbose = 0;
2075             gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
2076             opt.list_sigs=0;
2077             break;
2078           /* Disabled for now:
2079           case oQuickRandom: quick_random_gen(1); break;*/
2080           case oEmitVersion: opt.no_version=0; break;
2081           case oNoEmitVersion: opt.no_version=1; break;
2082           case oCompletesNeeded: opt.completes_needed = pargs.r.ret_int; break;
2083           case oMarginalsNeeded: opt.marginals_needed = pargs.r.ret_int; break;
2084           case oMaxCertDepth: opt.max_cert_depth = pargs.r.ret_int; break;
2085           case oTrustDBName: trustdb_name = pargs.r.ret_str; break;
2086           case oDefaultKey: opt.def_secret_key = pargs.r.ret_str; break;
2087           case oDefRecipient:
2088                     if( *pargs.r.ret_str )
2089                         opt.def_recipient = make_username(pargs.r.ret_str);
2090                     break;
2091           case oDefRecipientSelf:
2092                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2093                     opt.def_recipient_self = 1;
2094                     break;
2095           case oNoDefRecipient:
2096                     xfree(opt.def_recipient); opt.def_recipient = NULL;
2097                     opt.def_recipient_self = 0;
2098                     break;
2099           case oNoOptions: opt.no_homedir_creation = 1; break; /* no-options */
2100           case oHomedir: break;
2101           case oNoBatch: opt.batch = 0; break;
2102           case oWithKeyData: opt.with_key_data=1; /* fall thru */
2103           case oWithColons: opt.with_colons=':'; break;
2104
2105           case oSkipVerify: opt.skip_verify=1; break;
2106           case oCompressKeys: opt.compress_keys = 1; break;
2107           case aListSecretKeys: set_cmd( &cmd, aListSecretKeys); break;
2108             /* There are many programs (like mutt) that call gpg with
2109                --always-trust so keep this option around for a long
2110                time. */
2111           case oAlwaysTrust: opt.trust_model=TM_ALWAYS; break;
2112           case oTrustModel:
2113             parse_trust_model(pargs.r.ret_str);
2114             break;
2115           case oForceOwnertrust:
2116             log_info(_("NOTE: %s is not for normal use!\n"),
2117                      "--force-ownertrust");
2118             opt.force_ownertrust=string_to_trust_value(pargs.r.ret_str);
2119             if(opt.force_ownertrust==-1)
2120               {
2121                 log_error("invalid ownertrust `%s'\n",pargs.r.ret_str);
2122                 opt.force_ownertrust=0;
2123               }
2124             break;
2125           case oLoadExtension:
2126 #ifndef __riscos__
2127 #if defined(USE_DYNAMIC_LINKING) || defined(_WIN32)
2128             if(check_permissions(pargs.r.ret_str,2))
2129               log_info(_("cipher extension `%s' not loaded due to"
2130                          " unsafe permissions\n"),pargs.r.ret_str);
2131             else
2132               register_cipher_extension(orig_argc? *orig_argv:NULL,
2133                                         pargs.r.ret_str);
2134 #endif
2135 #else /* __riscos__ */
2136             riscos_not_implemented("load-extension");
2137 #endif /* __riscos__ */
2138             break;
2139           case oRFC1991:
2140             opt.compliance = CO_RFC1991;
2141             opt.force_v4_certs = 0;
2142             opt.escape_from = 1;
2143             break;
2144           case oOpenPGP:
2145           case oRFC2440:
2146             /* TODO: When 2440bis becomes a RFC, set new values for
2147                oOpenPGP. */
2148             opt.rfc2440_text=1;
2149             opt.compliance = CO_RFC2440;
2150             opt.allow_non_selfsigned_uid = 1;
2151             opt.allow_freeform_uid = 1;
2152             opt.pgp2_workarounds = 0;
2153             opt.escape_from = 0;
2154             opt.force_v3_sigs = 0;
2155             opt.compress_keys = 0;          /* not mandated, but we do it */
2156             opt.compress_sigs = 0;          /* ditto. */
2157             opt.not_dash_escaped = 0;
2158             opt.def_cipher_algo = 0;
2159             opt.def_digest_algo = 0;
2160             opt.cert_digest_algo = 0;
2161             opt.compress_algo = -1;
2162             opt.s2k_mode = 3; /* iterated+salted */
2163             opt.s2k_digest_algo = DIGEST_ALGO_SHA1;
2164             opt.s2k_cipher_algo = CIPHER_ALGO_3DES;
2165             break;
2166           case oPGP2:  opt.compliance = CO_PGP2;  break;
2167           case oPGP6:  opt.compliance = CO_PGP6;  break;
2168           case oPGP7:  opt.compliance = CO_PGP7;  break;
2169           case oPGP8:  opt.compliance = CO_PGP8;  break;
2170           case oGnuPG: opt.compliance = CO_GNUPG; break;
2171           case oCompressSigs: opt.compress_sigs = 1; break;
2172           case oRFC2440Text: opt.rfc2440_text=1; break;
2173           case oNoRFC2440Text: opt.rfc2440_text=0; break;
2174           case oSetFilename:
2175             if(utf8_strings)
2176               opt.set_filename = pargs.r.ret_str;
2177             else
2178               opt.set_filename = native_to_utf8(pargs.r.ret_str);
2179             break;
2180           case oForYourEyesOnly: eyes_only = 1; break;
2181           case oNoForYourEyesOnly: eyes_only = 0; break;
2182           case oSetPolicyURL:
2183             add_policy_url(pargs.r.ret_str,0);
2184             add_policy_url(pargs.r.ret_str,1);
2185             break;
2186           case oSigPolicyURL: add_policy_url(pargs.r.ret_str,0); break;
2187           case oCertPolicyURL: add_policy_url(pargs.r.ret_str,1); break;
2188           case oShowPolicyURL:
2189             deprecated_warning(configname,configlineno,"--show-policy-url",
2190                                "--list-options ","show-policy-urls");
2191             deprecated_warning(configname,configlineno,"--show-policy-url",
2192                                "--verify-options ","show-policy-urls");
2193             opt.list_options|=LIST_SHOW_POLICY_URLS;
2194             opt.verify_options|=VERIFY_SHOW_POLICY_URLS;
2195             break;
2196           case oNoShowPolicyURL:
2197             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2198                                "--list-options ","no-show-policy-urls");
2199             deprecated_warning(configname,configlineno,"--no-show-policy-url",
2200                                "--verify-options ","no-show-policy-urls");
2201             opt.list_options&=~LIST_SHOW_POLICY_URLS;
2202             opt.verify_options&=~VERIFY_SHOW_POLICY_URLS;
2203             break;
2204           case oSigKeyserverURL: add_keyserver_url(pargs.r.ret_str,0); break;
2205           case oUseEmbeddedFilename:
2206             opt.flags.use_embedded_filename=1;
2207             break;
2208           case oNoUseEmbeddedFilename:
2209             opt.flags.use_embedded_filename=0;
2210             break;
2211           case oComment:
2212             if(pargs.r.ret_str[0])
2213               append_to_strlist(&opt.comments,pargs.r.ret_str);
2214             break;
2215           case oDefaultComment:
2216             deprecated_warning(configname,configlineno,
2217                                "--default-comment","--no-comments","");
2218             /* fall through */
2219           case oNoComments:
2220             free_strlist(opt.comments);
2221             opt.comments=NULL;
2222             break;
2223           case oThrowKeyids: opt.throw_keyid = 1; break;
2224           case oNoThrowKeyids: opt.throw_keyid = 0; break;
2225           case oShowPhotos:
2226             deprecated_warning(configname,configlineno,"--show-photos",
2227                                "--list-options ","show-photos");
2228             deprecated_warning(configname,configlineno,"--show-photos",
2229                                "--verify-options ","show-photos");
2230             opt.list_options|=LIST_SHOW_PHOTOS;
2231             opt.verify_options|=VERIFY_SHOW_PHOTOS;
2232             break;
2233           case oNoShowPhotos:
2234             deprecated_warning(configname,configlineno,"--no-show-photos",
2235                                "--list-options ","no-show-photos");
2236             deprecated_warning(configname,configlineno,"--no-show-photos",
2237                                "--verify-options ","no-show-photos");
2238             opt.list_options&=~LIST_SHOW_PHOTOS;
2239             opt.verify_options&=~VERIFY_SHOW_PHOTOS;
2240             break;
2241           case oPhotoViewer: opt.photo_viewer = pargs.r.ret_str; break;
2242           case oForceV3Sigs: opt.force_v3_sigs = 1; break;
2243           case oNoForceV3Sigs: opt.force_v3_sigs = 0; break;
2244           case oForceV4Certs: opt.force_v4_certs = 1; break;
2245           case oNoForceV4Certs: opt.force_v4_certs = 0; break;
2246           case oForceMDC: opt.force_mdc = 1; break;
2247           case oNoForceMDC: opt.force_mdc = 0; break;
2248           case oDisableMDC: opt.disable_mdc = 1; break;
2249           case oNoDisableMDC: opt.disable_mdc = 0; break;
2250           case oS2KMode:   opt.s2k_mode = pargs.r.ret_int; break;
2251           case oS2KDigest: s2k_digest_string = xstrdup(pargs.r.ret_str); break;
2252           case oS2KCipher: s2k_cipher_string = xstrdup(pargs.r.ret_str); break;
2253           case oSimpleSKChecksum: opt.simple_sk_checksum = 1; break;
2254           case oNoEncryptTo: opt.no_encrypt_to = 1; break;
2255           case oEncryptTo: /* store the recipient in the second list */
2256             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2257             sl->flags = 1;
2258             break;
2259           case oHiddenEncryptTo: /* store the recipient in the second list */
2260             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2261             sl->flags = 1|2;
2262             break;
2263           case oRecipient: /* store the recipient */
2264             add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2265             any_explicit_recipient = 1;
2266             break;
2267           case oHiddenRecipient: /* store the recipient with a flag */
2268             sl = add_to_strlist2( &remusr, pargs.r.ret_str, utf8_strings );
2269             sl->flags = 2;
2270             any_explicit_recipient = 1;
2271             break;
2272           case oTextmodeShort: opt.textmode = 2; break;
2273           case oTextmode: opt.textmode=1;  break;
2274           case oNoTextmode: opt.textmode=0;  break;
2275           case oExpert: opt.expert = 1; break;
2276           case oNoExpert: opt.expert = 0; break;
2277           case oDefSigExpire:
2278             if(*pargs.r.ret_str!='\0')
2279               {
2280                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2281                   log_error(_("`%s' is not a valid signature expiration\n"),
2282                             pargs.r.ret_str);
2283                 else
2284                   opt.def_sig_expire=pargs.r.ret_str;
2285               }
2286             break;
2287           case oAskSigExpire: opt.ask_sig_expire = 1; break;
2288           case oNoAskSigExpire: opt.ask_sig_expire = 0; break;
2289           case oDefCertExpire:
2290             if(*pargs.r.ret_str!='\0')
2291               {
2292                 if(parse_expire_string(pargs.r.ret_str)==(u32)-1)
2293                   log_error(_("`%s' is not a valid signature expiration\n"),
2294                             pargs.r.ret_str);
2295                 else
2296                   opt.def_cert_expire=pargs.r.ret_str;
2297               }
2298             break;
2299           case oAskCertExpire: opt.ask_cert_expire = 1; break;
2300           case oNoAskCertExpire: opt.ask_cert_expire = 0; break;
2301           case oDefCertLevel: opt.def_cert_level=pargs.r.ret_int; break;
2302           case oMinCertLevel: opt.min_cert_level=pargs.r.ret_int; break;
2303           case oAskCertLevel: opt.ask_cert_level = 1; break;
2304           case oNoAskCertLevel: opt.ask_cert_level = 0; break;
2305           case oLocalUser: /* store the local users */
2306             add_to_strlist2( &locusr, pargs.r.ret_str, utf8_strings );
2307             break;
2308           case oCompress:
2309             /* this is the -z command line option */
2310             opt.compress_level = opt.bz2_compress_level = pargs.r.ret_int;
2311             break;
2312           case oCompressLevel: opt.compress_level = pargs.r.ret_int; break;
2313           case oBZ2CompressLevel: opt.bz2_compress_level = pargs.r.ret_int; break;
2314           case oBZ2DecompressLowmem: opt.bz2_decompress_lowmem=1; break;
2315           case oPasswd:
2316             set_passphrase_from_string(pargs.r.ret_str);
2317             break;
2318           case oPasswdFD:
2319             pwfd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2320             opt.use_agent = 0;
2321             break;
2322           case oPasswdFile:
2323             pwfd = open_info_file (pargs.r.ret_str, 0);
2324             break;
2325           case oCommandFD:
2326             opt.command_fd = iobuf_translate_file_handle (pargs.r.ret_int, 0);
2327             break;
2328           case oCommandFile:
2329             opt.command_fd = open_info_file (pargs.r.ret_str, 0);
2330             break;
2331           case oCipherAlgo: 
2332             def_cipher_string = xstrdup(pargs.r.ret_str);
2333             break;
2334           case oDigestAlgo:
2335             def_digest_string = xstrdup(pargs.r.ret_str);
2336             break;
2337           case oCompressAlgo:
2338             /* If it is all digits, stick a Z in front of it for
2339                later.  This is for backwards compatibility with
2340                versions that took the compress algorithm number. */
2341             {
2342               char *pt=pargs.r.ret_str;
2343               while(*pt)
2344                 {
2345                   if (!isascii (*pt) || !isdigit (*pt))
2346                     break;
2347
2348                   pt++;
2349                 }
2350
2351               if(*pt=='\0')
2352                 {
2353                   compress_algo_string=xmalloc(strlen(pargs.r.ret_str)+2);
2354                   strcpy(compress_algo_string,"Z");
2355                   strcat(compress_algo_string,pargs.r.ret_str);
2356                 }
2357               else
2358                 compress_algo_string = xstrdup(pargs.r.ret_str);
2359             }
2360             break;
2361           case oCertDigestAlgo: 
2362             cert_digest_string = xstrdup(pargs.r.ret_str);
2363             break;
2364
2365           case oNoSecmemWarn: 
2366             gcry_control (GCRYCTL_DISABLE_SECMEM_WARN); 
2367             break;
2368
2369           case oRequireSecmem: require_secmem=1; break;
2370           case oNoRequireSecmem: require_secmem=0; break;
2371           case oNoPermissionWarn: opt.no_perm_warn=1; break;
2372           case oNoMDCWarn: opt.no_mdc_warn=1; break;
2373           case oDisplayCharset:
2374             if( set_native_charset( pargs.r.ret_str ) )
2375                 log_error(_("`%s' is not a valid character set\n"),
2376                           pargs.r.ret_str);
2377             break;
2378           case oNotDashEscaped: opt.not_dash_escaped = 1; break;
2379           case oEscapeFrom: opt.escape_from = 1; break;
2380           case oNoEscapeFrom: opt.escape_from = 0; break;
2381           case oLockOnce: opt.lock_once = 1; break;
2382           case oLockNever:
2383             disable_dotlock ();
2384             break;
2385           case oLockMultiple:
2386 #ifndef __riscos__
2387             opt.lock_once = 0;
2388 #else /* __riscos__ */
2389             riscos_not_implemented("lock-multiple");
2390 #endif /* __riscos__ */
2391             break;
2392           case oKeyServer:
2393             {
2394               struct keyserver_spec *keyserver;
2395               keyserver=parse_keyserver_uri(pargs.r.ret_str,0,
2396                                             configname,configlineno);
2397               if(!keyserver)
2398                 log_error(_("could not parse keyserver URL\n"));
2399               else
2400                 {
2401                   keyserver->next=opt.keyserver;
2402                   opt.keyserver=keyserver;
2403                 }
2404             }
2405             break;
2406           case oKeyServerOptions:
2407             if(!parse_keyserver_options(pargs.r.ret_str))
2408               {
2409                 if(configname)
2410                   log_error(_("%s:%d: invalid keyserver options\n"),
2411                             configname,configlineno);
2412                 else
2413                   log_error(_("invalid keyserver options\n"));
2414               }
2415             break;
2416           case oImportOptions:
2417             if(!parse_import_options(pargs.r.ret_str,&opt.import_options,1))
2418               {
2419                 if(configname)
2420                   log_error(_("%s:%d: invalid import options\n"),
2421                             configname,configlineno);
2422                 else
2423                   log_error(_("invalid import options\n"));
2424               }
2425             break;
2426           case oExportOptions:
2427             if(!parse_export_options(pargs.r.ret_str,&opt.export_options,1))
2428               {
2429                 if(configname)
2430                   log_error(_("%s:%d: invalid export options\n"),
2431                             configname,configlineno);
2432                 else
2433                   log_error(_("invalid export options\n"));
2434               }
2435             break;
2436           case oListOptions:
2437             if(!parse_list_options(pargs.r.ret_str))
2438               {
2439                 if(configname)
2440                   log_error(_("%s:%d: invalid list options\n"),
2441                             configname,configlineno);
2442                 else
2443                   log_error(_("invalid list options\n"));
2444               }
2445             break;
2446           case oVerifyOptions:
2447             {
2448               struct parse_options vopts[]=
2449                 {
2450                   {"show-photos",VERIFY_SHOW_PHOTOS,NULL,
2451                    N_("display photo IDs during signature verification")},
2452                   {"show-policy-urls",VERIFY_SHOW_POLICY_URLS,NULL,
2453                    N_("show policy URLs during signature verification")},
2454                   {"show-notations",VERIFY_SHOW_NOTATIONS,NULL,
2455                    N_("show all notations during signature verification")},
2456                   {"show-std-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2457                    N_("show IETF standard notations during signature verification")},
2458                   {"show-standard-notations",VERIFY_SHOW_STD_NOTATIONS,NULL,
2459                    NULL},
2460                   {"show-user-notations",VERIFY_SHOW_USER_NOTATIONS,NULL,
2461                    N_("show user-supplied notations during signature verification")},
2462                   {"show-keyserver-urls",VERIFY_SHOW_KEYSERVER_URLS,NULL,
2463                    N_("show preferred keyserver URLs during signature verification")},
2464                   {"show-uid-validity",VERIFY_SHOW_UID_VALIDITY,NULL,
2465                    N_("show user ID validity during signature verification")},
2466                   {"show-unusable-uids",VERIFY_SHOW_UNUSABLE_UIDS,NULL,
2467                    N_("show revoked and expired user IDs in signature verification")},
2468                   {"pka-lookups",VERIFY_PKA_LOOKUPS,NULL,
2469                    N_("validate signatures with PKA data")},
2470                   {"pka-trust-increase",VERIFY_PKA_TRUST_INCREASE,NULL,
2471                    N_("elevate the trust of signatures with valid PKA data")},
2472                   {NULL,0,NULL,NULL}
2473                 };
2474
2475               if(!parse_options(pargs.r.ret_str,&opt.verify_options,vopts,1))
2476                 {
2477                   if(configname)
2478                     log_error(_("%s:%d: invalid verify options\n"),
2479                               configname,configlineno);
2480                   else
2481                     log_error(_("invalid verify options\n"));
2482                 }
2483             }
2484             break;
2485           case oTempDir: opt.temp_dir=pargs.r.ret_str; break;
2486           case oExecPath:
2487             if(set_exec_path(pargs.r.ret_str))
2488               log_error(_("unable to set exec-path to %s\n"),pargs.r.ret_str);
2489             else
2490               opt.exec_path_set=1;
2491             break;
2492           case oSetNotation:
2493             add_notation_data( pargs.r.ret_str, 0 );
2494             add_notation_data( pargs.r.ret_str, 1 );
2495             break;
2496           case oSigNotation: add_notation_data( pargs.r.ret_str, 0 ); break;
2497           case oCertNotation: add_notation_data( pargs.r.ret_str, 1 ); break;
2498           case oShowNotation:
2499             deprecated_warning(configname,configlineno,"--show-notation",
2500                                "--list-options ","show-notations");
2501             deprecated_warning(configname,configlineno,"--show-notation",
2502                                "--verify-options ","show-notations");
2503             opt.list_options|=LIST_SHOW_NOTATIONS;
2504             opt.verify_options|=VERIFY_SHOW_NOTATIONS;
2505             break;
2506           case oNoShowNotation:
2507             deprecated_warning(configname,configlineno,"--no-show-notation",
2508                                "--list-options ","no-show-notations");
2509             deprecated_warning(configname,configlineno,"--no-show-notation",
2510                                "--verify-options ","no-show-notations");
2511             opt.list_options&=~LIST_SHOW_NOTATIONS;
2512             opt.verify_options&=~VERIFY_SHOW_NOTATIONS;
2513             break;
2514           case oUtf8Strings: utf8_strings = 1; break;
2515           case oNoUtf8Strings: utf8_strings = 0; break;
2516           case oDisableCipherAlgo:
2517             {
2518               int algo = string_to_cipher_algo (pargs.r.ret_str);
2519               gcry_cipher_ctl (NULL, GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2520             }
2521             break;
2522           case oDisablePubkeyAlgo:
2523             {
2524               int algo = gcry_pk_map_name (pargs.r.ret_str);
2525               gcry_pk_ctl (GCRYCTL_DISABLE_ALGO, &algo, sizeof algo);
2526             }
2527             break;
2528           case oNoSigCache: opt.no_sig_cache = 1; break;
2529           case oNoSigCreateCheck: opt.no_sig_create_check = 1; break;
2530           case oAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid = 1; break;
2531           case oNoAllowNonSelfsignedUID: opt.allow_non_selfsigned_uid=0; break;
2532           case oAllowFreeformUID: opt.allow_freeform_uid = 1; break;
2533           case oNoAllowFreeformUID: opt.allow_freeform_uid = 0; break;
2534           case oNoLiteral: opt.no_literal = 1; break;
2535           case oSetFilesize: opt.set_filesize = pargs.r.ret_ulong; break;
2536           case oHonorHttpProxy:
2537                 add_to_strlist(&opt.keyserver_options.other,"http-proxy");
2538                 deprecated_warning(configname,configlineno,
2539                                    "--honor-http-proxy",
2540                                    "--keyserver-options ","http-proxy");
2541                 break;
2542           case oFastListMode: opt.fast_list_mode = 1; break;
2543           case oFixedListMode: opt.fixed_list_mode = 1; break;
2544           case oListOnly: opt.list_only=1; break;
2545           case oIgnoreTimeConflict: opt.ignore_time_conflict = 1; break;
2546           case oIgnoreValidFrom: opt.ignore_valid_from = 1; break;
2547           case oIgnoreCrcError: opt.ignore_crc_error = 1; break;
2548           case oIgnoreMDCError: opt.ignore_mdc_error = 1; break;
2549           case oNoRandomSeedFile: use_random_seed = 0; break;
2550           case oAutoKeyRetrieve:
2551           case oNoAutoKeyRetrieve:
2552                 if(pargs.r_opt==oAutoKeyRetrieve)
2553                   opt.keyserver_options.options|=KEYSERVER_AUTO_KEY_RETRIEVE;
2554                 else
2555                   opt.keyserver_options.options&=~KEYSERVER_AUTO_KEY_RETRIEVE;
2556
2557                 deprecated_warning(configname,configlineno,
2558                            pargs.r_opt==oAutoKeyRetrieve?"--auto-key-retrieve":
2559                                "--no-auto-key-retrieve","--keyserver-options ",
2560                            pargs.r_opt==oAutoKeyRetrieve?"auto-key-retrieve":
2561                                "no-auto-key-retrieve");
2562                 break;
2563           case oShowSessionKey: opt.show_session_key = 1; break;
2564           case oOverrideSessionKey:
2565                 opt.override_session_key = pargs.r.ret_str;
2566                 break;
2567           case oMergeOnly:
2568                 deprecated_warning(configname,configlineno,"--merge-only",
2569                                    "--import-options ","merge-only");
2570                 opt.import_options|=IMPORT_MERGE_ONLY;
2571             break;
2572           case oAllowSecretKeyImport: /* obsolete */ break;
2573           case oTryAllSecrets: opt.try_all_secrets = 1; break;
2574           case oTrustedKey: register_trusted_key( pargs.r.ret_str ); break;
2575           case oEnableSpecialFilenames:
2576             iobuf_enable_special_filenames (1);
2577             break;
2578           case oNoExpensiveTrustChecks: opt.no_expensive_trust_checks=1; break;
2579           case oAutoCheckTrustDB: opt.no_auto_check_trustdb=0; break;
2580           case oNoAutoCheckTrustDB: opt.no_auto_check_trustdb=1; break;
2581           case oPreservePermissions: opt.preserve_permissions=1; break;
2582           case oDefaultPreferenceList:
2583             opt.def_preference_list = pargs.r.ret_str;
2584             break;
2585           case oPersonalCipherPreferences:
2586             pers_cipher_list=pargs.r.ret_str;
2587             break;
2588           case oPersonalDigestPreferences:
2589             pers_digest_list=pargs.r.ret_str;
2590             break;
2591           case oPersonalCompressPreferences:
2592             pers_compress_list=pargs.r.ret_str;
2593             break;
2594           case oAgentProgram: opt.agent_program = pargs.r.ret_str;  break;
2595           case oDisplay: opt.display = pargs.r.ret_str; break;
2596           case oTTYname: opt.ttyname = pargs.r.ret_str; break;
2597           case oTTYtype: opt.ttytype = pargs.r.ret_str; break;
2598           case oLCctype: opt.lc_ctype = pargs.r.ret_str; break;
2599           case oLCmessages: opt.lc_messages = pargs.r.ret_str; break;
2600           case oGroup: add_group(pargs.r.ret_str); break;
2601           case oUnGroup: rm_group(pargs.r.ret_str); break;
2602           case oNoGroups:
2603             while(opt.grouplist)
2604               {
2605                 struct groupitem *iter=opt.grouplist;
2606                 free_strlist(iter->values);
2607                 opt.grouplist=opt.grouplist->next;
2608                 xfree(iter);
2609               }
2610             break;
2611
2612           case oStrict: 
2613           case oNoStrict: 
2614             /* Not used */
2615             break;
2616
2617           case oMangleDosFilenames: opt.mangle_dos_filenames = 1; break;
2618           case oNoMangleDosFilenames: opt.mangle_dos_filenames = 0; break;
2619           case oEnableProgressFilter: opt.enable_progress_filter = 1; break;
2620           case oMultifile: multifile=1; break;
2621           case oKeyidFormat:
2622             if(ascii_strcasecmp(pargs.r.ret_str,"short")==0)
2623               opt.keyid_format=KF_SHORT;
2624             else if(ascii_strcasecmp(pargs.r.ret_str,"long")==0)
2625               opt.keyid_format=KF_LONG;
2626             else if(ascii_strcasecmp(pargs.r.ret_str,"0xshort")==0)
2627               opt.keyid_format=KF_0xSHORT;
2628             else if(ascii_strcasecmp(pargs.r.ret_str,"0xlong")==0)
2629               opt.keyid_format=KF_0xLONG;
2630             else
2631               log_error("unknown keyid-format `%s'\n",pargs.r.ret_str);
2632             break;
2633
2634           case oExitOnStatusWriteError:
2635             opt.exit_on_status_write_error = 1;
2636             break;
2637
2638           case oLimitCardInsertTries: 
2639             opt.limit_card_insert_tries = pargs.r.ret_int; 
2640             break;
2641
2642           case oRequireCrossCert: opt.flags.require_cross_cert=1; break;
2643           case oNoRequireCrossCert: opt.flags.require_cross_cert=0; break;
2644
2645           case oAutoKeyLocate:
2646             if(!parse_auto_key_locate(pargs.r.ret_str))
2647               {
2648                 if(configname)
2649                   log_error(_("%s:%d: invalid auto-key-locate list\n"),
2650                             configname,configlineno);
2651                 else
2652                   log_error(_("invalid auto-key-locate list\n"));
2653               }
2654             break;
2655           case oNoAutoKeyLocate:
2656             release_akl();
2657             break;
2658
2659           case oAllowMultisigVerification:
2660             opt.allow_multisig_verification = 1;
2661             break;
2662
2663           case oEnableDSA2: opt.flags.dsa2=1; break;
2664           case oDisableDSA2: opt.flags.dsa2=0; break;
2665
2666           case oNoop: break;
2667
2668           default : pargs.err = configfp? 1:2; break;
2669           }
2670       }
2671
2672
2673     if( configfp ) {
2674         fclose( configfp );
2675         configfp = NULL;
2676         /* Remember the first config file name. */
2677         if (!save_configname)
2678           save_configname = configname;
2679         else
2680           xfree(configname);
2681         configname = NULL;
2682         goto next_pass;
2683     }
2684     xfree( configname ); configname = NULL;
2685     if( log_get_errorcount(0) )
2686         g10_exit(2);
2687
2688     /* The command --gpgconf-list is pretty simple and may be called
2689        directly after the option parsing. */
2690     if (cmd == aGPGConfList)
2691       {
2692         gpgconf_list (save_configname);
2693         g10_exit (0);
2694       }
2695     xfree (save_configname);
2696
2697     if( nogreeting )
2698         greeting = 0;
2699
2700     if( greeting ) {
2701         fprintf(stderr, "%s %s; %s\n",
2702                         strusage(11), strusage(13), strusage(14) );
2703         fprintf(stderr, "%s\n", strusage(15) );
2704     }
2705 #ifdef IS_DEVELOPMENT_VERSION
2706     if( !opt.batch )
2707       {
2708         const char *s;
2709
2710         if((s=strusage(20)))
2711           log_info("%s\n",s);
2712         if((s=strusage(21)))
2713           log_info("%s\n",s);
2714         if((s=strusage(22)))
2715           log_info("%s\n",s);
2716       }
2717 #endif
2718
2719     /* FIXME: We should use logging to a file only in server mode;
2720        however we have not yet implemetyed that.  Thus we try to get
2721        away with --batch as indication for logging to file
2722        required. */
2723     if (logfile && opt.batch)
2724       {
2725         log_set_file (logfile);
2726         log_set_prefix (NULL, 1|2|4);
2727       }
2728
2729     if (opt.verbose > 2)
2730         log_info ("using character set `%s'\n", get_native_charset ());
2731
2732     if( may_coredump && !opt.quiet )
2733         log_info(_("WARNING: program may create a core file!\n"));
2734
2735     if (eyes_only) {
2736       if (opt.set_filename)
2737           log_info(_("WARNING: %s overrides %s\n"),
2738                    "--for-your-eyes-only","--set-filename");
2739
2740       opt.set_filename="_CONSOLE";
2741     }
2742
2743     if (opt.no_literal) {
2744         log_info(_("NOTE: %s is not for normal use!\n"), "--no-literal");
2745         if (opt.textmode)
2746             log_error(_("%s not allowed with %s!\n"),
2747                        "--textmode", "--no-literal" );
2748         if (opt.set_filename)
2749             log_error(_("%s makes no sense with %s!\n"),
2750                         eyes_only?"--for-your-eyes-only":"--set-filename",
2751                         "--no-literal" );
2752     }
2753
2754
2755     if (opt.set_filesize)
2756         log_info(_("NOTE: %s is not for normal use!\n"), "--set-filesize");
2757     if( opt.batch )
2758         tty_batchmode( 1 );
2759
2760     gcry_control (GCRYCTL_RESUME_SECMEM_WARN);
2761
2762     if(require_secmem && !got_secmem)
2763       {
2764         log_info(_("will not run with insecure memory due to %s\n"),
2765                  "--require-secmem");
2766         g10_exit(2);
2767       }
2768
2769     set_debug (debug_level);
2770
2771     /* Do these after the switch(), so they can override settings. */
2772     if(PGP2)
2773       {
2774         int unusable=0;
2775
2776         if(cmd==aSign && !detached_sig)
2777           {
2778             log_info(_("you can only make detached or clear signatures "
2779                        "while in --pgp2 mode\n"));
2780             unusable=1;
2781           }
2782         else if(cmd==aSignEncr || cmd==aSignSym)
2783           {
2784             log_info(_("you can't sign and encrypt at the "
2785                        "same time while in --pgp2 mode\n"));
2786             unusable=1;
2787           }
2788         else if(argc==0 && (cmd==aSign || cmd==aEncr || cmd==aSym))
2789           {
2790             log_info(_("you must use files (and not a pipe) when "
2791                        "working with --pgp2 enabled.\n"));
2792             unusable=1;
2793           }
2794         else if(cmd==aEncr || cmd==aSym)
2795           {
2796             /* Everything else should work without IDEA (except using
2797                a secret key encrypted with IDEA and setting an IDEA
2798                preference, but those have their own error
2799                messages). */
2800
2801             if (openpgp_cipher_test_algo(CIPHER_ALGO_IDEA))
2802               {
2803                 log_info(_("encrypting a message in --pgp2 mode requires "
2804                            "the IDEA cipher\n"));
2805                 idea_cipher_warn(1);
2806                 unusable=1;
2807               }
2808             else if(cmd==aSym)
2809               {
2810                 /* This only sets IDEA for symmetric encryption
2811                    since it is set via select_algo_from_prefs for
2812                    pk encryption. */
2813                 xfree(def_cipher_string);
2814                 def_cipher_string = xstrdup("idea");
2815               }
2816
2817             /* PGP2 can't handle the output from the textmode
2818                filter, so we disable it for anything that could
2819                create a literal packet (only encryption and
2820                symmetric encryption, since we disable signing
2821                above). */
2822             if(!unusable)
2823               opt.textmode=0;
2824           }
2825
2826         if(unusable)
2827           compliance_failure();
2828         else
2829           {
2830             opt.force_v4_certs = 0;
2831             opt.escape_from = 1;
2832             opt.force_v3_sigs = 1;
2833             opt.pgp2_workarounds = 1;
2834             opt.ask_sig_expire = 0;
2835             opt.ask_cert_expire = 0;
2836             xfree(def_digest_string);
2837             def_digest_string = xstrdup("md5");
2838             xfree(s2k_digest_string);
2839             s2k_digest_string = xstrdup("md5");
2840             opt.compress_algo = COMPRESS_ALGO_ZIP;
2841           }
2842       }
2843     else if(PGP6)
2844       {
2845         opt.escape_from=1;
2846         opt.force_v3_sigs=1;
2847         opt.ask_sig_expire=0;
2848       }
2849     else if(PGP7)
2850       {
2851         opt.escape_from=1;
2852         opt.force_v3_sigs=1;
2853         opt.ask_sig_expire=0;
2854       }
2855     else if(PGP8)
2856       {
2857         opt.escape_from=1;
2858       }
2859
2860
2861     if( def_cipher_string ) {
2862         opt.def_cipher_algo = string_to_cipher_algo (def_cipher_string);
2863         if(opt.def_cipher_algo==0 &&
2864            (ascii_strcasecmp(def_cipher_string,"idea")==0
2865             || ascii_strcasecmp(def_cipher_string,"s1")==0))
2866           idea_cipher_warn(1);
2867         xfree(def_cipher_string); def_cipher_string = NULL;
2868         if ( openpgp_cipher_test_algo (opt.def_cipher_algo) )
2869             log_error(_("selected cipher algorithm is invalid\n"));
2870     }
2871     if( def_digest_string ) {
2872         opt.def_digest_algo = string_to_digest_algo (def_digest_string);
2873         xfree(def_digest_string); def_digest_string = NULL;
2874         if ( openpgp_md_test_algo (opt.def_digest_algo) )
2875             log_error(_("selected digest algorithm is invalid\n"));
2876     }
2877     if( compress_algo_string ) {
2878         opt.compress_algo = string_to_compress_algo(compress_algo_string);
2879         xfree(compress_algo_string); compress_algo_string = NULL;
2880         if( check_compress_algo(opt.compress_algo) )
2881           log_error(_("selected compression algorithm is invalid\n"));
2882     }
2883     if( cert_digest_string ) {
2884         opt.cert_digest_algo = string_to_digest_algo (cert_digest_string);
2885         xfree(cert_digest_string); cert_digest_string = NULL;
2886         if (openpgp_md_test_algo(opt.cert_digest_algo))
2887           log_error(_("selected certification digest algorithm is invalid\n"));
2888     }
2889     if( s2k_cipher_string ) {
2890         opt.s2k_cipher_algo = string_to_cipher_algo (s2k_cipher_string);
2891         xfree(s2k_cipher_string); s2k_cipher_string = NULL;
2892         if (openpgp_cipher_test_algo (opt.s2k_cipher_algo))
2893           log_error(_("selected cipher algorithm is invalid\n"));
2894     }
2895     if( s2k_digest_string ) {
2896         opt.s2k_digest_algo = string_to_digest_algo (s2k_digest_string);
2897         xfree(s2k_digest_string); s2k_digest_string = NULL;
2898         if (openpgp_md_test_algo(opt.s2k_digest_algo))
2899           log_error(_("selected digest algorithm is invalid\n"));
2900     }
2901     if( opt.completes_needed < 1 )
2902       log_error(_("completes-needed must be greater than 0\n"));
2903     if( opt.marginals_needed < 2 )
2904       log_error(_("marginals-needed must be greater than 1\n"));
2905     if( opt.max_cert_depth < 1 || opt.max_cert_depth > 255 )
2906       log_error(_("max-cert-depth must be in the range from 1 to 255\n"));
2907     if(opt.def_cert_level<0 || opt.def_cert_level>3)
2908       log_error(_("invalid default-cert-level; must be 0, 1, 2, or 3\n"));
2909     if( opt.min_cert_level < 1 || opt.min_cert_level > 3 )
2910       log_error(_("invalid min-cert-level; must be 1, 2, or 3\n"));
2911     switch( opt.s2k_mode ) {
2912       case 0:
2913         log_info(_("NOTE: simple S2K mode (0) is strongly discouraged\n"));
2914         break;
2915       case 1: case 3: break;
2916       default:
2917         log_error(_("invalid S2K mode; must be 0, 1 or 3\n"));
2918     }
2919
2920     /* This isn't actually needed, but does serve to error out if the
2921        string is invalid. */
2922     if(opt.def_preference_list &&
2923         keygen_set_std_prefs(opt.def_preference_list,0))
2924       log_error(_("invalid default preferences\n"));
2925
2926     /* We provide defaults for the personal digest list.  This is
2927        SHA-1. */
2928     if(!pers_digest_list)
2929       pers_digest_list="h2";
2930
2931     if(pers_cipher_list &&
2932        keygen_set_std_prefs(pers_cipher_list,PREFTYPE_SYM))
2933       log_error(_("invalid personal cipher preferences\n"));
2934
2935     if(pers_digest_list &&
2936        keygen_set_std_prefs(pers_digest_list,PREFTYPE_HASH))
2937       log_error(_("invalid personal digest preferences\n"));
2938
2939     if(pers_compress_list &&
2940        keygen_set_std_prefs(pers_compress_list,PREFTYPE_ZIP))
2941       log_error(_("invalid personal compress preferences\n"));
2942
2943     /* We don't support all possible commands with multifile yet */
2944     if(multifile)
2945       {
2946         char *cmdname;
2947
2948         switch(cmd)
2949           {
2950           case aSign:
2951             cmdname="--sign";
2952             break;
2953           case aClearsign:
2954             cmdname="--clearsign";
2955             break;
2956           case aDetachedSign:
2957             cmdname="--detach-sign";
2958             break;
2959           case aSym:
2960             cmdname="--symmetric";
2961             break;
2962           case aEncrSym:
2963             cmdname="--symmetric --encrypt";
2964             break;
2965           case aStore:
2966             cmdname="--store";
2967             break;
2968           default:
2969             cmdname=NULL;
2970             break;
2971           }
2972
2973         if(cmdname)
2974           log_error(_("%s does not yet work with %s\n"),cmdname,"--multifile");
2975       }
2976
2977     if( log_get_errorcount(0) )
2978         g10_exit(2);
2979
2980     if(opt.compress_level==0)
2981       opt.compress_algo=COMPRESS_ALGO_NONE;
2982
2983     /* Check our chosen algorithms against the list of legal
2984        algorithms. */
2985
2986     if(!GNUPG)
2987       {
2988         const char *badalg=NULL;
2989         preftype_t badtype=PREFTYPE_NONE;
2990
2991         if(opt.def_cipher_algo
2992            && !algo_available(PREFTYPE_SYM,opt.def_cipher_algo,NULL))
2993           {
2994             badalg = gcry_cipher_algo_name (opt.def_cipher_algo);
2995             badtype = PREFTYPE_SYM;
2996           }
2997         else if(opt.def_digest_algo
2998                 && !algo_available(PREFTYPE_HASH,opt.def_digest_algo,NULL))
2999           {
3000             badalg = gcry_md_algo_name (opt.def_digest_algo);
3001             badtype = PREFTYPE_HASH;
3002           }
3003         else if(opt.cert_digest_algo
3004                 && !algo_available(PREFTYPE_HASH,opt.cert_digest_algo,NULL))
3005           {
3006             badalg = gcry_md_algo_name (opt.cert_digest_algo);
3007             badtype = PREFTYPE_HASH;
3008           }
3009         else if(opt.compress_algo!=-1
3010                 && !algo_available(PREFTYPE_ZIP,opt.compress_algo,NULL))
3011           {
3012             badalg = compress_algo_to_string(opt.compress_algo);
3013             badtype = PREFTYPE_ZIP;
3014           }
3015
3016         if(badalg)
3017           {
3018             switch(badtype)
3019               {
3020               case PREFTYPE_SYM:
3021                 log_info(_("you may not use cipher algorithm `%s'"
3022                            " while in %s mode\n"),
3023                          badalg,compliance_option_string());
3024                 break;
3025               case PREFTYPE_HASH:
3026                 log_info(_("you may not use digest algorithm `%s'"
3027                            " while in %s mode\n"),
3028                          badalg,compliance_option_string());
3029                 break;
3030               case PREFTYPE_ZIP:
3031                 log_info(_("you may not use compression algorithm `%s'"
3032                            " while in %s mode\n"),
3033                          badalg,compliance_option_string());
3034                 break;
3035               default:
3036                 BUG();
3037               }
3038
3039             compliance_failure();
3040           }
3041       }
3042
3043     /* Set the random seed file. */
3044     if( use_random_seed ) {
3045         char *p = make_filename(opt.homedir, "random_seed", NULL );
3046         gcry_control (GCRYCTL_SET_RANDOM_SEED_FILE, p);
3047         if (!access (p, F_OK))
3048           register_secured_file (p);
3049         xfree(p);
3050     }
3051
3052     if( !cmd && opt.fingerprint && !with_fpr ) {
3053         set_cmd( &cmd, aListKeys);
3054     }
3055
3056     if( cmd == aKMode || cmd == aKModeC ) { /* kludge to be compatible to pgp */
3057         if( cmd == aKModeC ) {
3058             opt.fingerprint = 1;
3059             cmd = aKMode;
3060         }
3061         opt.list_sigs = 0;
3062         if( opt.verbose > 2 )
3063             opt.check_sigs++;
3064         if( opt.verbose > 1 )
3065             opt.list_sigs++;
3066
3067         opt.verbose = opt.verbose > 1;
3068     }
3069
3070     /* kludge to let -sat generate a clear text signature */
3071     if( opt.textmode == 2 && !detached_sig && opt.armor && cmd == aSign )
3072         cmd = aClearsign;
3073
3074     if( opt.verbose > 1 )
3075         set_packet_list_mode(1);
3076
3077     /* Add the keyrings, but not for some special commands and not in
3078        case of "-kvv userid keyring".  Also avoid adding the secret
3079        keyring for a couple of commands to avoid unneeded access in
3080        case the secrings are stored on a floppy.
3081        
3082        We always need to add the keyrings if we are running under
3083        SELinux, this is so that the rings are added to the list of
3084        secured files. */
3085     if( ALWAYS_ADD_KEYRINGS 
3086         || (cmd != aDeArmor && cmd != aEnArmor
3087             && !(cmd == aKMode && argc == 2 )) ) 
3088       {
3089         if (ALWAYS_ADD_KEYRINGS
3090             || (cmd != aCheckKeys && cmd != aListSigs && cmd != aListKeys
3091                 && cmd != aVerify && cmd != aSym))
3092           {
3093             if (!sec_nrings || default_keyring) /* add default secret rings */
3094               keydb_add_resource ("secring" EXTSEP_S "gpg", 4, 1);
3095             for (sl = sec_nrings; sl; sl = sl->next)
3096               keydb_add_resource ( sl->d, 0, 1 );
3097           }
3098         if( !nrings || default_keyring )  /* add default ring */
3099             keydb_add_resource ("pubring" EXTSEP_S "gpg", 4, 0);
3100         for(sl = nrings; sl; sl = sl->next )
3101             keydb_add_resource ( sl->d, sl->flags, 0 );
3102       }
3103     FREE_STRLIST(nrings);
3104     FREE_STRLIST(sec_nrings);
3105
3106
3107     if( pwfd != -1 )  /* read the passphrase now. */
3108         read_passphrase_from_fd( pwfd );
3109
3110     fname = argc? *argv : NULL;
3111
3112     if(fname && utf8_strings)
3113       opt.flags.utf8_filename=1;
3114
3115     switch( cmd ) {
3116       case aPrimegen:
3117       case aPrintMD:
3118       case aPrintMDs:
3119       case aGenRandom:
3120       case aDeArmor:
3121       case aEnArmor:
3122       case aFixTrustDB:
3123         break;
3124       case aExportOwnerTrust: rc = setup_trustdb( 0, trustdb_name ); break;
3125       case aListTrustDB: rc = setup_trustdb( argc? 1:0, trustdb_name ); break;
3126       default: rc = setup_trustdb(1, trustdb_name ); break;
3127     }
3128     if( rc )
3129         log_error(_("failed to initialize the TrustDB: %s\n"), g10_errstr(rc));
3130
3131
3132     switch (cmd)
3133       {
3134       case aStore: 
3135       case aSym:  
3136       case aSign: 
3137       case aSignSym: 
3138       case aClearsign: 
3139         if (!opt.quiet && any_explicit_recipient)
3140           log_info (_("WARNING: recipients (-r) given "
3141                       "without using public key encryption\n"));
3142         break;
3143       default:
3144         break;
3145       }
3146
3147     switch( cmd )
3148       {
3149       case aStore: /* only store the file */
3150         if( argc > 1 )
3151             wrong_args(_("--store [filename]"));
3152         if( (rc = encode_store(fname)) )
3153             log_error ("storing `%s' failed: %s\n",
3154                        print_fname_stdin(fname),g10_errstr(rc) );
3155         break;
3156       case aSym: /* encrypt the given file only with the symmetric cipher */
3157         if( argc > 1 )
3158             wrong_args(_("--symmetric [filename]"));
3159         if( (rc = encode_symmetric(fname)) )
3160             log_error (_("symmetric encryption of `%s' failed: %s\n"),
3161                         print_fname_stdin(fname),g10_errstr(rc) );
3162         break;
3163
3164       case aEncr: /* encrypt the given file */
3165         if(multifile)
3166           encode_crypt_files(argc, argv, remusr);
3167         else
3168           {
3169             if( argc > 1 )
3170               wrong_args(_("--encrypt [filename]"));
3171             if( (rc = encode_crypt(fname,remusr,0)) )
3172               log_error("%s: encryption failed: %s\n",
3173                         print_fname_stdin(fname), g10_errstr(rc) );
3174           }
3175         break;
3176
3177       case aEncrSym:
3178         /* This works with PGP 8 in the sense that it acts just like a
3179            symmetric message.  It doesn't work at all with 2 or 6.  It
3180            might work with 7, but alas, I don't have a copy to test
3181            with right now. */
3182         if( argc > 1 )
3183           wrong_args(_("--symmetric --encrypt [filename]"));
3184         else if(opt.s2k_mode==0)
3185           log_error(_("you cannot use --symmetric --encrypt"
3186                       " with --s2k-mode 0\n"));
3187         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3188           log_error(_("you cannot use --symmetric --encrypt"
3189                       " while in %s mode\n"),compliance_option_string());
3190         else
3191           {
3192             if( (rc = encode_crypt(fname,remusr,1)) )
3193               log_error("%s: encryption failed: %s\n",
3194                         print_fname_stdin(fname), g10_errstr(rc) );
3195           }
3196         break;
3197
3198       case aSign: /* sign the given file */
3199         sl = NULL;
3200         if( detached_sig ) { /* sign all files */
3201             for( ; argc; argc--, argv++ )
3202                 add_to_strlist( &sl, *argv );
3203         }
3204         else {
3205             if( argc > 1 )
3206                 wrong_args(_("--sign [filename]"));
3207             if( argc ) {
3208                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3209                 strcpy(sl->d, fname);
3210             }
3211         }
3212         if( (rc = sign_file( sl, detached_sig, locusr, 0, NULL, NULL)) )
3213             log_error("signing failed: %s\n", g10_errstr(rc) );
3214         free_strlist(sl);
3215         break;
3216
3217       case aSignEncr: /* sign and encrypt the given file */
3218         if( argc > 1 )
3219             wrong_args(_("--sign --encrypt [filename]"));
3220         if( argc ) {
3221             sl = xmalloc_clear( sizeof *sl + strlen(fname));
3222             strcpy(sl->d, fname);
3223         }
3224         else
3225             sl = NULL;
3226         if( (rc = sign_file(sl, detached_sig, locusr, 1, remusr, NULL)) )
3227             log_error("%s: sign+encrypt failed: %s\n",
3228                       print_fname_stdin(fname), g10_errstr(rc) );
3229         free_strlist(sl);
3230         break;
3231
3232       case aSignEncrSym: /* sign and encrypt the given file */
3233         if( argc > 1 )
3234             wrong_args(_("--symmetric --sign --encrypt [filename]"));
3235         else if(opt.s2k_mode==0)
3236           log_error(_("you cannot use --symmetric --sign --encrypt"
3237                       " with --s2k-mode 0\n"));
3238         else if(PGP2 || PGP6 || PGP7 || RFC1991)
3239           log_error(_("you cannot use --symmetric --sign --encrypt"
3240                       " while in %s mode\n"),compliance_option_string());
3241         else
3242           {
3243             if( argc )
3244               {
3245                 sl = xmalloc_clear( sizeof *sl + strlen(fname));
3246                 strcpy(sl->d, fname);
3247               }
3248             else
3249               sl = NULL;
3250             if( (rc = sign_file(sl, detached_sig, locusr, 2, remusr, NULL)) )
3251               log_error("%s: symmetric+sign+encrypt failed: %s\n",
3252                         print_fname_stdin(fname), g10_errstr(rc) );
3253             free_strlist(sl);
3254           }
3255         break;
3256
3257       case aSignSym: /* sign and conventionally encrypt the given file */
3258         if (argc > 1)
3259             wrong_args(_("--sign --symmetric [filename]"));
3260         rc = sign_symencrypt_file (fname, locusr);
3261         if (rc)
3262             log_error("%s: sign+symmetric failed: %s\n",
3263                       print_fname_stdin(fname), g10_errstr(rc) );
3264         break;
3265
3266       case aClearsign: /* make a clearsig */
3267         if( argc > 1 )
3268             wrong_args(_("--clearsign [filename]"));
3269         if( (rc = clearsign_file(fname, locusr, NULL)) )
3270             log_error("%s: clearsign failed: %s\n",
3271                       print_fname_stdin(fname), g10_errstr(rc) );
3272         break;
3273
3274       case aVerify:
3275         if(multifile)
3276           {
3277             if( (rc = verify_files( argc, argv ) ))
3278               log_error("verify files failed: %s\n", g10_errstr(rc) );
3279           }
3280         else
3281           {
3282             if( (rc = verify_signatures( argc, argv ) ))
3283               log_error("verify signatures failed: %s\n", g10_errstr(rc) );
3284           }
3285         break;
3286
3287       case aDecrypt:
3288         if(multifile)
3289           decrypt_messages(argc, argv);
3290         else
3291           {
3292             if( argc > 1 )
3293               wrong_args(_("--decrypt [filename]"));
3294             if( (rc = decrypt_message( fname ) ))
3295               log_error("decrypt_message failed: %s\n", g10_errstr(rc) );
3296           }
3297         break;
3298             
3299       case aSignKey:
3300         if( argc != 1 )
3301           wrong_args(_("--sign-key user-id"));
3302         /* fall through */
3303       case aLSignKey:
3304         if( argc != 1 )
3305           wrong_args(_("--lsign-key user-id"));
3306         /* fall through */
3307
3308         sl=NULL;
3309
3310         if(cmd==aSignKey)
3311           append_to_strlist(&sl,"sign");
3312         else if(cmd==aLSignKey)
3313           append_to_strlist(&sl,"lsign");
3314         else
3315           BUG();
3316
3317         append_to_strlist( &sl, "save" );
3318         username = make_username( fname );
3319         keyedit_menu(fname, locusr, sl, 0, 0 );
3320         xfree(username);
3321         free_strlist(sl);
3322         break;
3323
3324       case aEditKey: /* Edit a key signature */
3325         if( !argc )
3326             wrong_args(_("--edit-key user-id [commands]"));
3327         username = make_username( fname );
3328         if( argc > 1 ) {
3329             sl = NULL;
3330             for( argc--, argv++ ; argc; argc--, argv++ )
3331                 append_to_strlist( &sl, *argv );
3332             keyedit_menu( username, locusr, sl, 0, 1 );
3333             free_strlist(sl);
3334         }
3335         else
3336             keyedit_menu(username, locusr, NULL, 0, 1 );
3337         xfree(username);
3338         break;
3339
3340       case aDeleteKeys:
3341       case aDeleteSecretKeys:
3342       case aDeleteSecretAndPublicKeys:
3343         sl = NULL;
3344         /* I'm adding these in reverse order as add_to_strlist2
3345            reverses them again, and it's easier to understand in the
3346            proper order :) */
3347         for( ; argc; argc-- )
3348           add_to_strlist2( &sl, argv[argc-1], utf8_strings );
3349         delete_keys(sl,cmd==aDeleteSecretKeys,cmd==aDeleteSecretAndPublicKeys);
3350         free_strlist(sl);
3351         break;
3352
3353       case aCheckKeys:
3354         opt.check_sigs = 1;
3355       case aListSigs:
3356         opt.list_sigs = 1;
3357       case aListKeys:
3358         sl = NULL;
3359         for( ; argc; argc--, argv++ )
3360             add_to_strlist2( &sl, *argv, utf8_strings );
3361         public_key_list( sl );
3362         free_strlist(sl);
3363         break;
3364       case aListSecretKeys:
3365         sl = NULL;
3366         for( ; argc; argc--, argv++ )
3367             add_to_strlist2( &sl, *argv, utf8_strings );
3368         secret_key_list( sl );
3369         free_strlist(sl);
3370         break;
3371
3372       case aKMode: /* list keyring -- NOTE: This will be removed soon */
3373         if( argc < 2 ) { /* -kv [userid] */
3374             sl = NULL;
3375             if (argc && **argv)
3376                 add_to_strlist2( &sl, *argv, utf8_strings );
3377             public_key_list( sl );
3378             free_strlist(sl);
3379         }
3380         else if( argc == 2 ) { /* -kv userid keyring */
3381             if( access( argv[1], R_OK ) ) {
3382                 log_error(_("can't open `%s': %s\n"),
3383                                print_fname_stdin(argv[1]), strerror(errno));
3384             }
3385             else {
3386                 /* add keyring (default keyrings are not registered in this
3387                  * special case */
3388                 keydb_add_resource( argv[1], 0, 0 );
3389                 sl = NULL;
3390                 if (**argv)
3391                     add_to_strlist2( &sl, *argv, utf8_strings );
3392                 public_key_list( sl );
3393                 free_strlist(sl);
3394             }
3395         }
3396         else
3397             wrong_args(_("-k[v][v][v][c] [user-id] [keyring]") );
3398         break;
3399
3400       case aKeygen: /* generate a key */
3401         if( opt.batch ) {
3402             if( argc > 1 )
3403                 wrong_args("--gen-key [parameterfile]");
3404             generate_keypair( argc? *argv : NULL, NULL, NULL );
3405         }
3406         else {
3407             if( argc )
3408                 wrong_args("--gen-key");
3409             generate_keypair(NULL, NULL, NULL);
3410         }
3411         break;
3412
3413       case aFastImport:
3414         opt.import_options |= IMPORT_FAST;
3415       case aImport:
3416         import_keys( argc? argv:NULL, argc, NULL, opt.import_options );
3417         break;
3418
3419         /* TODO: There are a number of command that use this same
3420            "make strlist, call function, report error, free strlist"
3421            pattern.  Join them together here and avoid all that
3422            duplicated code. */
3423
3424       case aExport:
3425       case aSendKeys:
3426       case aRecvKeys:
3427         sl = NULL;
3428         for( ; argc; argc--, argv++ )
3429             append_to_strlist2( &sl, *argv, utf8_strings );
3430         if( cmd == aSendKeys )
3431             rc=keyserver_export( sl );
3432         else if( cmd == aRecvKeys )
3433             rc=keyserver_import( sl );
3434         else
3435             rc=export_pubkeys( sl, opt.export_options );
3436         if(rc)
3437           {
3438             if(cmd==aSendKeys)
3439               log_error(_("keyserver send failed: %s\n"),g10_errstr(rc));
3440             else if(cmd==aRecvKeys)
3441               log_error(_("keyserver receive failed: %s\n"),g10_errstr(rc));
3442             else
3443               log_error(_("key export failed: %s\n"),g10_errstr(rc));
3444           }
3445         free_strlist(sl);
3446         break;
3447
3448      case aSearchKeys:
3449         sl = NULL;
3450         for( ; argc; argc--, argv++ )
3451           append_to_strlist2( &sl, *argv, utf8_strings );
3452         rc=keyserver_search( sl );
3453         if(rc)
3454           log_error(_("keyserver search failed: %s\n"),g10_errstr(rc));
3455         free_strlist(sl);
3456         break;
3457
3458       case aRefreshKeys:
3459         sl = NULL;
3460         for( ; argc; argc--, argv++ )
3461             append_to_strlist2( &sl, *argv, utf8_strings );
3462         rc=keyserver_refresh(sl);
3463         if(rc)
3464           log_error(_("keyserver refresh failed: %s\n"),g10_errstr(rc));
3465         free_strlist(sl);
3466         break;
3467
3468       case aFetchKeys:
3469         sl = NULL;
3470         for( ; argc; argc--, argv++ )
3471             append_to_strlist2( &sl, *argv, utf8_strings );
3472         rc=keyserver_fetch(sl);
3473         if(rc)
3474           log_error("key fetch failed: %s\n",g10_errstr(rc));
3475         free_strlist(sl);
3476         break;
3477
3478       case aExportSecret:
3479         sl = NULL;
3480         for( ; argc; argc--, argv++ )
3481             add_to_strlist2( &sl, *argv, utf8_strings );
3482         export_seckeys( sl );
3483         free_strlist(sl);
3484         break;
3485
3486       case aExportSecretSub:
3487         sl = NULL;
3488         for( ; argc; argc--, argv++ )
3489             add_to_strlist2( &sl, *argv, utf8_strings );
3490         export_secsubkeys( sl );
3491         free_strlist(sl);
3492         break;
3493
3494       case aGenRevoke:
3495         if( argc != 1 )
3496             wrong_args("--gen-revoke user-id");
3497         username =  make_username(*argv);
3498         gen_revoke( username );
3499         xfree( username );
3500         break;
3501
3502       case aDesigRevoke:
3503         if( argc != 1 )
3504             wrong_args("--desig-revoke user-id");
3505         username =  make_username(*argv);
3506         gen_desig_revoke( username, locusr );
3507         xfree( username );
3508         break;
3509
3510       case aDeArmor:
3511         if( argc > 1 )
3512             wrong_args("--dearmor [file]");
3513         rc = dearmor_file( argc? *argv: NULL );
3514         if( rc )
3515             log_error(_("dearmoring failed: %s\n"), g10_errstr(rc));
3516         break;
3517
3518       case aEnArmor:
3519         if( argc > 1 )
3520             wrong_args("--enarmor [file]");
3521         rc = enarmor_file( argc? *argv: NULL );
3522         if( rc )
3523             log_error(_("enarmoring failed: %s\n"), g10_errstr(rc));
3524         break;
3525
3526
3527       case aPrimegen:
3528 #if 0 /*FIXME*/
3529         {   int mode = argc < 2 ? 0 : atoi(*argv);
3530
3531             if( mode == 1 && argc == 2 ) {
3532                 mpi_print( stdout, generate_public_prime( atoi(argv[1]) ), 1);
3533             }
3534             else if( mode == 2 && argc == 3 ) {
3535                 mpi_print( stdout, generate_elg_prime(
3536                                              0, atoi(argv[1]),
3537                                              atoi(argv[2]), NULL,NULL ), 1);
3538             }
3539             else if( mode == 3 && argc == 3 ) {
3540                 MPI *factors;
3541                 mpi_print( stdout, generate_elg_prime(
3542                                              1, atoi(argv[1]),
3543                                              atoi(argv[2]), NULL,&factors ), 1);
3544                 putchar('\n');
3545                 mpi_print( stdout, factors[0], 1 ); /* print q */
3546             }
3547             else if( mode == 4 && argc == 3 ) {
3548                 MPI g = mpi_alloc(1);
3549                 mpi_print( stdout, generate_elg_prime(
3550                                                  0, atoi(argv[1]),
3551                                                  atoi(argv[2]), g, NULL ), 1);
3552                 putchar('\n');
3553                 mpi_print( stdout, g, 1 );
3554                 mpi_free(g);
3555             }
3556             else
3557                 wrong_args("--gen-prime mode bits [qbits] ");
3558             putchar('\n');
3559         }
3560 #endif
3561         wrong_args("--gen-prime not yet supported ");
3562         break;
3563
3564       case aGenRandom:
3565         {
3566             int level = argc ? atoi(*argv):0;
3567             int count = argc > 1 ? atoi(argv[1]): 0;
3568             int endless = !count;
3569
3570             if( argc < 1 || argc > 2 || level < 0 || level > 2 || count < 0 )
3571                 wrong_args("--gen-random 0|1|2 [count]");
3572
3573             while( endless || count ) {
3574                 byte *p;
3575                 /* Wee need a multiple of 3, so that in case of
3576                    armored output we get a correct string.  No
3577                    linefolding is done, as it is best to levae this to
3578                    other tools */
3579                 size_t n = !endless && count < 99? count : 99;
3580
3581                 p = gcry_random_bytes (n, level);
3582 #ifdef HAVE_DOSISH_SYSTEM
3583                 setmode ( fileno(stdout), O_BINARY );
3584 #endif
3585                 if (opt.armor) {
3586                     char *tmp = make_radix64_string (p, n);
3587                     fputs (tmp, stdout);
3588                     xfree (tmp);
3589                     if (n%3 == 1)
3590                       putchar ('=');
3591                     if (n%3)
3592                       putchar ('=');
3593                 } else {
3594                     fwrite( p, n, 1, stdout );
3595                 }
3596                 xfree(p);
3597                 if( !endless )
3598                     count -= n;
3599             }
3600             if (opt.armor)
3601                 putchar ('\n');
3602         }
3603         break;
3604
3605       case aPrintMD:
3606         if( argc < 1)
3607             wrong_args("--print-md algo [files]");
3608         {
3609             int all_algos = (**argv=='*' && !(*argv)[1]);
3610             int algo = all_algos? 0 : gcry_md_map_name (*argv);
3611
3612             if( !algo && !all_algos )
3613                 log_error(_("invalid hash algorithm `%s'\n"), *argv );
3614             else {
3615                 argc--; argv++;
3616                 if( !argc )
3617                     print_mds(NULL, algo);
3618                 else {
3619                     for(; argc; argc--, argv++ )
3620                         print_mds(*argv, algo);
3621                 }
3622             }
3623         }
3624         break;
3625
3626       case aPrintMDs: /* old option */
3627         if( !argc )
3628             print_mds(NULL,0);
3629         else {
3630             for(; argc; argc--, argv++ )
3631                 print_mds(*argv,0);
3632         }
3633         break;
3634
3635       case aListTrustDB:
3636         if( !argc )
3637             list_trustdb(NULL);
3638         else {
3639             for( ; argc; argc--, argv++ )
3640                 list_trustdb( *argv );
3641         }
3642         break;
3643
3644       case aUpdateTrustDB:
3645         if( argc )
3646             wrong_args("--update-trustdb");
3647         update_trustdb();
3648         break;
3649
3650       case aCheckTrustDB:
3651         /* Old versions allowed for arguments - ignore them */
3652         check_trustdb();
3653         break;
3654
3655       case aFixTrustDB:
3656         log_error("this command is not yet implemented.\n");
3657         log_error("A workaround is to use \"--export-ownertrust\", remove\n");
3658         log_error("the trustdb file and do an \"--import-ownertrust\".\n" );
3659         break;
3660
3661       case aListTrustPath:
3662         if( !argc )
3663             wrong_args("--list-trust-path <user-ids>");
3664         for( ; argc; argc--, argv++ ) {
3665             username = make_username( *argv );
3666             list_trust_path( username );
3667             xfree(username);
3668         }
3669         break;
3670
3671       case aExportOwnerTrust:
3672         if( argc )
3673             wrong_args("--export-ownertrust");
3674         export_ownertrust();
3675         break;
3676
3677       case aImportOwnerTrust:
3678         if( argc > 1 )
3679             wrong_args("--import-ownertrust [file]");
3680         import_ownertrust( argc? *argv:NULL );
3681         break;
3682       
3683       case aRebuildKeydbCaches:
3684         if (argc)
3685             wrong_args ("--rebuild-keydb-caches");
3686         keydb_rebuild_caches (1);
3687         break;
3688
3689 #ifdef ENABLE_CARD_SUPPORT
3690       case aCardStatus:
3691         if (argc)
3692             wrong_args ("--card-status");
3693         card_status (stdout, NULL, 0);
3694         break;
3695
3696       case aCardEdit:
3697         if (argc) {
3698             sl = NULL;
3699             for (argc--, argv++ ; argc; argc--, argv++)
3700                 append_to_strlist (&sl, *argv);
3701             card_edit (sl);
3702             free_strlist (sl);
3703         }
3704         else
3705             card_edit (NULL);
3706         break;
3707
3708       case aChangePIN:
3709         if (!argc)
3710             change_pin (0,1);
3711         else if (argc == 1)
3712             change_pin (atoi (*argv),1);
3713         else
3714         wrong_args ("--change-pin [no]");
3715         break;
3716 #endif /* ENABLE_CARD_SUPPORT*/
3717
3718       case aListConfig:
3719         {
3720           char *str=collapse_args(argc,argv);
3721           list_config(str);
3722           xfree(str);
3723         }
3724         break;
3725
3726       case aListPackets:
3727         opt.list_packets=2;
3728       default:
3729         if( argc > 1 )
3730             wrong_args(_("[filename]"));
3731         /* Issue some output for the unix newbie */
3732         if( !fname && !opt.outfile && isatty( fileno(stdin) )
3733                 && isatty( fileno(stdout) ) && isatty( fileno(stderr) ) )
3734             log_info(_("Go ahead and type your message ...\n"));
3735
3736         a = iobuf_open(fname);
3737         if (a && is_secured_file (iobuf_get_fd (a)))
3738           {
3739             iobuf_close (a);
3740             a = NULL;
3741             errno = EPERM;
3742           }
3743         if( !a )
3744             log_error(_("can't open `%s'\n"), print_fname_stdin(fname));
3745         else {
3746
3747             if( !opt.no_armor ) {
3748                 if( use_armor_filter( a ) ) {
3749                     memset( &afx, 0, sizeof afx);
3750                     iobuf_push_filter( a, armor_filter, &afx );
3751                 }
3752             }
3753             if( cmd == aListPackets ) {
3754                 set_packet_list_mode(1);
3755                 opt.list_packets=1;
3756             }
3757             rc = proc_packets(NULL, a );
3758             if( rc )
3759                 log_error("processing message failed: %s\n", g10_errstr(rc) );
3760             iobuf_close(a);
3761         }
3762         break;
3763       }
3764
3765     /* cleanup */
3766     FREE_STRLIST(remusr);
3767     FREE_STRLIST(locusr);
3768     g10_exit(0);
3769     return 8; /*NEVER REACHED*/
3770 }
3771
3772
3773 /* Note: This function is used by signal handlers!. */
3774 static void
3775 emergency_cleanup (void)
3776 {
3777   gcry_control (GCRYCTL_TERM_SECMEM );
3778 }
3779
3780
3781 void
3782 g10_exit( int rc )
3783 {
3784 #ifdef ENABLE_CARD_SUPPORT
3785   card_close ();
3786 #endif
3787
3788   gcry_control (GCRYCTL_UPDATE_RANDOM_SEED_FILE);
3789   if ( (opt.debug & DBG_MEMSTAT_VALUE) )
3790     {
3791       gcry_control (GCRYCTL_DUMP_MEMORY_STATS);
3792       gcry_control (GCRYCTL_DUMP_RANDOM_STATS);
3793     }
3794   if (opt.debug)
3795     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
3796
3797   emergency_cleanup ();
3798   
3799   rc = rc? rc : log_get_errorcount(0)? 2 : g10_errors_seen? 1 : 0;
3800   exit (rc);
3801 }
3802
3803
3804 /* Pretty-print hex hashes.  This assumes at least an 80-character
3805    display, but there are a few other similar assumptions in the
3806    display code. */
3807 static void
3808 print_hex( gcry_md_hd_t md, int algo, const char *fname )
3809 {
3810   int i,n,count,indent=0;
3811   const byte *p;
3812
3813   if(fname)
3814     indent=printf("%s: ",fname);
3815
3816   if(indent>40)
3817     {
3818       printf("\n");
3819       indent=0;
3820     }
3821
3822   if(algo==DIGEST_ALGO_RMD160)
3823     indent+=printf("RMD160 = ");
3824   else if(algo>0)
3825     indent+=printf("%6s = ", gcry_md_algo_name (algo));
3826   else
3827     algo=abs(algo);
3828
3829   count=indent;
3830
3831   p = gcry_md_read (md, algo);
3832   n = gcry_md_get_algo_dlen (algo);
3833
3834   count += printf ("%02X",*p++);
3835
3836   for(i=1;i<n;i++,p++)
3837     {
3838       if(n==16)
3839         {
3840           if(count+2>79)
3841             {
3842               printf("\n%*s",indent," ");
3843               count=indent;
3844             }
3845           else
3846             count+=printf(" ");
3847
3848           if(!(i%8))
3849             count+=printf(" ");
3850         }
3851       else if (n==20)
3852         {
3853           if(!(i%2))
3854             {
3855               if(count+4>79)
3856                 {
3857                   printf("\n%*s",indent," ");
3858                   count=indent;
3859                 }
3860               else
3861                 count+=printf(" ");
3862             }
3863
3864           if(!(i%10))
3865             count+=printf(" ");
3866         }
3867       else
3868         {
3869           if(!(i%4))
3870             {
3871               if(count+8>79)
3872                 {
3873                   printf("\n%*s",indent," ");
3874                   count=indent;
3875                 }
3876               else
3877                 count+=printf(" ");
3878             }
3879         }
3880
3881       count+=printf("%02X",*p);
3882     }
3883
3884   printf("\n");
3885 }
3886
3887 static void
3888 print_hashline( gcry_md_hd_t md, int algo, const char *fname )
3889 {
3890     int i, n;
3891     const byte *p;
3892     
3893     if ( fname ) {
3894         for (p = fname; *p; p++ ) {
3895             if ( *p <= 32 || *p > 127 || *p == ':' || *p == '%' )
3896                 printf("%%%02X", *p );
3897             else 
3898                 putchar( *p );
3899         }
3900     }
3901     putchar(':');
3902     printf("%d:", algo );
3903     p = gcry_md_read (md, algo);
3904     n = gcry_md_get_algo_dlen (algo);
3905     for(i=0; i < n ; i++, p++ ) 
3906         printf("%02X", *p );
3907     putchar(':');
3908     putchar('\n');
3909 }
3910
3911 static void
3912 print_mds( const char *fname, int algo )
3913 {
3914     FILE *fp;
3915     char buf[1024];
3916     size_t n;
3917     gcry_md_hd_t md;
3918
3919     if( !fname ) {
3920         fp = stdin;
3921 #ifdef HAVE_DOSISH_SYSTEM
3922         setmode ( fileno(fp) , O_BINARY );
3923 #endif
3924     }
3925     else {
3926         fp = fopen( fname, "rb" );
3927         if (fp && is_secured_file (fileno (fp)))
3928           {
3929             fclose (fp);
3930             fp = NULL;
3931             errno = EPERM;
3932           }
3933     }
3934     if( !fp ) {
3935         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3936         return;
3937     }
3938
3939     gcry_md_open (&md, 0, 0);
3940     if( algo )
3941         gcry_md_enable (md, algo);
3942     else {
3943         gcry_md_enable (md, GCRY_MD_MD5);
3944         gcry_md_enable (md, GCRY_MD_SHA1);
3945         gcry_md_enable (md, GCRY_MD_RMD160);
3946 #ifdef USE_SHA256
3947         gcry_md_enable (md, DIGEST_ALGO_SHA224);
3948         gcry_md_enable (md, GCRY_MD_SHA256);
3949 #endif
3950 #ifdef USE_SHA512
3951         gcry_md_enable (md, GCRY_MD_SHA384);
3952         gcry_md_enable (md, GCRY_MD_SHA512);
3953 #endif
3954     }
3955
3956     while( (n=fread( buf, 1, DIM(buf), fp )) )
3957         gcry_md_write (md, buf, n);
3958     if( ferror(fp) )
3959         log_error("%s: %s\n", fname?fname:"[stdin]", strerror(errno) );
3960     else {
3961         gcry_md_final (md);
3962         if ( opt.with_colons ) {
3963             if ( algo ) 
3964                 print_hashline( md, algo, fname );
3965             else {
3966                 print_hashline( md, GCRY_MD_MD5, fname );
3967                 print_hashline( md, GCRY_MD_SHA1, fname );
3968                 print_hashline( md, GCRY_MD_RMD160, fname );
3969 #ifdef USE_SHA256
3970                 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224)
3971                     print_hashline (md, DIGEST_ALGO_SHA224, fname);
3972                 print_hashline( md, GCRY_MD_SHA256, fname );
3973 #endif
3974 #ifdef USE_SHA512
3975                 print_hashline( md, GCRY_MD_SHA384, fname );
3976                 print_hashline( md, GCRY_MD_SHA512, fname );
3977 #endif
3978             }
3979         }
3980         else {
3981             if( algo )
3982                print_hex(md,-algo,fname);
3983             else {
3984                 print_hex( md, GCRY_MD_MD5, fname );
3985                 print_hex( md, GCRY_MD_SHA1, fname );
3986                 print_hex( md, GCRY_MD_RMD160, fname );
3987 #ifdef USE_SHA256
3988                 if (!gcry_md_test_algo (DIGEST_ALGO_SHA224)
3989                     print_hex (md, DIGEST_ALGO_SHA224, fname);
3990                 print_hex( md, GCRY_MD_SHA256, fname );
3991 #endif
3992 #ifdef USE_SHA512
3993                 print_hex( md, GCRY_MD_SHA384, fname );
3994                 print_hex( md, GCRY_MD_SHA512, fname );
3995 #endif
3996             }
3997         }
3998     }
3999     gcry_md_close(md);
4000
4001     if( fp != stdin )
4002         fclose(fp);
4003 }
4004
4005
4006 /****************
4007  * Check the supplied name,value string and add it to the notation
4008  * data to be used for signatures.  which==0 for sig notations, and 1
4009  * for cert notations.
4010 */
4011 static void
4012 add_notation_data( const char *string, int which )
4013 {
4014   struct notation *notation;
4015
4016   notation=string_to_notation(string,utf8_strings);
4017   if(notation)
4018     {
4019       if(which)
4020         {
4021           notation->next=opt.cert_notations;
4022           opt.cert_notations=notation;
4023         }
4024       else
4025         {
4026           notation->next=opt.sig_notations;
4027           opt.sig_notations=notation;
4028         }
4029     }
4030 }
4031
4032 static void
4033 add_policy_url( const char *string, int which )
4034 {
4035   unsigned int i,critical=0;
4036   STRLIST sl;
4037
4038   if(*string=='!')
4039     {
4040       string++;
4041       critical=1;
4042     }
4043
4044   for(i=0;i<strlen(string);i++)
4045     if( !isascii (string[i]) || iscntrl(string[i]))
4046       break;
4047
4048   if(i==0 || i<strlen(string))
4049     {
4050       if(which)
4051         log_error(_("the given certification policy URL is invalid\n"));
4052       else
4053         log_error(_("the given signature policy URL is invalid\n"));
4054     }
4055
4056   if(which)
4057     sl=add_to_strlist( &opt.cert_policy_url, string );
4058   else
4059     sl=add_to_strlist( &opt.sig_policy_url, string );
4060
4061   if(critical)
4062     sl->flags |= 1;    
4063 }
4064
4065 static void
4066 add_keyserver_url( const char *string, int which )
4067 {
4068   unsigned int i,critical=0;
4069   STRLIST sl;
4070
4071   if(*string=='!')
4072     {
4073       string++;
4074       critical=1;
4075     }
4076
4077   for(i=0;i<strlen(string);i++)
4078     if( !isascii (string[i]) || iscntrl(string[i]))
4079       break;
4080
4081   if(i==0 || i<strlen(string))
4082     {
4083       if(which)
4084         BUG();
4085       else
4086         log_error(_("the given preferred keyserver URL is invalid\n"));
4087     }
4088
4089   if(which)
4090     BUG();
4091   else
4092     sl=add_to_strlist( &opt.sig_keyserver_url, string );
4093
4094   if(critical)
4095     sl->flags |= 1;    
4096 }