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]

diff --git a/CHANGES b/CHANGES
index a516f811074506ee6508ad33c80623996be94be2..9680945764ee1e7c589a4ad3071162c32ce5aece 100644 (file)
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,7 @@
+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]
 

diff --git a/bin/named/lwdgabn.c b/bin/named/lwdgabn.c
index bc9b0746a33e3d1c6680981d11570867f7fbb396..d5da2f1db9eca7bf143951df1aa8beb54c38e225 100644 (file)
--- a/bin/named/lwdgabn.c
+++ b/bin/named/lwdgabn.c
@@ -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);

diff --git a/lib/dns/adb.c b/lib/dns/adb.c
index 103f46b0b7f28a525a7152b6f998ddc05a11e308..1362f32f202016603d0d79daa1057cf493b4a0e1 100644 (file)
--- a/lib/dns/adb.c
+++ b/lib/dns/adb.c
@@ -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]);
 

diff --git a/lib/dns/include/dns/adb.h b/lib/dns/include/dns/adb.h
index 17e250034dc4b38952ec9c0eedaf5252ea672901..635b1ac8ab2e9427f2885f15e3e96dd64fb5e396 100644 (file)
--- a/lib/dns/include/dns/adb.h
+++ b/lib/dns/include/dns/adb.h
@@ -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:
  *

diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
index 5027cc961594995bd876dffd4eb73fa9d71b7a20..7fa3fe0adc403668a1a343c50e97d5a86b59741c 100644 (file)
--- a/lib/dns/resolver.c
+++ b/lib/dns/resolver.c
@@ -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,

diff --git a/lib/dns/zone.c b/lib/dns/zone.c
index 10fd2d5292ece6f9f6f1a5dcf6210ce507fda98a..81c405281cc2c7ae867e8daad54c4d74b07f88c1 100644 (file)
--- a/lib/dns/zone.c
+++ b/lib/dns/zone.c
@@ -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);