Commit bcf369e5 authored by Mark Andrews's avatar Mark Andrews
Browse files

1889. [func] The lame cache is now done on a <qname,qclass,qtype>

                        basis as some servers only appear to be lame for
                        certain query types.  [RT #14916]
parent 045eca6d
1889. [func] The lame cache is now done on a <qname,qclass,qtype>
basis as some servers only appear to be lame for
certain query types. [RT #14916]
1888. [func] "USE INTERNAL MALLOC" is now runtime selectable.
[RT #14892]
......
......@@ -15,7 +15,7 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: lwdgabn.c,v 1.17 2005/04/29 00:22:28 marka Exp $ */
/* $Id: lwdgabn.c,v 1.18 2005/06/23 04:21:59 marka Exp $ */
/*! \file */
......@@ -434,7 +434,7 @@ restart_find(ns_lwdclient_t *client) {
client->clientmgr->task,
process_gabn_finddone, client,
dns_fixedname_name(&client->target_name),
dns_rootname, options, 0,
dns_rootname, 0, options, 0,
dns_fixedname_name(&client->target_name),
client->clientmgr->view->dstport,
&client->find);
......
......@@ -15,7 +15,7 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: adb.c,v 1.221 2005/04/27 04:56:44 sra Exp $ */
/* $Id: adb.c,v 1.222 2005/06/23 04:22:01 marka Exp $ */
/*! \file
*
......@@ -52,6 +52,7 @@
#include <dns/rdata.h>
#include <dns/rdataset.h>
#include <dns/rdatastruct.h>
#include <dns/rdatatype.h>
#include <dns/resolver.h>
#include <dns/result.h>
......@@ -61,8 +62,8 @@
#define DNS_ADBNAME_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBNAME_MAGIC)
#define DNS_ADBNAMEHOOK_MAGIC ISC_MAGIC('a', 'd', 'N', 'H')
#define DNS_ADBNAMEHOOK_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBNAMEHOOK_MAGIC)
#define DNS_ADBZONEINFO_MAGIC ISC_MAGIC('a', 'd', 'b', 'Z')
#define DNS_ADBZONEINFO_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBZONEINFO_MAGIC)
#define DNS_ADBLAMEINFO_MAGIC ISC_MAGIC('a', 'd', 'b', 'Z')
#define DNS_ADBLAMEINFO_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBLAMEINFO_MAGIC)
#define DNS_ADBENTRY_MAGIC ISC_MAGIC('a', 'd', 'b', 'E')
#define DNS_ADBENTRY_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBENTRY_MAGIC)
#define DNS_ADBFETCH_MAGIC ISC_MAGIC('a', 'd', 'F', '4')
......@@ -107,7 +108,7 @@
typedef ISC_LIST(dns_adbname_t) dns_adbnamelist_t;
typedef struct dns_adbnamehook dns_adbnamehook_t;
typedef ISC_LIST(dns_adbnamehook_t) dns_adbnamehooklist_t;
typedef struct dns_adbzoneinfo dns_adbzoneinfo_t;
typedef struct dns_adblameinfo dns_adblameinfo_t;
typedef ISC_LIST(dns_adbentry_t) dns_adbentrylist_t;
typedef struct dns_adbfetch dns_adbfetch_t;
typedef struct dns_adbfetch6 dns_adbfetch6_t;
......@@ -135,7 +136,7 @@ struct dns_adb {
isc_mutex_t mplock;
isc_mempool_t *nmp; /*%< dns_adbname_t */
isc_mempool_t *nhmp; /*%< dns_adbnamehook_t */
isc_mempool_t *zimp; /*%< dns_adbzoneinfo_t */
isc_mempool_t *limp; /*%< dns_adblameinfo_t */
isc_mempool_t *emp; /*%< dns_adbentry_t */
isc_mempool_t *ahmp; /*%< dns_adbfind_t */
isc_mempool_t *aimp; /*%< dns_adbaddrinfo_t */
......@@ -218,17 +219,18 @@ struct dns_adbnamehook {
};
/*%
* This is a small widget that holds zone-specific information about an
* This is a small widget that holds qname-specific information about an
* address. Currently limited to lameness, but could just as easily be
* extended to other types of information about zones.
*/
struct dns_adbzoneinfo {
struct dns_adblameinfo {
unsigned int magic;
dns_name_t zone;
dns_name_t qname;
dns_rdatatype_t qtype;
isc_stdtime_t lame_timer;
ISC_LINK(dns_adbzoneinfo_t) plink;
ISC_LINK(dns_adblameinfo_t) plink;
};
/*%
......@@ -255,7 +257,7 @@ struct dns_adbentry {
* name.
*/
ISC_LIST(dns_adbzoneinfo_t) zoneinfo;
ISC_LIST(dns_adblameinfo_t) lameinfo;
ISC_LINK(dns_adbentry_t) plink;
};
......@@ -267,8 +269,9 @@ static inline void free_adbname(dns_adb_t *, dns_adbname_t **);
static inline dns_adbnamehook_t *new_adbnamehook(dns_adb_t *,
dns_adbentry_t *);
static inline void free_adbnamehook(dns_adb_t *, dns_adbnamehook_t **);
static inline dns_adbzoneinfo_t *new_adbzoneinfo(dns_adb_t *, dns_name_t *);
static inline void free_adbzoneinfo(dns_adb_t *, dns_adbzoneinfo_t **);
static inline dns_adblameinfo_t *new_adblameinfo(dns_adb_t *, dns_name_t *,
dns_rdatatype_t);
static inline void free_adblameinfo(dns_adb_t *, dns_adblameinfo_t **);
static inline dns_adbentry_t *new_adbentry(dns_adb_t *);
static inline void free_adbentry(dns_adb_t *, dns_adbentry_t **);
static inline dns_adbfind_t *new_adbfind(dns_adb_t *);
......@@ -1324,42 +1327,42 @@ free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
isc_mempool_put(adb->nhmp, nh);
}
static inline dns_adbzoneinfo_t *
new_adbzoneinfo(dns_adb_t *adb, dns_name_t *zone) {
dns_adbzoneinfo_t *zi;
static inline dns_adblameinfo_t *
new_adblameinfo(dns_adb_t *adb, dns_name_t *qname, dns_rdatatype_t qtype) {
dns_adblameinfo_t *li;
zi = isc_mempool_get(adb->zimp);
if (zi == NULL)
li = isc_mempool_get(adb->limp);
if (li == NULL)
return (NULL);
dns_name_init(&zi->zone, NULL);
if (dns_name_dup(zone, adb->mctx, &zi->zone) != ISC_R_SUCCESS) {
isc_mempool_put(adb->zimp, zi);
dns_name_init(&li->qname, NULL);
if (dns_name_dup(qname, adb->mctx, &li->qname) != ISC_R_SUCCESS) {
isc_mempool_put(adb->limp, li);
return (NULL);
}
li->magic = DNS_ADBLAMEINFO_MAGIC;
li->lame_timer = 0;
li->qtype = qtype;
ISC_LINK_INIT(li, plink);
zi->magic = DNS_ADBZONEINFO_MAGIC;
zi->lame_timer = 0;
ISC_LINK_INIT(zi, plink);
return (zi);
return (li);
}
static inline void
free_adbzoneinfo(dns_adb_t *adb, dns_adbzoneinfo_t **zoneinfo) {
dns_adbzoneinfo_t *zi;
free_adblameinfo(dns_adb_t *adb, dns_adblameinfo_t **lameinfo) {
dns_adblameinfo_t *li;
INSIST(zoneinfo != NULL && DNS_ADBZONEINFO_VALID(*zoneinfo));
zi = *zoneinfo;
*zoneinfo = NULL;
INSIST(lameinfo != NULL && DNS_ADBLAMEINFO_VALID(*lameinfo));
li = *lameinfo;
*lameinfo = NULL;
INSIST(!ISC_LINK_LINKED(zi, plink));
INSIST(!ISC_LINK_LINKED(li, plink));
dns_name_free(&zi->zone, adb->mctx);
dns_name_free(&li->qname, adb->mctx);
zi->magic = 0;
li->magic = 0;
isc_mempool_put(adb->zimp, zi);
isc_mempool_put(adb->limp, li);
}
static inline dns_adbentry_t *
......@@ -1378,7 +1381,7 @@ new_adbentry(dns_adb_t *adb) {
isc_random_get(&r);
e->srtt = (r & 0x1f) + 1;
e->expires = 0;
ISC_LIST_INIT(e->zoneinfo);
ISC_LIST_INIT(e->lameinfo);
ISC_LINK_INIT(e, plink);
return (e);
......@@ -1387,7 +1390,7 @@ new_adbentry(dns_adb_t *adb) {
static inline void
free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
dns_adbentry_t *e;
dns_adbzoneinfo_t *zi;
dns_adblameinfo_t *li;
INSIST(entry != NULL && DNS_ADBENTRY_VALID(*entry));
e = *entry;
......@@ -1399,11 +1402,11 @@ free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry) {
e->magic = 0;
zi = ISC_LIST_HEAD(e->zoneinfo);
while (zi != NULL) {
ISC_LIST_UNLINK(e->zoneinfo, zi, plink);
free_adbzoneinfo(adb, &zi);
zi = ISC_LIST_HEAD(e->zoneinfo);
li = ISC_LIST_HEAD(e->lameinfo);
while (li != NULL) {
ISC_LIST_UNLINK(e->lameinfo, li, plink);
free_adblameinfo(adb, &li);
li = ISC_LIST_HEAD(e->lameinfo);
}
isc_mempool_put(adb->emp, e);
......@@ -1650,45 +1653,47 @@ find_entry_and_lock(dns_adb_t *adb, isc_sockaddr_t *addr, int *bucketp) {
* Entry bucket MUST be locked!
*/
static isc_boolean_t
entry_is_bad_for_zone(dns_adb_t *adb, dns_adbentry_t *entry, dns_name_t *zone,
isc_stdtime_t now)
entry_is_lame(dns_adb_t *adb, dns_adbentry_t *entry, dns_name_t *qname,
dns_rdatatype_t qtype, isc_stdtime_t now)
{
dns_adbzoneinfo_t *zi, *next_zi;
dns_adblameinfo_t *li, *next_li;
isc_boolean_t is_bad;
is_bad = ISC_FALSE;
zi = ISC_LIST_HEAD(entry->zoneinfo);
if (zi == NULL)
li = ISC_LIST_HEAD(entry->lameinfo);
if (li == NULL)
return (ISC_FALSE);
while (zi != NULL) {
next_zi = ISC_LIST_NEXT(zi, plink);
while (li != NULL) {
next_li = ISC_LIST_NEXT(li, plink);
/*
* Has the entry expired?
*/
if (zi->lame_timer < now) {
ISC_LIST_UNLINK(entry->zoneinfo, zi, plink);
free_adbzoneinfo(adb, &zi);
if (li->lame_timer < now) {
ISC_LIST_UNLINK(entry->lameinfo, li, plink);
free_adblameinfo(adb, &li);
}
/*
* Order tests from least to most expensive.
*/
if (zi != NULL && !is_bad) {
if (dns_name_equal(zone, &zi->zone))
if (li != NULL && !is_bad) {
if (li->qtype == qtype &&
dns_name_equal(qname, &li->qname))
is_bad = ISC_TRUE;
}
zi = next_zi;
li = next_li;
}
return (is_bad);
}
static void
copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *zone,
dns_adbname_t *name, isc_stdtime_t now)
copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *qname,
dns_rdatatype_t qtype, dns_adbname_t *name,
isc_stdtime_t now)
{
dns_adbnamehook_t *namehook;
dns_adbaddrinfo_t *addrinfo;
......@@ -1705,7 +1710,7 @@ copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *zone,
LOCK(&adb->entrylocks[bucket]);
if (!FIND_RETURNLAME(find)
&& entry_is_bad_for_zone(adb, entry, zone, now)) {
&& entry_is_lame(adb, entry, qname, qtype, now)) {
find->options |= DNS_ADBFIND_LAMEPRUNED;
goto nextv4;
}
......@@ -1734,7 +1739,7 @@ copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *zone,
bucket = entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
if (entry_is_bad_for_zone(adb, entry, zone, now))
if (entry_is_lame(adb, entry, qname, qtype, now))
goto nextv6;
addrinfo = new_adbaddrinfo(adb, entry, find->port);
if (addrinfo == NULL) {
......@@ -1974,7 +1979,7 @@ destroy(dns_adb_t *adb) {
isc_mempool_destroy(&adb->nmp);
isc_mempool_destroy(&adb->nhmp);
isc_mempool_destroy(&adb->zimp);
isc_mempool_destroy(&adb->limp);
isc_mempool_destroy(&adb->emp);
isc_mempool_destroy(&adb->ahmp);
isc_mempool_destroy(&adb->aimp);
......@@ -2022,7 +2027,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
adb->irefcnt = 0;
adb->nmp = NULL;
adb->nhmp = NULL;
adb->zimp = NULL;
adb->limp = NULL;
adb->emp = NULL;
adb->ahmp = NULL;
adb->aimp = NULL;
......@@ -2094,7 +2099,7 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
MPINIT(dns_adbname_t, adb->nmp, "adbname");
MPINIT(dns_adbnamehook_t, adb->nhmp, "adbnamehook");
MPINIT(dns_adbzoneinfo_t, adb->zimp, "adbzoneinfo");
MPINIT(dns_adblameinfo_t, adb->limp, "adblameinfo");
MPINIT(dns_adbentry_t, adb->emp, "adbentry");
MPINIT(dns_adbfind_t, adb->ahmp, "adbfind");
MPINIT(dns_adbaddrinfo_t, adb->aimp, "adbaddrinfo");
......@@ -2147,8 +2152,8 @@ dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
isc_mempool_destroy(&adb->nmp);
if (adb->nhmp != NULL)
isc_mempool_destroy(&adb->nhmp);
if (adb->zimp != NULL)
isc_mempool_destroy(&adb->zimp);
if (adb->limp != NULL)
isc_mempool_destroy(&adb->limp);
if (adb->emp != NULL)
isc_mempool_destroy(&adb->emp);
if (adb->ahmp != NULL)
......@@ -2268,8 +2273,9 @@ dns_adb_shutdown(dns_adb_t *adb) {
isc_result_t
dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
void *arg, dns_name_t *name, dns_name_t *zone,
unsigned int options, isc_stdtime_t now, dns_name_t *target,
void *arg, dns_name_t *name, dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target,
in_port_t port, dns_adbfind_t **findp)
{
dns_adbfind_t *find;
......@@ -2286,7 +2292,7 @@ dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
REQUIRE(action != NULL);
}
REQUIRE(name != NULL);
REQUIRE(zone != NULL);
REQUIRE(qname != NULL);
REQUIRE(findp != NULL && *findp == NULL);
REQUIRE(target == NULL || dns_name_hasbuffer(target));
......@@ -2514,7 +2520,7 @@ dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
* Run through the name and copy out the bits we are
* interested in.
*/
copy_namehook_lists(adb, find, zone, adbname, now);
copy_namehook_lists(adb, find, qname, qtype, adbname, now);
post_copy:
if (NAME_FETCH_V4(adbname))
......@@ -2830,8 +2836,9 @@ dump_entry(FILE *f, dns_adbentry_t *entry, isc_boolean_t debug,
isc_stdtime_t now)
{
char addrbuf[ISC_NETADDR_FORMATSIZE];
char typebuf[DNS_RDATATYPE_FORMATSIZE];
isc_netaddr_t netaddr;
dns_adbzoneinfo_t *zi;
dns_adblameinfo_t *li;
isc_netaddr_fromsockaddr(&netaddr, &entry->sockaddr);
isc_netaddr_format(&netaddr, addrbuf, sizeof(addrbuf));
......@@ -2844,12 +2851,14 @@ dump_entry(FILE *f, dns_adbentry_t *entry, isc_boolean_t debug,
if (entry->expires != 0)
fprintf(f, " [ttl %d]", entry->expires - now);
fprintf(f, "\n");
for (zi = ISC_LIST_HEAD(entry->zoneinfo);
zi != NULL;
zi = ISC_LIST_NEXT(zi, plink)) {
for (li = ISC_LIST_HEAD(entry->lameinfo);
li != NULL;
li = ISC_LIST_NEXT(li, plink)) {
fprintf(f, ";\t\t");
print_dns_name(f, &zi->zone);
fprintf(f, " [lame TTL %d]\n", zi->lame_timer - now);
print_dns_name(f, &li->qname);
dns_rdatatype_format(li->qtype, typebuf, sizeof(typebuf));
fprintf(f, " %s [lame TTL %d]\n", typebuf,
li->lame_timer - now);
}
}
......@@ -3336,36 +3345,37 @@ fetch_name(dns_adbname_t *adbname,
* since these can be extracted from the find itself.
*/
isc_result_t
dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *zone,
isc_stdtime_t expire_time)
dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *qname,
dns_rdatatype_t qtype, isc_stdtime_t expire_time)
{
dns_adbzoneinfo_t *zi;
dns_adblameinfo_t *li;
int bucket;
isc_result_t result = ISC_R_SUCCESS;
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(DNS_ADBADDRINFO_VALID(addr));
REQUIRE(zone != NULL);
REQUIRE(qname != NULL);
bucket = addr->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
zi = ISC_LIST_HEAD(addr->entry->zoneinfo);
while (zi != NULL && !dns_name_equal(zone, &zi->zone))
zi = ISC_LIST_NEXT(zi, plink);
if (zi != NULL) {
if (expire_time > zi->lame_timer)
zi->lame_timer = expire_time;
li = ISC_LIST_HEAD(addr->entry->lameinfo);
while (li != NULL && li->qtype != qtype &&
!dns_name_equal(qname, &li->qname))
li = ISC_LIST_NEXT(li, plink);
if (li != NULL) {
if (expire_time > li->lame_timer)
li->lame_timer = expire_time;
goto unlock;
}
zi = new_adbzoneinfo(adb, zone);
if (zi == NULL) {
li = new_adblameinfo(adb, qname, qtype);
if (li == NULL) {
result = ISC_R_NOMEMORY;
goto unlock;
}
zi->lame_timer = expire_time;
li->lame_timer = expire_time;
ISC_LIST_PREPEND(addr->entry->zoneinfo, zi, plink);
ISC_LIST_PREPEND(addr->entry->lameinfo, li, plink);
unlock:
UNLOCK(&adb->entrylocks[bucket]);
......
......@@ -15,7 +15,7 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: adb.h,v 1.78 2005/04/29 00:22:54 marka Exp $ */
/* $Id: adb.h,v 1.79 2005/06/23 04:22:02 marka Exp $ */
#ifndef DNS_ADB_H
#define DNS_ADB_H 1
......@@ -50,9 +50,9 @@
* Records are stored internally until a timer expires. The timer is the
* smaller of the TTL or signature validity period.
*
* Lameness is stored per-zone, and this data hangs off each address field.
* When an address is marked lame for a given zone the address will not
* be returned to a caller.
* Lameness is stored per <qname,qtype> tuple, and this data hangs off each
* address field. When an address is marked lame for a given tuple the address
* will not be returned to a caller.
*
*
* MP:
......@@ -330,8 +330,9 @@ dns_adb_shutdown(dns_adb_t *adb);
isc_result_t
dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
void *arg, dns_name_t *name, dns_name_t *zone,
unsigned int options, isc_stdtime_t now, dns_name_t *target,
void *arg, dns_name_t *name, dns_name_t *qname,
dns_rdatatype_t qtype, unsigned int options,
isc_stdtime_t now, dns_name_t *target,
in_port_t port, dns_adbfind_t **find);
/*%<
* Main interface for clients. The adb will look up the name given in
......@@ -385,7 +386,7 @@ dns_adb_createfind(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
*
*\li *name is a valid dns_name_t.
*
*\li zone != NULL and *zone be a valid dns_name_t.
*\li qname != NULL and *qname be a valid dns_name_t.
*
*\li target == NULL or target is a valid name with a buffer.
*
......@@ -487,10 +488,10 @@ dns_adb_dumpfind(dns_adbfind_t *find, FILE *f);
*/
isc_result_t
dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *zone,
isc_stdtime_t expire_time);
dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *qname,
dns_rdatatype_t type, isc_stdtime_t expire_time);
/*%<
* Mark the given address as lame for the zone "zone". expire_time should
* Mark the given address as lame for the <qname,qtype>. expire_time should
* be set to the time when the entry should expire. That is, if it is to
* expire 10 minutes in the future, it should set it to (now + 10 * 60).
*
......@@ -500,7 +501,7 @@ dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *zone,
*
*\li addr be valid.
*
*\li zone be the zone used in the dns_adb_createfind() call.
*\li qname be the qname used in the dns_adb_createfind() call.
*
* Returns:
*
......
......@@ -15,7 +15,7 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: resolver.c,v 1.311 2005/06/17 01:58:22 marka Exp $ */
/* $Id: resolver.c,v 1.312 2005/06/23 04:22:01 marka Exp $ */
/*! \file */
......@@ -1757,7 +1757,7 @@ sort_finds(fetchctx_t *fctx) {
static void
findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
unsigned int options, unsigned int flags, isc_stdtime_t now,
isc_boolean_t *pruned, isc_boolean_t *need_alternate)
isc_boolean_t *need_alternate)
{
dns_adbaddrinfo_t *ai;
dns_adbfind_t *find;
......@@ -1786,7 +1786,8 @@ findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
result = dns_adb_createfind(fctx->adb,
res->buckets[fctx->bucketnum].task,
fctx_finddone, fctx, name,
&fctx->domain, options, now, NULL,
&fctx->name, fctx->type,
options, now, NULL,
res->view->dstport, &find);
if (result != ISC_R_SUCCESS) {
if (result == DNS_R_ALIAS) {
......@@ -1849,18 +1850,6 @@ findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
(res->dispatchv6 == NULL &&
find->result_v4 == DNS_R_NXRRSET)))
*need_alternate = ISC_TRUE;
/*
* And ADB isn't going to send us any events
* either. This find loses.
*/
if ((find->options & DNS_ADBFIND_LAMEPRUNED) != 0) {
/*
* The ADB pruned lame servers for
* this name. Remember that in case
* we get desperate later on.
*/
*pruned = ISC_TRUE;
}
dns_adb_destroyfind(&find);
}
}
......@@ -1875,7 +1864,7 @@ fctx_getaddresses(fetchctx_t *fctx) {
unsigned int stdoptions;
isc_sockaddr_t *sa;
dns_adbaddrinfo_t *ai;
isc_boolean_t pruned, all_bad;
isc_boolean_t all_bad;
dns_rdata_ns_t ns;
isc_boolean_t need_alternate = ISC_FALSE;
isc_boolean_t unshared;
......@@ -1892,7 +1881,6 @@ fctx_getaddresses(fetchctx_t *fctx) {
}
res = fctx->res;
pruned = ISC_FALSE;
stdoptions = 0; /* Keep compiler happy. */
unshared = ISC_TF((fctx->options | DNS_FETCHOPT_UNSHARED) != 0);
......@@ -1985,7 +1973,6 @@ fctx_getaddresses(fetchctx_t *fctx) {
stdoptions |= DNS_ADBFIND_INET6;
isc_stdtime_get(&now);
restart:
INSIST(ISC_LIST_EMPTY(fctx->finds));
INSIST(ISC_LIST_EMPTY(fctx->altfinds));
......@@ -2002,7 +1989,7 @@ fctx_getaddresses(fetchctx_t *fctx) {
continue;
findname(fctx, &ns.name, 0, stdoptions, 0, now,
&pruned, &need_alternate);
&need_alternate);
dns_rdata_reset(&rdata);
dns_rdata_freestruct(&ns);
}
......@@ -2022,7 +2009,7 @@ fctx_getaddresses(fetchctx_t *fctx) {
if (!a->isaddress) {
findname(fctx, &a->_u._n.name, a->_u._n.port,
stdoptions, FCTX_ADDRINFO_FORWARDER,
now, &pruned, NULL);
now, NULL);
continue;
}
if (isc_sockaddr_pf(&a->_u.addr) != family)
......@@ -2065,18 +2052,6 @@ fctx_getaddresses(fetchctx_t *fctx) {
* yet. Tell the caller to wait for an answer.
*/
result = DNS_R_WAIT;
} else if (pruned) {
/*
* Some addresses were removed by lame pruning.
* Turn pruning off and try again.
*/
FCTXTRACE("restarting with returnlame");
INSIST((stdoptions & DNS_ADBFIND_RETURNLAME) == 0);
stdoptions |= DNS_ADBFIND_RETURNLAME;
pruned = ISC_FALSE;
fctx_cleanupaltfinds(fctx);
fctx_cleanupfinds(fctx);
goto restart;
} else {
/*
* We've lost completely. We don't know any
......@@ -5344,7 +5319,7 @@ resquery_response(isc_task_t *task, isc_event_t *event) {
is_lame(fctx)) {
log_lame(fctx, query->addrinfo);
result = dns_adb_marklame(fctx->adb, query->addrinfo,
&fctx->domain,
&fctx->domain, fctx->type,
now + fctx->res->lame_ttl);
if (result != ISC_R_SUCCESS)
isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
......
......@@ -15,7 +15,7 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
/* $Id: zone.c,v 1.440 2005/06/20 01:03:53 marka Exp $ */
/* $Id: zone.c,v 1.441 2005/06/23 04:22:02 marka Exp $ */
/*! \file */
......@@ -3386,7 +3386,7 @@ notify_find_address(dns_notify_t *notify) {
result = dns_adb_createfind(notify->zone->view->adb,
notify->zone->task,
process_adb_event, notify,
&notify->ns, dns_rootname,
&notify->ns, dns_rootname, 0,
options, 0, NULL,
notify->zone->view->dstport,
&notify->find);
......