mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 18:19:42 +00:00
Code Issues Releases Wiki Activity
bind/lib/dns/adb.c

3633 lines
85 KiB
C
Raw Normal View History

Start on address.c
1999-09-21 22:46:42 +00:00
/*
* Copyright (C) 1999 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
* Implementation notes
* --------------------
*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* In finds, if task == NULL, no events will be generated, and no events
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
* have been sent. If task != NULL but taskaction == NULL, an event has been
review checkpoint
1999-11-25 01:23:32 +00:00
* posted but not yet freed. If neither are NULL, no event was posted.
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*
*/
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* After we have cleaned all buckets, dump the database contents.
*/
#define DUMP_ADB_AFTER_CLEANING
Start on address.c
1999-09-21 22:46:42 +00:00
#include <config.h>
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
#include <stdio.h>
#include <string.h>
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
#include <isc/assertions.h>
snapshot
1999-10-05 23:50:43 +00:00
#include <isc/condition.h>
snapshot
1999-10-20 23:26:06 +00:00
#include <isc/event.h>
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
#include <isc/log.h>
use isc/magic.h, and (unfortunately) export dns_adbhandle_t's definition
1999-09-25 01:25:46 +00:00
#include <isc/magic.h>
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
#include <isc/mutex.h>
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
#include <isc/mutexblock.h>
snapshot
1999-10-20 23:26:06 +00:00
#include <isc/random.h>
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
#include <isc/timer.h>
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
a6 checkpoint
1999-10-30 01:22:16 +00:00
#include <dns/a6.h>
s/address/adb/
1999-10-22 01:02:38 +00:00
#include <dns/adb.h>
database lookups
1999-10-21 01:18:06 +00:00
#include <dns/db.h>
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
#include <dns/events.h>
fix
1999-10-25 21:39:08 +00:00
#include <dns/fixedname.h>
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
#include <dns/log.h>
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
#include <dns/name.h>
snapshot
1999-10-05 23:50:43 +00:00
#include <dns/rdata.h>
#include <dns/rdataset.h>
fix
1999-10-25 21:39:08 +00:00
#include <dns/resolver.h>
#include <dns/types.h>
snapshot
1999-10-08 23:12:21 +00:00
#include <dns/view.h>
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
#include "../isc/util.h"
Start on address.c
1999-09-21 22:46:42 +00:00
use isc/magic.h, and (unfortunately) export dns_adbhandle_t's definition
1999-09-25 01:25:46 +00:00
#define DNS_ADB_MAGIC 0x44616462 /* Dadb. */
#define DNS_ADB_VALID(x) ISC_MAGIC_VALID(x, DNS_ADB_MAGIC)
#define DNS_ADBNAME_MAGIC 0x6164624e /* adbN. */
#define DNS_ADBNAME_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBNAME_MAGIC)
#define DNS_ADBNAMEHOOK_MAGIC 0x61644e48 /* adNH. */
#define DNS_ADBNAMEHOOK_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBNAMEHOOK_MAGIC)
#define DNS_ADBZONEINFO_MAGIC 0x6164625a /* adbZ. */
#define DNS_ADBZONEINFO_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBZONEINFO_MAGIC)
#define DNS_ADBENTRY_MAGIC 0x61646245 /* adbE. */
#define DNS_ADBENTRY_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBENTRY_MAGIC)
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
#define DNS_ADBFETCH_MAGIC 0x61644634 /* adF4. */
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
#define DNS_ADBFETCH_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBFETCH_MAGIC)
a6 checkpoint
1999-10-30 01:22:16 +00:00
#define DNS_ADBFETCH6_MAGIC 0x61644636 /* adF6. */
#define DNS_ADBFETCH6_VALID(x) ISC_MAGIC_VALID(x, DNS_ADBFETCH6_MAGIC)
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
review checkpoint
1999-11-25 01:23:32 +00:00
* The number of buckets needs to be a prime (for good hashing).
*
* XXXRTH How many buckets do we need?
*
* This value must be coordinated with CLEAN_SECONDS (below).
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*/
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
#define NBUCKETS 1009 /* how many buckets for names/addrs */
/*
* For type 3 negative cache entries, we will remember that the address is
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
* broken for this long. XXXMLG This is also used for actual addresses, too.
* The intent is to keep us from constantly asking about A/A6/AAAA records
* if the zone has extremely low TTLs.
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
*/
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
#define ADB_CACHE_MINIMUM 600 /* seconds */
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
review checkpoint
1999-11-25 01:23:32 +00:00
/*
* Clean one bucket every CLEAN_SECONDS.
*/
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
#define CLEAN_SECONDS (300 / NBUCKETS)
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
#if CLEAN_SECONDS < 1
#undef CLEAN_SECONDS
#define CLEAN_SECONDS 1
#endif
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
#define FREE_ITEMS 16 /* free count for memory pools */
#define FILL_COUNT 8 /* fill count for memory pools */
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
#define DNS_ADB_INVALIDBUCKET (-1) /* invalid bucket address */
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
typedef ISC_LIST(dns_adbname_t) dns_adbnamelist_t;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
typedef struct dns_adbnamehook dns_adbnamehook_t;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
typedef ISC_LIST(dns_adbnamehook_t) dns_adbnamehooklist_t;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
typedef struct dns_adbzoneinfo dns_adbzoneinfo_t;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
typedef ISC_LIST(dns_adbentry_t) dns_adbentrylist_t;
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
typedef struct dns_adbfetch dns_adbfetch_t;
a6 checkpoint
1999-10-30 01:22:16 +00:00
typedef struct dns_adbfetch6 dns_adbfetch6_t;
Start on address.c
1999-09-21 22:46:42 +00:00
struct dns_adb {
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
unsigned int magic;
isc_mutex_t lock;
isc_mem_t *mctx;
snapshot
1999-10-08 23:12:21 +00:00
dns_view_t *view;
fix
1999-10-25 21:39:08 +00:00
isc_timermgr_t *timermgr;
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
isc_timer_t *timer;
fix
1999-10-25 21:39:08 +00:00
isc_taskmgr_t *taskmgr;
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
isc_task_t *task;
cleanup snapshot
1999-10-29 23:53:12 +00:00
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
isc_interval_t tick_interval;
cleanup snapshot
1999-10-29 23:53:12 +00:00
int next_namebucket;
int next_entrybucket;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
unsigned int irefcnt;
unsigned int erefcnt;
snapshot
1999-10-05 23:50:43 +00:00
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
isc_mutex_t mplock;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
isc_mempool_t *nmp; /* dns_adbname_t */
isc_mempool_t *nhmp; /* dns_adbnamehook_t */
isc_mempool_t *zimp; /* dns_adbzoneinfo_t */
isc_mempool_t *emp; /* dns_adbentry_t */
dns_adbhandle_t -> dns_adbfind_t
1999-10-29 18:07:32 +00:00
isc_mempool_t *ahmp; /* dns_adbfind_t */
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
isc_mempool_t *aimp; /* dns_adbaddrinfo_t */
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
isc_mempool_t *afmp; /* dns_adbfetch_t */
a6 checkpoint
1999-10-30 01:22:16 +00:00
isc_mempool_t *af6mp; /* dns_adbfetch6_t */
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
snapshot
1999-10-20 23:26:06 +00:00
isc_random_t rand;
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
/*
* Bucketized locks and lists for names.
review checkpoint
1999-11-25 01:23:32 +00:00
*
* XXXRTH Have a per-bucket structure that contains all of these?
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
*/
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
dns_adbnamelist_t names[NBUCKETS];
isc_mutex_t namelocks[NBUCKETS];
isc_boolean_t name_sd[NBUCKETS];
unsigned int name_refcnt[NBUCKETS];
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
/*
* Bucketized locks for entries.
review checkpoint
1999-11-25 01:23:32 +00:00
*
* XXXRTH Have a per-bucket structure that contains all of these?
adjust what points to what. You are lost in a maze of twisty little pointers, all alike.
1999-09-22 01:01:14 +00:00
*/
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
dns_adbentrylist_t entries[NBUCKETS];
isc_mutex_t entrylocks[NBUCKETS];
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
isc_event_t cevent;
isc_boolean_t cevent_sent;
isc_boolean_t shutting_down;
isc_eventlist_t whenshutdown;
Start on address.c
1999-09-21 22:46:42 +00:00
};
review checkpoint
1999-11-25 01:23:32 +00:00
/*
* XXXMLG Document these structures.
*/
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
struct dns_adbname {
unsigned int magic;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
dns_name_t name;
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
dns_adb_t *adb;
start on ipv6 bits
1999-10-28 21:50:27 +00:00
unsigned int partial_result;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
unsigned int flags;
clean up; fix hashes
1999-10-29 22:09:31 +00:00
int lock_bucket;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
isc_stdtime_t expire_v4;
isc_stdtime_t expire_v6;
a6 checkpoint
1999-10-30 01:22:16 +00:00
unsigned int chains;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dns_adbnamehooklist_t v4;
dns_adbnamehooklist_t v6;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
dns_adbfetch_t *fetch_a;
dns_adbfetch_t *fetch_aaaa;
a6 checkpoint
1999-10-30 01:22:16 +00:00
ISC_LIST(dns_adbfetch6_t) fetches_a6;
create adb list types
1999-11-05 09:49:53 +00:00
dns_adbfindlist_t finds;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK(dns_adbname_t) plink;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
};
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
struct dns_adbfetch {
unsigned int magic;
dns_adbnamehook_t *namehook;
dns_adbentry_t *entry;
dns_fetch_t *fetch;
dns_rdataset_t rdataset;
};
a6 checkpoint
1999-10-30 01:22:16 +00:00
struct dns_adbfetch6 {
unsigned int magic;
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
unsigned int flags;
a6 checkpoint
1999-10-30 01:22:16 +00:00
dns_adbnamehook_t *namehook;
dns_adbentry_t *entry;
dns_fetch_t *fetch;
dns_rdataset_t rdataset;
dns_a6context_t a6ctx;
ISC_LINK(dns_adbfetch6_t) plink;
};
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
/*
* dns_adbnamehook_t
*
* This is a small widget that dangles off a dns_adbname_t. It contains a
* pointer to the address information about this host, and a link to the next
* namehook that will contain the next address this host has.
*/
struct dns_adbnamehook {
unsigned int magic;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
dns_adbentry_t *entry;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK(dns_adbnamehook_t) plink;
Start on address.c
1999-09-21 22:46:42 +00:00
};
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
/*
* dns_adbzoneinfo_t
*
* This is a small widget that holds zone-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 {
unsigned int magic;
snapshot
1999-10-08 23:12:21 +00:00
dns_name_t zone;
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
isc_stdtime_t lame_timer;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK(dns_adbzoneinfo_t) plink;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
};
/*
* An address entry. It holds quite a bit of information about addresses,
* including edns state, rtt, and of course the address of the host.
*/
Start on address.c
1999-09-21 22:46:42 +00:00
struct dns_adbentry {
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
unsigned int magic;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
int lock_bucket;
snapshot
1999-10-08 23:12:21 +00:00
unsigned int refcnt;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
unsigned int flags;
snapshot
1999-10-20 23:26:06 +00:00
int edns_level; /* must be int! */
int goodness; /* bad < 0 <= good */
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
unsigned int srtt;
isc_sockaddr_t sockaddr;
ISC_LIST(dns_adbzoneinfo_t) zoneinfo;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK(dns_adbentry_t) plink;
Start on address.c
1999-09-21 22:46:42 +00:00
};
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
/*
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
* Internal functions (and prototypes).
*/
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
static inline dns_adbname_t *new_adbname(dns_adb_t *, dns_name_t *);
snapshot
1999-10-08 23:12:21 +00:00
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 **);
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
static inline dns_adbzoneinfo_t *new_adbzoneinfo(dns_adb_t *, dns_name_t *);
snapshot
1999-10-08 23:12:21 +00:00
static inline void free_adbzoneinfo(dns_adb_t *, dns_adbzoneinfo_t **);
static inline dns_adbentry_t *new_adbentry(dns_adb_t *);
static inline void free_adbentry(dns_adb_t *, dns_adbentry_t **);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
static inline dns_adbfind_t *new_adbfind(dns_adb_t *);
static inline void free_adbfind(dns_adb_t *, dns_adbfind_t **);
snapshot
1999-10-08 23:12:21 +00:00
static inline dns_adbaddrinfo_t *new_adbaddrinfo(dns_adb_t *,
dns_adbentry_t *);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
static inline dns_adbfetch_t *new_adbfetch(dns_adb_t *);
static inline void free_adbfetch(dns_adb_t *, dns_adbfetch_t **);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
static inline dns_adbfetch6_t *new_adbfetch6(dns_adb_t *, dns_adbname_t *,
dns_a6context_t *);
a6 checkpoint
1999-10-30 01:22:16 +00:00
static inline void free_adbfetch6(dns_adb_t *, dns_adbfetch6_t **);
snapshot
1999-10-08 23:12:21 +00:00
static inline dns_adbname_t *find_name_and_lock(dns_adb_t *, dns_name_t *,
int *);
static inline dns_adbentry_t *find_entry_and_lock(dns_adb_t *,
isc_sockaddr_t *, int *);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
static void dump_adb(dns_adb_t *, FILE *);
snapshot
1999-10-08 23:12:21 +00:00
static void print_dns_name(FILE *, dns_name_t *);
static void print_namehook_list(FILE *, dns_adbname_t *);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
static void print_find_list(FILE *, dns_adbname_t *);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
static void print_fetch_list(FILE *, dns_adbname_t *);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static inline void inc_adb_irefcnt(dns_adb_t *, isc_boolean_t);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void dec_adb_irefcnt(dns_adb_t *, isc_boolean_t);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static inline void inc_adb_erefcnt(dns_adb_t *, isc_boolean_t);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void dec_adb_erefcnt(dns_adb_t *, isc_boolean_t);
snapshot
1999-10-08 23:12:21 +00:00
static inline void inc_entry_refcnt(dns_adb_t *, dns_adbentry_t *,
isc_boolean_t);
static inline void dec_entry_refcnt(dns_adb_t *, dns_adbentry_t *,
isc_boolean_t);
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
static inline void violate_locking_hierarchy(isc_mutex_t *, isc_mutex_t *);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
static void clean_namehooks(dns_adb_t *, dns_adbnamehooklist_t *);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
static void clean_finds_at_name(dns_adbname_t *, isc_eventtype_t,
unsigned int);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
static void check_expire_namehooks(dns_adbname_t *, isc_stdtime_t);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static void cancel_fetches_at_name(dns_adb_t *, dns_adbname_t *);
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
static isc_result_t dbfind_name(dns_adbname_t *, isc_stdtime_t,
isc_boolean_t, dns_rdatatype_t);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
static isc_result_t fetch_name_v4(dns_adbname_t *, isc_stdtime_t);
static isc_result_t fetch_name_aaaa(dns_adbname_t *, isc_stdtime_t);
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
static isc_result_t fetch_name_a6(dns_adbname_t *, isc_stdtime_t,
isc_boolean_t);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void check_exit(dns_adb_t *);
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
static void timer_cleanup(isc_task_t *, isc_event_t *);
clean up warnings that shouldn't be there.
1999-10-25 23:18:19 +00:00
static void destroy(dns_adb_t *);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static void shutdown_names(dns_adb_t *);
static inline void link_name(dns_adb_t *, int, dns_adbname_t *);
static inline void unlink_name(dns_adb_t *, dns_adbname_t *);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
static void kill_name(dns_adbname_t **, isc_eventtype_t);
static void fetch_callback_a6(isc_task_t *, isc_event_t *);
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
static isc_result_t dbfind_a6(dns_adbname_t *, isc_stdtime_t, isc_boolean_t);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
/*
* MUST NOT overlap DNS_ADBFIND_* flags!
*/
#define FIND_EVENT_SENT 0x40000000
#define FIND_EVENT_FREED 0x80000000
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
#define FIND_EVENTSENT(h) (((h)->flags & FIND_EVENT_SENT) != 0)
#define FIND_EVENTFREED(h) (((h)->flags & FIND_EVENT_FREED) != 0)
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
#define NAME_NEEDS_POKE 0x80000000
#define NAME_IS_DEAD 0x40000000
#define NAME_DEAD(n) (((n)->flags & NAME_IS_DEAD) != 0)
#define NAME_NEEDSPOKE(n) (((n)->flags & NAME_NEEDS_POKE) != 0)
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
/*
* To the name, address classes are all that really exist. If it has a
* V6 address it doesn't care if it came from an A6 chain or an AAAA query.
*/
#define NAME_HAS_V4(n) (!ISC_LIST_EMPTY((n)->v4))
#define NAME_HAS_V6(n) (!ISC_LIST_EMPTY((n)->v6))
#define NAME_HAS_ADDRS(n) (NAME_HAS_V4(n) || NAME_HAS_V6(n))
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
/*
* Fetches are broken out into A, AAAA, and A6 types. In some cases,
* however, it makes more sense to test for a particular class of fetches,
* like V4 or V6 above.
*/
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
#define NAME_FETCH_A(n) ((n)->fetch_a != NULL)
#define NAME_FETCH_AAAA(n) ((n)->fetch_aaaa != NULL)
#define NAME_FETCH_A6(n) (!ISC_LIST_EMPTY((n)->fetches_a6))
#define NAME_FETCH_V4(n) (NAME_FETCH_A(n))
#define NAME_FETCH_V6(n) (NAME_FETCH_AAAA(n) || NAME_FETCH_A6(n))
#define NAME_FETCH(n) (NAME_FETCH_V4(n) || NAME_FETCH_V6(n))
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
/*
* Was this fetch started using the hints database?
* Was this the initial fetch for the A6 record? If so, we might want to
* start AAAA queries if it fails.
*/
#define FETCH_USE_HINTS 0x80000000
#define FETCH_FIRST_A6 0x40000000
#define FETCH_USEHINTS(f) (((f)->flags & FETCH_USE_HINTS) != 0)
#define FETCH_FIRSTA6(f) (((f)->flags & FETCH_FIRST_A6) != 0)
/*
* Find options and tests to see if there are addresses on the list.
*/
#define FIND_WANTEVENT(fn) (((fn)->options & DNS_ADBFIND_WANTEVENT) != 0)
#define FIND_WANTEMPTYEVENT(fn) (((fn)->options & DNS_ADBFIND_EMPTYEVENT) != 0)
#define FIND_HAS_ADDRS(fn) (!ISC_LIST_EMPTY((fn)->list))
/*
* These are currently used on simple unsigned ints, so they are
* not really associated with any particular type.
*/
#define WANT_INET(x) (((x) & DNS_ADBFIND_INET) != 0)
#define WANT_INET6(x) (((x) & DNS_ADBFIND_INET6) != 0)
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
#define EXPIRE_OK(exp, now) ((exp == INT_MAX) || (exp < now))
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
#define ENTER_LEVEL 50
#define EXIT_LEVEL ENTER_LEVEL
#define CLEAN_LEVEL 100
#define DEF_LEVEL 5
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
#define NCACHE_LEVEL 20
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
#define NCACHE_RESULT(r) ((r) == DNS_R_NCACHENXDOMAIN || \
(r) == DNS_R_NCACHENXRRSET)
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
static void
DP(int level, char *format, ...)
{
va_list args;
va_start(args, format);
isc_log_vwrite(dns_lctx,
DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_ADB,
ISC_LOG_DEBUG(level), format, args);
va_end(args);
}
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
/*
* Requires the adbname bucket be locked and that no entry buckets be locked.
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
*
* This code handles A and AAAA rdatasets only.
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
*/
static isc_result_t
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
isc_stdtime_t now)
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
{
isc_result_t result;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dns_adb_t *adb;
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
dns_adbnamehook_t *nh;
dns_rdata_t rdata;
struct in_addr ina;
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
struct in6_addr in6a;
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
isc_sockaddr_t sockaddr;
dns_adbentry_t *foundentry; /* NO CLEAN UP! */
int addr_bucket;
isc_boolean_t new_addresses_added;
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
dns_rdatatype_t rdtype;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
unsigned int findoptions;
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
INSIST(DNS_ADBNAME_VALID(adbname));
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
rdtype = rdataset->type;
INSIST((rdtype == dns_rdatatype_a) || (rdtype == dns_rdatatype_aaaa));
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
if (rdtype == dns_rdatatype_a)
findoptions = DNS_ADBFIND_INET;
more fully implement the 'standard' in6_addr, and use the macros correctly in adb.c
1999-12-02 23:45:30 +00:00
else
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
findoptions = DNS_ADBFIND_INET6;
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
addr_bucket = DNS_ADB_INVALIDBUCKET;
new_addresses_added = ISC_FALSE;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
nh = NULL;
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
result = dns_rdataset_first(rdataset);
while (result == ISC_R_SUCCESS) {
dns_rdataset_current(rdataset, &rdata);
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
if (rdtype == dns_rdatatype_a) {
INSIST(rdata.length == 4);
memcpy(&ina.s_addr, rdata.data, 4);
isc_sockaddr_fromin(&sockaddr, &ina, 53);
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
} else {
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
INSIST(rdata.length == 16);
remove compiler warning
1999-11-01 00:10:10 +00:00
memcpy(in6a.s6_addr, rdata.data, 16);
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
isc_sockaddr_fromin6(&sockaddr, &in6a, 53);
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
}
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
if (IN6_IS_ADDR_V4MAPPED(&sockaddr.type.sin6.sin6_addr)
|| IN6_IS_ADDR_V4COMPAT(&sockaddr.type.sin6.sin6_addr)) {
DP(1, "Ignoring IPv6 mapped IPv4 address");
goto next;
}
INSIST(nh == NULL);
nh = new_adbnamehook(adb, NULL);
if (nh == NULL) {
adbname->partial_result |= findoptions;
result = ISC_R_NOMEMORY;
goto fail;
}
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
foundentry = find_entry_and_lock(adb, &sockaddr, &addr_bucket);
if (foundentry == NULL) {
dns_adbentry_t *entry;
entry = new_adbentry(adb);
if (entry == NULL) {
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
adbname->partial_result |= findoptions;
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
result = ISC_R_NOMEMORY;
goto fail;
}
entry->sockaddr = sockaddr;
entry->refcnt = 1;
entry->lock_bucket = addr_bucket;
nh->entry = entry;
ISC_LIST_APPEND(adb->entries[addr_bucket],
entry, plink);
} else {
foundentry->refcnt++;
nh->entry = foundentry;
}
new_addresses_added = ISC_TRUE;
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
if (rdtype == dns_rdatatype_a)
ISC_LIST_APPEND(adbname->v4, nh, plink);
else
ISC_LIST_APPEND(adbname->v6, nh, plink);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
nh = NULL;
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
next:
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
result = dns_rdataset_next(rdataset);
}
fail:
if (nh != NULL)
free_adbnamehook(adb, &nh);
if (addr_bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->entrylocks[addr_bucket]);
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
rdataset->ttl = ISC_MIN(rdataset->ttl, ADB_CACHE_MINIMUM);
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
if (rdtype == dns_rdatatype_a) {
DP(NCACHE_LEVEL, "expire_v4 set to MIN(%u,%u) import_rdataset",
adbname->expire_v4, now + rdataset->ttl);
adbname->expire_v4 = ISC_MIN(adbname->expire_v4,
now + rdataset->ttl);
} else {
DP(NCACHE_LEVEL, "expire_v6 set to MIN(%u,%u) import_rdataset",
adbname->expire_v6, now + rdataset->ttl);
adbname->expire_v6 = ISC_MIN(adbname->expire_v6,
now + rdataset->ttl);
}
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
if (new_addresses_added) {
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
/*
* Lie a little here. This is more or less so code that cares
* can find out if any new information was added or not.
*/
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
return (ISC_R_SUCCESS);
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
}
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
return (result);
}
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
static void
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
import_a6(dns_a6context_t *a6ctx)
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
{
dns_adbname_t *name;
dns_adb_t *adb;
dns_adbnamehook_t *nh;
dns_adbentry_t *foundentry; /* NO CLEAN UP! */
int addr_bucket;
isc_sockaddr_t sockaddr;
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
name = a6ctx->arg;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
initialize addr_bucket
1999-11-02 00:39:11 +00:00
addr_bucket = DNS_ADB_INVALIDBUCKET;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(ENTER_LEVEL, "ENTER: import_a6() name %p", name);
add a few more logging lines; no functional change.
1999-10-30 02:40:59 +00:00
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
nh = new_adbnamehook(adb, NULL);
if (nh == NULL) {
name->partial_result |= DNS_ADBFIND_INET6; /* clear for AAAA */
goto fail;
}
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
isc_sockaddr_fromin6(&sockaddr, &a6ctx->in6addr, 53);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
if (IN6_IS_ADDR_V4MAPPED(&sockaddr.type.sin6.sin6_addr)
|| IN6_IS_ADDR_V4COMPAT(&sockaddr.type.sin6.sin6_addr)) {
DP(1, "Ignoring IPv6 mapped IPv4 address");
goto fail;
}
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
foundentry = find_entry_and_lock(adb, &sockaddr, &addr_bucket);
if (foundentry == NULL) {
dns_adbentry_t *entry;
entry = new_adbentry(adb);
if (entry == NULL) {
name->partial_result |= DNS_ADBFIND_INET6;
goto fail;
}
entry->sockaddr = sockaddr;
entry->refcnt = 1;
entry->lock_bucket = addr_bucket;
nh->entry = entry;
ISC_LIST_APPEND(adb->entries[addr_bucket], entry, plink);
} else {
foundentry->refcnt++;
nh->entry = foundentry;
}
ISC_LIST_APPEND(name->v6, nh, plink);
nh = NULL;
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
fail:
DP(NCACHE_LEVEL, "expire_v6 set to MIN(%u,%u) in import_v6",
review checkpoint
1999-11-25 01:23:32 +00:00
name->expire_v6, a6ctx->expiration);
name->expire_v6 = ISC_MIN(name->expire_v6, a6ctx->expiration);
name->flags |= NAME_NEEDS_POKE;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (nh != NULL)
free_adbnamehook(adb, &nh);
if (addr_bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->entrylocks[addr_bucket]);
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
/*
* Requires the name's bucket be locked.
*/
static void
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
kill_name(dns_adbname_t **n, isc_eventtype_t ev)
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
{
dns_adbname_t *name;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dns_adb_t *adb;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
INSIST(n != NULL);
name = *n;
*n = NULL;
INSIST(DNS_ADBNAME_VALID(name));
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL, "killing name %p", name);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
Handle the case where kill_name() is called on an already dead name correctly.
1999-10-26 23:57:38 +00:00
/*
* If we're dead already, just check to see if we should go
* away now or not.
*/
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (NAME_DEAD(name) && !NAME_FETCH(name)) {
Handle the case where kill_name() is called on an already dead name correctly.
1999-10-26 23:57:38 +00:00
unlink_name(adb, name);
free_adbname(adb, &name);
return;
}
/*
* Clean up the name's various lists. These two are destructive
* in that they will always empty the list.
*/
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
clean_finds_at_name(name, ev, DNS_ADBFIND_ADDRESSMASK);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
clean_namehooks(adb, &name->v4);
clean_namehooks(adb, &name->v6);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
Handle the case where kill_name() is called on an already dead name correctly.
1999-10-26 23:57:38 +00:00
/*
* If fetches are running, cancel them. If none are running, we can
* just kill the name here.
*/
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (!NAME_FETCH(name)) {
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
unlink_name(adb, name);
free_adbname(adb, &name);
} else {
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
name->flags |= NAME_IS_DEAD;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
cancel_fetches_at_name(adb, name);
}
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
/*
* Requires the name's bucket be locked and no entry buckets be locked.
*/
static void
check_expire_namehooks(dns_adbname_t *name, isc_stdtime_t now)
{
dns_adb_t *adb;
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
/*
* Check to see if we need to remove the v4 addresses
*/
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
if (!NAME_FETCH_V4(name) && EXPIRE_OK(name->expire_v4, now)) {
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (NAME_HAS_V4(name)) {
Don't say we're actually expiring addresses unless we really do.
1999-11-04 08:35:45 +00:00
DP(DEF_LEVEL, "expiring v4 for name %p", name);
clean_namehooks(adb, &name->v4);
reset partial flag only when deleting names
1999-11-04 08:50:12 +00:00
name->partial_result &= ~DNS_ADBFIND_INET;
Don't say we're actually expiring addresses unless we really do.
1999-11-04 08:35:45 +00:00
}
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
name->expire_v4 = INT_MAX;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
/*
* Check to see if we need to remove the v6 addresses
*/
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
if (!NAME_FETCH_V6(name) && EXPIRE_OK(name->expire_v6, now)) {
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (NAME_HAS_V6(name)) {
Don't say we're actually expiring addresses unless we really do.
1999-11-04 08:35:45 +00:00
DP(DEF_LEVEL, "expiring v6 for name %p", name);
clean_namehooks(adb, &name->v6);
reset partial flag only when deleting names
1999-11-04 08:50:12 +00:00
name->partial_result &= ~DNS_ADBFIND_INET6;
Don't say we're actually expiring addresses unless we really do.
1999-11-04 08:35:45 +00:00
}
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
name->expire_v6 = INT_MAX;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
/*
* Requires the name's bucket be locked.
*/
static inline void
link_name(dns_adb_t *adb, int bucket, dns_adbname_t *name)
{
INSIST(name->lock_bucket == DNS_ADB_INVALIDBUCKET);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_PREPEND(adb->names[bucket], name, plink);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
name->lock_bucket = bucket;
adb->name_refcnt[bucket]++;
}
/*
* Requires the name's bucket be locked.
*/
static inline void
unlink_name(dns_adb_t *adb, dns_adbname_t *name)
{
int bucket;
bucket = name->lock_bucket;
INSIST(bucket != DNS_ADB_INVALIDBUCKET);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_UNLINK(adb->names[bucket], name, plink);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
name->lock_bucket = DNS_ADB_INVALIDBUCKET;
INSIST(adb->name_refcnt[bucket] > 0);
adb->name_refcnt[bucket]--;
}
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static inline void
violate_locking_hierarchy(isc_mutex_t *have, isc_mutex_t *want)
{
if (isc_mutex_trylock(want) != ISC_R_SUCCESS) {
UNLOCK(have);
LOCK(want);
LOCK(have);
}
}
/*
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
* The ADB _MUST_ be locked before calling. Also, exit conditions must be
* checked after calling this function.
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
*/
static void
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
shutdown_names(dns_adb_t *adb)
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
{
int bucket;
dns_adbname_t *name;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
dns_adbname_t *next_name;
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (bucket = 0 ; bucket < NBUCKETS ; bucket++) {
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
LOCK(&adb->namelocks[bucket]);
adb->name_sd[bucket] = ISC_TRUE;
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* Run through the list. For each name, clean up finds
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
* found there, and cancel any fetches running. When
* all the fetches are canceled, the name will destroy
* itself.
*/
name = ISC_LIST_HEAD(adb->names[bucket]);
while (name != NULL) {
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
next_name = ISC_LIST_NEXT(name, plink);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
kill_name(&name, DNS_EVENT_ADBSHUTDOWN);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
name = next_name;
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
/* kill_name() will decrement the refcnt. */
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
if (adb->name_refcnt[bucket] == 0)
dec_adb_irefcnt(adb, ISC_FALSE);
UNLOCK(&adb->namelocks[bucket]);
}
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
/*
* Name bucket must be locked
*/
static void
cancel_fetches_at_name(dns_adb_t *adb, dns_adbname_t *name)
{
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
dns_adbfetch6_t *fetch6;
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (NAME_FETCH_A(name))
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
dns_resolver_cancelfetch(adb->view->resolver,
name->fetch_a->fetch);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (NAME_FETCH_AAAA(name))
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
dns_resolver_cancelfetch(adb->view->resolver,
name->fetch_aaaa->fetch);
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
fetch6 = ISC_LIST_HEAD(name->fetches_a6);
while (fetch6 != NULL) {
dns_resolver_cancelfetch(adb->view->resolver, fetch6->fetch);
fetch6 = ISC_LIST_NEXT(fetch6, plink);
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
}
snapshot
1999-10-20 23:26:06 +00:00
/*
* Assumes the name bucket is locked.
*/
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static void
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
clean_namehooks(dns_adb_t *adb, dns_adbnamehooklist_t *namehooks)
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
{
dns_adbentry_t *entry;
dns_adbnamehook_t *namehook;
int addr_bucket;
addr_bucket = DNS_ADB_INVALIDBUCKET;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
namehook = ISC_LIST_HEAD(*namehooks);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
while (namehook != NULL) {
INSIST(DNS_ADBNAMEHOOK_VALID(namehook));
/*
* Clean up the entry if needed.
*/
entry = namehook->entry;
if (entry != NULL) {
INSIST(DNS_ADBENTRY_VALID(entry));
if (addr_bucket != entry->lock_bucket) {
if (addr_bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->entrylocks[addr_bucket]);
addr_bucket = entry->lock_bucket;
LOCK(&adb->entrylocks[addr_bucket]);
}
dec_entry_refcnt(adb, entry, ISC_FALSE);
}
/*
* Free the namehook
*/
namehook->entry = NULL;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_UNLINK(*namehooks, namehook, plink);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
free_adbnamehook(adb, &namehook);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
namehook = ISC_LIST_HEAD(*namehooks);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
}
if (addr_bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->entrylocks[addr_bucket]);
}
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
/*
* Assumes nothing is locked, since this is called by the client.
*/
static void
event_free(isc_event_t *event)
{
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
INSIST(event != NULL);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find = event->destroy_arg;
INSIST(DNS_ADBFIND_VALID(find));
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
LOCK(&find->lock);
find->flags |= FIND_EVENT_FREED;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
event->destroy_arg = NULL;
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
UNLOCK(&find->lock);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
}
snapshot
1999-10-20 23:26:06 +00:00
/*
* Assumes the name bucket is locked.
*/
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static void
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
clean_finds_at_name(dns_adbname_t *name, isc_eventtype_t evtype,
unsigned int addrs)
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
{
isc_event_t *ev;
isc_task_t *task;
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
dns_adbfind_t *next_find;
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
isc_boolean_t process;
unsigned int wanted;
DP(ENTER_LEVEL,
"ENTER clean_finds_at_name, name %p, evtype %08x, addrs %08x",
name, evtype, addrs);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find = ISC_LIST_HEAD(name->finds);
while (find != NULL) {
LOCK(&find->lock);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
next_find = ISC_LIST_NEXT(find, plink);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
process = ISC_FALSE;
wanted = find->flags & DNS_ADBFIND_ADDRESSMASK;
switch (evtype) {
case DNS_EVENT_ADBMOREADDRESSES:
move some debugging output from level 1 to level 3
1999-11-23 20:52:34 +00:00
DP(3, "DNS_EVENT_ADBMOREADDRESSES");
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
if ((wanted & addrs) != 0) {
move some debugging output from level 1 to level 3
1999-11-23 20:52:34 +00:00
DP(3, "processing");
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
find->flags &= ~addrs;
process = ISC_TRUE;
}
break;
case DNS_EVENT_ADBNOMOREADDRESSES:
move some debugging output from level 1 to level 3
1999-11-23 20:52:34 +00:00
DP(3, "DNS_EVENT_ADBNOMOREADDRESSES");
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
find->flags &= ~addrs;
wanted = find->flags & DNS_ADBFIND_ADDRESSMASK;
if (wanted == 0) {
process = ISC_TRUE;
move some debugging output from level 1 to level 3
1999-11-23 20:52:34 +00:00
DP(3, "processing");
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
}
break;
default:
find->flags &= ~addrs;
process = ISC_TRUE;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
}
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
if (process) {
DP(DEF_LEVEL, "cfan: processing find %p", find);
/*
* Unlink the find from the name, letting the caller
* call dns_adb_destroyfind() on it to clean it up
* later.
*/
ISC_LIST_UNLINK(name->finds, find, plink);
find->adbname = NULL;
find->name_bucket = DNS_ADB_INVALIDBUCKET;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
INSIST(!FIND_EVENTSENT(find));
A debugging statement was in the wrong place.
1999-10-29 03:05:24 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
ev = &find->event;
task = ev->sender;
ev->sender = find;
ev->type = evtype;
ev->destroy = event_free;
ev->destroy_arg = find;
A debugging statement was in the wrong place.
1999-10-29 03:05:24 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
"Sending event %p to task %p for find %p",
ev, task, find);
isc_task_sendanddetach(&task, &ev);
} else {
DP(DEF_LEVEL, "cfan: skipping find %p", find);
}
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
UNLOCK(&find->lock);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
find = next_find;
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
}
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(ENTER_LEVEL, "EXIT clean_finds_at_name, name %p", name);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
check_exit(dns_adb_t *adb)
{
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
isc_event_t *event, *next_event;
isc_task_t *etask;
/*
* The caller must be holding the adb lock.
*/
if (adb->shutting_down && adb->irefcnt == 0 &&
isc_mempool_getallocated(adb->ahmp) == 0) {
/*
* We're now shutdown. Send any whenshutdown events.
*/
for (event = ISC_LIST_HEAD(adb->whenshutdown);
event != NULL;
event = next_event) {
next_event = ISC_LIST_NEXT(event, link);
ISC_LIST_UNLINK(adb->whenshutdown, event, link);
etask = event->sender;
event->sender = adb;
isc_task_sendanddetach(&etask, &event);
}
/*
* If there aren't any external references either, we're
* done. Send the control event to initiate shutdown.
*/
if (adb->erefcnt == 0) {
INSIST(!adb->cevent_sent); /* Sanity check. */
event = &adb->cevent;
isc_task_send(adb->task, &event);
adb->cevent_sent = ISC_TRUE;
}
}
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
}
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
static inline void
inc_adb_irefcnt(dns_adb_t *adb, isc_boolean_t lock)
{
if (lock)
LOCK(&adb->lock);
adb->irefcnt++;
if (lock)
UNLOCK(&adb->lock);
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
dec_adb_irefcnt(dns_adb_t *adb, isc_boolean_t lock)
{
if (lock)
LOCK(&adb->lock);
INSIST(adb->irefcnt > 0);
adb->irefcnt--;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
check_exit(adb);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
if (lock)
UNLOCK(&adb->lock);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline void
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
inc_adb_erefcnt(dns_adb_t *adb, isc_boolean_t lock)
snapshot
1999-10-05 23:50:43 +00:00
{
if (lock)
LOCK(&adb->lock);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
adb->erefcnt++;
snapshot
1999-10-05 23:50:43 +00:00
if (lock)
UNLOCK(&adb->lock);
}
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
static inline void
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
dec_adb_erefcnt(dns_adb_t *adb, isc_boolean_t lock)
snapshot
1999-10-05 23:50:43 +00:00
{
if (lock)
LOCK(&adb->lock);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
INSIST(adb->erefcnt > 0);
adb->erefcnt--;
snapshot
1999-10-05 23:50:43 +00:00
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
check_exit(adb);
snapshot
1999-10-05 23:50:43 +00:00
if (lock)
UNLOCK(&adb->lock);
}
snapshot
1999-10-08 23:12:21 +00:00
static inline void
inc_entry_refcnt(dns_adb_t *adb, dns_adbentry_t *entry, isc_boolean_t lock)
{
int bucket;
bucket = entry->lock_bucket;
if (lock)
LOCK(&adb->entrylocks[bucket]);
entry->refcnt++;
if (lock)
UNLOCK(&adb->entrylocks[bucket]);
}
static inline void
dec_entry_refcnt(dns_adb_t *adb, dns_adbentry_t *entry, isc_boolean_t lock)
{
int bucket;
isc_boolean_t destroy_entry;
bucket = entry->lock_bucket;
if (lock)
LOCK(&adb->entrylocks[bucket]);
INSIST(entry->refcnt > 0);
entry->refcnt--;
destroy_entry = ISC_FALSE;
if (entry->refcnt == 0) {
destroy_entry = ISC_TRUE;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_UNLINK(adb->entries[bucket], entry, plink);
snapshot
1999-10-08 23:12:21 +00:00
}
if (lock)
UNLOCK(&adb->entrylocks[bucket]);
if (!destroy_entry)
return;
entry->lock_bucket = DNS_ADB_INVALIDBUCKET;
free_adbentry(adb, &entry);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbname_t *
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
new_adbname(dns_adb_t *adb, dns_name_t *dnsname)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
{
dns_adbname_t *name;
name = isc_mempool_get(adb->nmp);
if (name == NULL)
return (NULL);
dns_name_init(&name->name, NULL);
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
if (dns_name_dup(dnsname, adb->mctx, &name->name) != ISC_R_SUCCESS) {
isc_mempool_put(adb->nmp, name);
return (NULL);
}
name->magic = DNS_ADBNAME_MAGIC;
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
name->adb = adb;
start on ipv6 bits
1999-10-28 21:50:27 +00:00
name->partial_result = 0;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
name->flags = 0;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
name->expire_v4 = INT_MAX;
name->expire_v6 = INT_MAX;
a6 checkpoint
1999-10-30 01:22:16 +00:00
name->chains = 0;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
name->lock_bucket = DNS_ADB_INVALIDBUCKET;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
ISC_LIST_INIT(name->v4);
ISC_LIST_INIT(name->v6);
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
name->fetch_a = NULL;
name->fetch_aaaa = NULL;
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
ISC_LIST_INIT(name->fetches_a6);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ISC_LIST_INIT(name->finds);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(name, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (name);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline void
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
free_adbname(dns_adb_t *adb, dns_adbname_t **name)
{
dns_adbname_t *n;
INSIST(name != NULL && DNS_ADBNAME_VALID(*name));
n = *name;
*name = NULL;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
INSIST(!NAME_HAS_V4(n));
INSIST(!NAME_HAS_V6(n));
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
INSIST(!NAME_FETCH(n));
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
INSIST(ISC_LIST_EMPTY(n->finds));
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
INSIST(!ISC_LINK_LINKED(n, plink));
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
INSIST(n->lock_bucket == DNS_ADB_INVALIDBUCKET);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
INSIST(n->adb == adb);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
n->magic = 0;
dns_name_free(&n->name, adb->mctx);
isc_mempool_put(adb->nmp, n);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbnamehook_t *
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
new_adbnamehook(dns_adb_t *adb, dns_adbentry_t *entry)
{
dns_adbnamehook_t *nh;
nh = isc_mempool_get(adb->nhmp);
if (nh == NULL)
return (NULL);
nh->magic = DNS_ADBNAMEHOOK_MAGIC;
nh->entry = entry;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(nh, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (nh);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline void
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook)
{
dns_adbnamehook_t *nh;
INSIST(namehook != NULL && DNS_ADBNAMEHOOK_VALID(*namehook));
nh = *namehook;
*namehook = NULL;
INSIST(nh->entry == NULL);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
INSIST(!ISC_LINK_LINKED(nh, plink));
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
nh->magic = 0;
isc_mempool_put(adb->nhmp, nh);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbzoneinfo_t *
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
new_adbzoneinfo(dns_adb_t *adb, dns_name_t *zone)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
{
dns_adbzoneinfo_t *zi;
zi = isc_mempool_get(adb->zimp);
if (zi == NULL)
return (NULL);
snapshot
1999-10-08 23:12:21 +00:00
dns_name_init(&zi->zone, NULL);
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
if (dns_name_dup(zone, adb->mctx, &zi->zone) != ISC_R_SUCCESS) {
isc_mempool_put(adb->zimp, zi);
return (NULL);
}
zi->magic = DNS_ADBZONEINFO_MAGIC;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
zi->lame_timer = 0;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(zi, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (zi);
}
snapshot
1999-10-08 23:12:21 +00:00
static inline void
free_adbzoneinfo(dns_adb_t *adb, dns_adbzoneinfo_t **zoneinfo)
{
dns_adbzoneinfo_t *zi;
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
INSIST(zoneinfo != NULL && DNS_ADBZONEINFO_VALID(*zoneinfo));
snapshot
1999-10-08 23:12:21 +00:00
zi = *zoneinfo;
*zoneinfo = NULL;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
INSIST(!ISC_LINK_LINKED(zi, plink));
snapshot
1999-10-08 23:12:21 +00:00
dns_name_free(&zi->zone, adb->mctx);
zi->magic = 0;
isc_mempool_put(adb->zimp, zi);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbentry_t *
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
new_adbentry(dns_adb_t *adb)
{
dns_adbentry_t *e;
snapshot
1999-10-20 23:26:06 +00:00
isc_uint32_t r;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
e = isc_mempool_get(adb->emp);
if (e == NULL)
return (NULL);
e->magic = DNS_ADBENTRY_MAGIC;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
e->lock_bucket = DNS_ADB_INVALIDBUCKET;
snapshot
1999-10-08 23:12:21 +00:00
e->refcnt = 0;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
e->flags = 0;
e->goodness = 0;
snapshot
1999-10-20 23:26:06 +00:00
isc_random_get(&adb->rand, &r);
e->srtt = (r & 0x1f) + 1;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
ISC_LIST_INIT(e->zoneinfo);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(e, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (e);
}
snapshot
1999-10-05 23:50:43 +00:00
static inline void
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
free_adbentry(dns_adb_t *adb, dns_adbentry_t **entry)
{
dns_adbentry_t *e;
Clean up zoneinfo when freeing the entry. This makes more sense, since we will always want to do this anyway, and less code duplication means less places to forget to do it.
1999-10-19 21:42:56 +00:00
dns_adbzoneinfo_t *zi;
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
INSIST(entry != NULL && DNS_ADBENTRY_VALID(*entry));
e = *entry;
*entry = NULL;
INSIST(e->lock_bucket == DNS_ADB_INVALIDBUCKET);
snapshot
1999-10-08 23:12:21 +00:00
INSIST(e->refcnt == 0);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
INSIST(!ISC_LINK_LINKED(e, plink));
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
e->magic = 0;
Clean up zoneinfo when freeing the entry. This makes more sense, since we will always want to do this anyway, and less code duplication means less places to forget to do it.
1999-10-19 21:42:56 +00:00
zi = ISC_LIST_HEAD(e->zoneinfo);
while (zi != NULL) {
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_UNLINK(e->zoneinfo, zi, plink);
Clean up zoneinfo when freeing the entry. This makes more sense, since we will always want to do this anyway, and less code duplication means less places to forget to do it.
1999-10-19 21:42:56 +00:00
free_adbzoneinfo(adb, &zi);
zi = ISC_LIST_HEAD(e->zoneinfo);
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
isc_mempool_put(adb->emp, e);
}
dns_adbhandle_t -> dns_adbfind_t
1999-10-29 18:07:32 +00:00
static inline dns_adbfind_t *
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
new_adbfind(dns_adb_t *adb)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
{
dns_adbhandle_t -> dns_adbfind_t
1999-10-29 18:07:32 +00:00
dns_adbfind_t *h;
clean up public vs. private items
1999-09-25 01:44:41 +00:00
isc_result_t result;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
h = isc_mempool_get(adb->ahmp);
if (h == NULL)
return (NULL);
clean up public vs. private items
1999-09-25 01:44:41 +00:00
/*
* public members
*/
h->magic = 0;
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
h->adb = adb;
start on ipv6 bits
1999-10-28 21:50:27 +00:00
h->partial_result = 0;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
h->options = 0;
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
h->flags = 0;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(h, publink);
add plink
1999-10-28 20:09:51 +00:00
ISC_LINK_INIT(h, plink);
clean up public vs. private items
1999-09-25 01:44:41 +00:00
ISC_LIST_INIT(h->list);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
h->adbname = NULL;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
h->name_bucket = DNS_ADB_INVALIDBUCKET;
clean up public vs. private items
1999-09-25 01:44:41 +00:00
/*
* private members
*/
result = isc_mutex_init(&h->lock);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
"isc_mutex_init failed in new_adbfind()");
clean up public vs. private items
1999-09-25 01:44:41 +00:00
isc_mempool_put(adb->ahmp, h);
return (NULL);
}
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
ISC_EVENT_INIT(&h->event, sizeof (isc_event_t), 0, 0, 0, NULL, NULL,
NULL, NULL, h);
dns_adbhandle_t -> dns_adbfind_t
1999-10-29 18:07:32 +00:00
h->magic = DNS_ADBFIND_MAGIC;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (h);
}
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
static inline dns_adbfetch_t *
new_adbfetch(dns_adb_t *adb)
{
dns_adbfetch_t *f;
f = isc_mempool_get(adb->afmp);
if (f == NULL)
return (NULL);
f->magic = 0;
f->namehook = NULL;
f->entry = NULL;
f->fetch = NULL;
f->namehook = new_adbnamehook(adb, NULL);
if (f->namehook == NULL)
goto err;
f->entry = new_adbentry(adb);
if (f->entry == NULL)
goto err;
dns_rdataset_init(&f->rdataset);
f->magic = DNS_ADBFETCH_MAGIC;
return (f);
err:
if (f->namehook != NULL)
free_adbnamehook(adb, &f->namehook);
if (f->entry != NULL)
free_adbentry(adb, &f->entry);
isc_mempool_put(adb->afmp, f);
return (NULL);
}
static inline void
free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetch)
{
dns_adbfetch_t *f;
INSIST(fetch != NULL && DNS_ADBFETCH_VALID(*fetch));
f = *fetch;
*fetch = NULL;
f->magic = 0;
if (f->namehook != NULL)
free_adbnamehook(adb, &f->namehook);
if (f->entry != NULL)
free_adbentry(adb, &f->entry);
remove duplicate checks
1999-10-28 00:37:31 +00:00
if (dns_rdataset_isassociated(&f->rdataset))
dns_rdataset_disassociate(&f->rdataset);
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
isc_mempool_put(adb->afmp, f);
}
a6 checkpoint
1999-10-30 01:22:16 +00:00
/*
* Caller must be holding the name lock.
*/
static isc_result_t
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
a6find(void *arg, dns_name_t *a6name, dns_rdatatype_t type, isc_stdtime_t now,
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
{
a6 checkpoint
1999-10-30 01:22:16 +00:00
dns_adbname_t *name;
dns_adb_t *adb;
name = arg;
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
return (dns_view_find(adb->view, a6name, type, now,
add missing DNS_DBFIND_GLUEOK
1999-11-03 03:20:16 +00:00
DNS_DBFIND_GLUEOK, ISC_FALSE,
a6 checkpoint
1999-10-30 01:22:16 +00:00
rdataset, sigrdataset));
}
/*
* Caller must be holding the name lock.
*/
static void
a6missing(dns_a6context_t *a6ctx, dns_name_t *a6name) {
dns_adbname_t *name;
dns_adb_t *adb;
dns_adbfetch6_t *fetch;
isc_result_t result;
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
dns_rdataset_t nameservers;
dns_name_t fname;
isc_buffer_t buffer;
unsigned char ndata[256];
a6 checkpoint
1999-10-30 01:22:16 +00:00
name = a6ctx->arg;
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
isc_buffer_init(&buffer, ndata, sizeof(ndata), ISC_BUFFERTYPE_BINARY);
dns_name_init(&fname, NULL);
dns_name_setbuffer(&fname, &buffer);
dns_rdataset_init(&nameservers);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
fetch = new_adbfetch6(adb, name, a6ctx);
a6 checkpoint
1999-10-30 01:22:16 +00:00
if (fetch == NULL) {
name->partial_result |= DNS_ADBFIND_INET6;
return;
}
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
result = dns_view_findzonecut(adb->view, a6name, &fname, a6ctx->now,
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
0, ISC_TRUE, &nameservers, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
a6 checkpoint
1999-10-30 01:22:16 +00:00
result = dns_resolver_createfetch(adb->view->resolver, a6name,
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
dns_rdatatype_a6, &fname,
&nameservers, NULL, 0,
adb->task, fetch_callback_a6,
a6 checkpoint
1999-10-30 01:22:16 +00:00
name, &fetch->rdataset, NULL,
&fetch->fetch);
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
if (result != ISC_R_SUCCESS)
goto cleanup;
name->chains = a6ctx->chains;
ISC_LIST_APPEND(name->fetches_a6, fetch, plink);
cleanup:
a6 checkpoint
1999-10-30 01:22:16 +00:00
if (result != ISC_R_SUCCESS) {
free_adbfetch6(adb, &fetch);
name->partial_result |= DNS_ADBFIND_INET6;
}
}
static inline dns_adbfetch6_t *
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
new_adbfetch6(dns_adb_t *adb, dns_adbname_t *name, dns_a6context_t *a6ctx)
a6 checkpoint
1999-10-30 01:22:16 +00:00
{
dns_adbfetch6_t *f;
f = isc_mempool_get(adb->af6mp);
if (f == NULL)
return (NULL);
f->magic = 0;
f->namehook = NULL;
f->entry = NULL;
f->fetch = NULL;
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
f->flags = 0;
a6 checkpoint
1999-10-30 01:22:16 +00:00
f->namehook = new_adbnamehook(adb, NULL);
if (f->namehook == NULL)
goto err;
f->entry = new_adbentry(adb);
if (f->entry == NULL)
goto err;
dns_rdataset_init(&f->rdataset);
initialize a6 chain correctly before copying
1999-10-30 03:41:34 +00:00
dns_a6_init(&f->a6ctx, a6find, NULL, import_a6,
a6missing, name);
a6 checkpoint
1999-10-30 01:22:16 +00:00
if (a6ctx != NULL)
dns_a6_copy(a6ctx, &f->a6ctx);
f->magic = DNS_ADBFETCH6_MAGIC;
return (f);
err:
if (f->namehook != NULL)
free_adbnamehook(adb, &f->namehook);
if (f->entry != NULL)
free_adbentry(adb, &f->entry);
isc_mempool_put(adb->af6mp, f);
return (NULL);
}
static inline void
free_adbfetch6(dns_adb_t *adb, dns_adbfetch6_t **fetch)
{
dns_adbfetch6_t *f;
INSIST(fetch != NULL && DNS_ADBFETCH6_VALID(*fetch));
f = *fetch;
*fetch = NULL;
f->magic = 0;
if (f->namehook != NULL)
free_adbnamehook(adb, &f->namehook);
if (f->entry != NULL)
free_adbentry(adb, &f->entry);
if (dns_rdataset_isassociated(&f->rdataset))
dns_rdataset_disassociate(&f->rdataset);
isc_mempool_put(adb->af6mp, f);
}
snapshot
1999-10-08 23:12:21 +00:00
static inline void
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
free_adbfind(dns_adb_t *adb, dns_adbfind_t **findp)
snapshot
1999-10-08 23:12:21 +00:00
{
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
snapshot
1999-10-08 23:12:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
INSIST(findp != NULL && DNS_ADBFIND_VALID(*findp));
find = *findp;
*findp = NULL;
snapshot
1999-10-08 23:12:21 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
INSIST(!FIND_HAS_ADDRS(find));
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
INSIST(!ISC_LINK_LINKED(find, publink));
INSIST(!ISC_LINK_LINKED(find, plink));
INSIST(find->name_bucket == DNS_ADB_INVALIDBUCKET);
INSIST(find->adbname == NULL);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->magic = 0;
snapshot
1999-10-08 23:12:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
isc_mutex_destroy(&find->lock);
isc_mempool_put(adb->ahmp, find);
snapshot
1999-10-08 23:12:21 +00:00
}
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
* Copy bits from the entry into the newly allocated addrinfo. The entry
* must be locked, and the reference count must be bumped up by one
* if this function returns a valid pointer.
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
*/
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbaddrinfo_t *
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry)
{
dns_adbaddrinfo_t *ai;
ai = isc_mempool_get(adb->aimp);
if (ai == NULL)
return (NULL);
ai->magic = DNS_ADBADDRINFO_MAGIC;
ai->sockaddr = &entry->sockaddr;
ai->goodness = entry->goodness;
ai->srtt = entry->srtt;
ai->flags = entry->flags;
ai->entry = entry;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LINK_INIT(ai, publink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (ai);
}
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
static inline void
free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo)
{
dns_adbaddrinfo_t *ai;
INSIST(ainfo != NULL && DNS_ADBADDRINFO_VALID(*ainfo));
ai = *ainfo;
*ainfo = NULL;
INSIST(ai->sockaddr == NULL);
INSIST(ai->entry == NULL);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
INSIST(!ISC_LINK_LINKED(ai, publink));
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
ai->magic = 0;
isc_mempool_put(adb->aimp, ai);
}
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
* Search for the name. NOTE: The bucket is kept locked on both
* success and failure, so it must always be unlocked by the caller!
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
*
* On the first call to this function, *bucketp must be set to
* DNS_ADB_INVALIDBUCKET.
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*/
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbname_t *
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
find_name_and_lock(dns_adb_t *adb, dns_name_t *name, int *bucketp)
{
dns_adbname_t *adbname;
snapshot
1999-10-05 23:50:43 +00:00
int bucket;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
bucket = dns_name_hash(name, ISC_FALSE) % NBUCKETS;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
snapshot
1999-10-05 23:50:43 +00:00
if (*bucketp == DNS_ADB_INVALIDBUCKET) {
LOCK(&adb->namelocks[bucket]);
*bucketp = bucket;
} else if (*bucketp != bucket) {
UNLOCK(&adb->namelocks[*bucketp]);
LOCK(&adb->namelocks[bucket]);
*bucketp = bucket;
}
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
adbname = ISC_LIST_HEAD(adb->names[bucket]);
while (adbname != NULL) {
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (!NAME_DEAD(adbname)) {
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
if (dns_name_equal(name, &adbname->name))
return (adbname);
}
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
adbname = ISC_LIST_NEXT(adbname, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
}
return (NULL);
}
/*
* Search for the address. NOTE: The bucket is kept locked on both
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
* success and failure, so it must always be unlocked by the caller.
*
* On the first call to this function, *bucketp must be set to
* DNS_ADB_INVALIDBUCKET. This will cause a lock to occur. On
* later calls (within the same "lock path") it can be left alone, so
* if this function is called multiple times locking is only done if
* the bucket changes.
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*/
snapshot
1999-10-05 23:50:43 +00:00
static inline dns_adbentry_t *
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
find_entry_and_lock(dns_adb_t *adb, isc_sockaddr_t *addr, int *bucketp)
{
dns_adbentry_t *entry;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
int bucket;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
bucket = isc_sockaddr_hash(addr, ISC_TRUE) % NBUCKETS;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
if (*bucketp == DNS_ADB_INVALIDBUCKET) {
LOCK(&adb->entrylocks[bucket]);
*bucketp = bucket;
} else if (*bucketp != bucket) {
UNLOCK(&adb->entrylocks[*bucketp]);
LOCK(&adb->entrylocks[bucket]);
*bucketp = bucket;
}
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
entry = ISC_LIST_HEAD(adb->entries[bucket]);
while (entry != NULL) {
if (isc_sockaddr_equal(addr, &entry->sockaddr))
return (entry);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
entry = ISC_LIST_NEXT(entry, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
}
return (NULL);
}
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
/*
* Entry bucket MUST be locked!
*/
static isc_boolean_t
snapshot
1999-10-20 23:26:06 +00:00
entry_is_bad_for_zone(dns_adb_t *adb, dns_adbentry_t *entry, dns_name_t *zone,
isc_stdtime_t now)
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
{
dns_adbzoneinfo_t *zi, *next_zi;
isc_boolean_t is_bad;
is_bad = ISC_FALSE;
zi = ISC_LIST_HEAD(entry->zoneinfo);
if (zi == NULL)
return (ISC_FALSE);
while (zi != NULL) {
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
next_zi = ISC_LIST_NEXT(zi, plink);
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
/*
* Has the entry expired?
*/
if (zi->lame_timer < now) {
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_UNLINK(entry->zoneinfo, zi, plink);
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
free_adbzoneinfo(adb, &zi);
}
snapshot
1999-10-20 23:26:06 +00:00
/*
* Order tests from least to most expensive.
*/
if (zi != NULL && !is_bad) {
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
if (dns_name_equal(zone, &zi->zone))
is_bad = ISC_TRUE;
snapshot
1999-10-20 23:26:06 +00:00
}
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
zi = next_zi;
}
return (is_bad);
}
snapshot
1999-10-08 23:12:21 +00:00
static void
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_name_t *zone,
dns_adbname_t *name, isc_stdtime_t now)
snapshot
1999-10-08 23:12:21 +00:00
{
dns_adbnamehook_t *namehook;
dns_adbaddrinfo_t *addrinfo;
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
int bucket;
snapshot
1999-10-08 23:12:21 +00:00
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
bucket = DNS_ADB_INVALIDBUCKET;
snapshot
1999-10-08 23:12:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
if (find->options & DNS_ADBFIND_INET) {
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
namehook = ISC_LIST_HEAD(name->v4);
while (namehook != NULL) {
bucket = namehook->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
if (entry_is_bad_for_zone(adb, namehook->entry,
zone, now))
goto nextv4;
addrinfo = new_adbaddrinfo(adb, namehook->entry);
if (addrinfo == NULL) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->partial_result |= DNS_ADBFIND_INET;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
goto out;
}
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* Found a valid entry. Add it to the find's list.
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
*/
inc_entry_refcnt(adb, namehook->entry, ISC_FALSE);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ISC_LIST_APPEND(find->list, addrinfo, publink);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
addrinfo = NULL;
nextv4:
UNLOCK(&adb->entrylocks[bucket]);
bucket = DNS_ADB_INVALIDBUCKET;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
namehook = ISC_LIST_NEXT(namehook, plink);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
}
}
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
if (find->options & DNS_ADBFIND_INET6) {
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
namehook = ISC_LIST_HEAD(name->v6);
while (namehook != NULL) {
bucket = namehook->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
if (entry_is_bad_for_zone(adb, namehook->entry,
zone, now))
goto nextv6;
addrinfo = new_adbaddrinfo(adb, namehook->entry);
if (addrinfo == NULL) {
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
find->partial_result |= DNS_ADBFIND_INET6;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
goto out;
}
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* Found a valid entry. Add it to the find's list.
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
*/
inc_entry_refcnt(adb, namehook->entry, ISC_FALSE);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ISC_LIST_APPEND(find->list, addrinfo, publink);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
addrinfo = NULL;
nextv6:
UNLOCK(&adb->entrylocks[bucket]);
bucket = DNS_ADB_INVALIDBUCKET;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
namehook = ISC_LIST_NEXT(namehook, plink);
snapshot
1999-10-08 23:12:21 +00:00
}
}
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
out:
if (bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->entrylocks[bucket]);
snapshot
1999-10-08 23:12:21 +00:00
}
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
static void
shutdown_task(isc_task_t *task, isc_event_t *ev)
{
dns_adb_t *adb;
clean up warnings that shouldn't be there.
1999-10-25 23:18:19 +00:00
(void)task; /* not used */
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
adb = ev->arg;
INSIST(DNS_ADB_VALID(adb));
/*
* Kill the timer, and then the ADB itself. Note that this implies
* that this task was the one scheduled to get timer events. If
* this is not true (and it is unfortunate there is no way to INSIST()
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
* this) badness will occur.
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
*/
LOCK(&adb->lock);
isc_timer_detach(&adb->timer);
UNLOCK(&adb->lock);
isc_event_free(&ev);
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
destroy(adb);
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
}
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
/*
cleanup snapshot
1999-10-29 23:53:12 +00:00
* name bucket must be locked; adb may be locked; no other locks held.
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
*/
static void
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
check_expire_name(dns_adbname_t **namep, isc_stdtime_t now)
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
{
cleanup snapshot
1999-10-29 23:53:12 +00:00
dns_adbname_t *name;
INSIST(namep != NULL && DNS_ADBNAME_VALID(*namep));
name = *namep;
*namep = NULL;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (NAME_HAS_V4(name) || NAME_HAS_V6(name))
cleanup snapshot
1999-10-29 23:53:12 +00:00
return;
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (NAME_FETCH(name))
cleanup snapshot
1999-10-29 23:53:12 +00:00
return;
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
if (!EXPIRE_OK(name->expire_v4, now))
return;
if (!EXPIRE_OK(name->expire_v6, now))
return;
cleanup snapshot
1999-10-29 23:53:12 +00:00
/*
* The name is empty. Delete it.
*/
kill_name(&name, DNS_EVENT_ADBEXPIRED);
}
/*
* ADB must be locked, and no other locks held.
*/
static void
cleanup_names(dns_adb_t *adb, int bucket, isc_stdtime_t now)
{
dns_adbname_t *name;
dns_adbname_t *next_name;
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(CLEAN_LEVEL, "cleaning bucket %d", bucket);
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
cleanup snapshot
1999-10-29 23:53:12 +00:00
LOCK(&adb->namelocks[bucket]);
if (adb->name_sd[bucket]) {
UNLOCK(&adb->namelocks[bucket]);
return;
}
name = ISC_LIST_HEAD(adb->names[bucket]);
while (name != NULL) {
next_name = ISC_LIST_NEXT(name, plink);
check_expire_namehooks(name, now);
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
check_expire_name(&name, now);
cleanup snapshot
1999-10-29 23:53:12 +00:00
name = next_name;
}
UNLOCK(&adb->namelocks[bucket]);
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
}
static void
timer_cleanup(isc_task_t *task, isc_event_t *ev)
{
dns_adb_t *adb;
isc_result_t result;
cleanup snapshot
1999-10-29 23:53:12 +00:00
isc_stdtime_t now;
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
clean up warnings that shouldn't be there.
1999-10-25 23:18:19 +00:00
(void)task; /* not used */
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
adb = ev->arg;
INSIST(DNS_ADB_VALID(adb));
LOCK(&adb->lock);
cleanup snapshot
1999-10-29 23:53:12 +00:00
result = isc_stdtime_get(&now);
if (result != ISC_R_SUCCESS) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
"isc_stdtime_get() failed! Resetting clean timer.");
cleanup snapshot
1999-10-29 23:53:12 +00:00
goto reset;
}
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
/*
* Call our cleanup routine.
*/
cleanup snapshot
1999-10-29 23:53:12 +00:00
cleanup_names(adb, adb->next_namebucket, now);
/*
* Set the next bucket to be cleaned.
*/
adb->next_namebucket++;
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
if (adb->next_namebucket >= NBUCKETS) {
cleanup snapshot
1999-10-29 23:53:12 +00:00
adb->next_namebucket = 0;
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
#ifdef DUMP_ADB_AFTER_CLEANING
dump_adb(adb, stdout);
#endif
}
cleanup snapshot
1999-10-29 23:53:12 +00:00
#if 0
/*
* Call the entry cleanup routine
*/
cleanup_entries(adb, adb->next_entrybucket, now);
adb->next_entrybucket++;
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
if (adb->next_entrybucket >= NBUCKETS)
cleanup snapshot
1999-10-29 23:53:12 +00:00
adb->next_entrybucket = 0;
#endif
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
/*
* Reset the timer.
*/
cleanup snapshot
1999-10-29 23:53:12 +00:00
reset:
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
result = isc_timer_reset(adb->timer, isc_timertype_once, NULL,
&adb->tick_interval, ISC_FALSE);
UNLOCK(&adb->lock);
isc_event_free(&ev);
}
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
static void
destroy(dns_adb_t *adb)
{
adb->magic = 0;
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
/*
* The timer is already dead, from the task's shutdown callback.
*/
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
isc_task_detach(&adb->task);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
isc_mempool_destroy(&adb->nmp);
isc_mempool_destroy(&adb->nhmp);
isc_mempool_destroy(&adb->zimp);
isc_mempool_destroy(&adb->emp);
isc_mempool_destroy(&adb->ahmp);
isc_mempool_destroy(&adb->aimp);
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
isc_mempool_destroy(&adb->afmp);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
isc_mempool_destroy(&adb->af6mp);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
isc_mutexblock_destroy(adb->entrylocks, NBUCKETS);
isc_mutexblock_destroy(adb->namelocks, NBUCKETS);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
isc_mutex_destroy(&adb->lock);
isc_mutex_destroy(&adb->mplock);
snapshot
1999-10-20 23:26:06 +00:00
isc_random_invalidate(&adb->rand);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
isc_mem_put(adb->mctx, adb, sizeof (dns_adb_t));
}
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
/*
* Public functions.
*/
Start on address.c
1999-09-21 22:46:42 +00:00
isc_result_t
fix, take II
1999-10-25 21:40:56 +00:00
dns_adb_create(isc_mem_t *mem, dns_view_t *view, isc_timermgr_t *timermgr,
fix
1999-10-25 21:39:08 +00:00
isc_taskmgr_t *taskmgr, dns_adb_t **newadb)
Start on address.c
1999-09-21 22:46:42 +00:00
{
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
dns_adb_t *adb;
isc_result_t result;
int i;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
REQUIRE(mem != NULL);
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
REQUIRE(view != NULL);
REQUIRE(timermgr != NULL);
REQUIRE(taskmgr != NULL);
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
REQUIRE(newadb != NULL && *newadb == NULL);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
adb = isc_mem_get(mem, sizeof (dns_adb_t));
if (adb == NULL)
return (ISC_R_NOMEMORY);
/*
* Initialize things here that cannot fail, and especially things
* that must be NULL for the error return to work properly.
*/
adb->magic = 0;
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
adb->erefcnt = 1;
adb->irefcnt = 0;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
adb->nmp = NULL;
adb->nhmp = NULL;
adb->zimp = NULL;
adb->emp = NULL;
adb->ahmp = NULL;
adb->aimp = NULL;
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
adb->afmp = NULL;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
adb->af6mp = NULL;
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
adb->task = NULL;
adb->timer = NULL;
adb->mctx = mem;
adb->view = view;
adb->timermgr = timermgr;
adb->taskmgr = taskmgr;
cleanup snapshot
1999-10-29 23:53:12 +00:00
adb->next_namebucket = 0;
adb->next_entrybucket = 0;
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
ISC_EVENT_INIT(&adb->cevent, sizeof adb->cevent, 0, NULL,
DNS_EVENT_ADBCONTROL, shutdown_task, adb,
adb, NULL, NULL);
adb->cevent_sent = ISC_FALSE;
adb->shutting_down = ISC_FALSE;
ISC_LIST_INIT(adb->whenshutdown);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
snapshot
1999-10-20 23:26:06 +00:00
result = isc_random_init(&adb->rand);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
if (result != ISC_R_SUCCESS)
snapshot
1999-10-05 23:50:43 +00:00
goto fail0a;
snapshot
1999-10-20 23:26:06 +00:00
result = isc_mutex_init(&adb->lock);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
if (result != ISC_R_SUCCESS)
snapshot
1999-10-05 23:50:43 +00:00
goto fail0b;
clean up warnings that shouldn't be there.
1999-10-25 23:18:19 +00:00
snapshot
1999-10-20 23:26:06 +00:00
result = isc_mutex_init(&adb->mplock);
snapshot
1999-10-05 23:50:43 +00:00
if (result != ISC_R_SUCCESS)
goto fail0c;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
* Initialize the bucket locks for names and elements.
* May as well initialize the list heads, too.
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*/
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
result = isc_mutexblock_init(adb->namelocks, NBUCKETS);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
if (result != ISC_R_SUCCESS)
goto fail1;
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++) {
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
ISC_LIST_INIT(adb->names[i]);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
adb->name_sd[i] = ISC_FALSE;
adb->name_refcnt[i] = 0;
adb->irefcnt++;
}
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
ISC_LIST_INIT(adb->entries[i]);
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
result = isc_mutexblock_init(adb->entrylocks, NBUCKETS);
use isc_mutexblock_init/destroy()
1999-09-24 23:54:42 +00:00
if (result != ISC_R_SUCCESS)
goto fail2;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
* Memory pools
*/
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
#define MPINIT(t, p, l, n) do { \
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
result = isc_mempool_create(mem, sizeof (t), &(p)); \
if (result != ISC_R_SUCCESS) \
goto fail3; \
isc_mempool_setfreemax((p), FREE_ITEMS); \
isc_mempool_setfillcount((p), FILL_COUNT); \
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
isc_mempool_setname((p), n); \
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
if (l) \
isc_mempool_associatelock((p), &adb->mplock); \
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
} while (0)
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
MPINIT(dns_adbname_t, adb->nmp, ISC_TRUE, "adbname");
MPINIT(dns_adbnamehook_t, adb->nhmp, ISC_TRUE, "adbnamehook");
MPINIT(dns_adbzoneinfo_t, adb->zimp, ISC_TRUE, "adbzoneinfo");
MPINIT(dns_adbentry_t, adb->emp, ISC_TRUE, "adbentry");
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
MPINIT(dns_adbfind_t, adb->ahmp, ISC_TRUE, "adbfind");
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
MPINIT(dns_adbaddrinfo_t, adb->aimp, ISC_TRUE, "adbaddrinfo");
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
MPINIT(dns_adbfetch_t, adb->afmp, ISC_TRUE, "adbfetch");
a6 checkpoint
1999-10-30 01:22:16 +00:00
MPINIT(dns_adbfetch6_t, adb->af6mp, ISC_TRUE, "adbfetch6");
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
#undef MPINIT
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
/*
* Allocate a timer and a task for our periodic cleanup.
*/
result = isc_task_create(adb->taskmgr, adb->mctx, 0, &adb->task);
if (result != ISC_R_SUCCESS)
goto fail3;
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
/*
* XXXMLG When this is changed to be a config file option,
*/
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
isc_interval_set(&adb->tick_interval, CLEAN_SECONDS, 0);
result = isc_timer_create(adb->timermgr, isc_timertype_once,
NULL, &adb->tick_interval, adb->task,
timer_cleanup, adb, &adb->timer);
if (result != ISC_R_SUCCESS)
goto fail3;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
* Normal return.
*/
adb->magic = DNS_ADB_MAGIC;
*newadb = adb;
return (ISC_R_SUCCESS);
start on cleanup timer/task
1999-10-25 22:53:15 +00:00
fail3:
if (adb->task != NULL)
isc_task_detach(&adb->task);
if (adb->timer != NULL)
isc_timer_detach(&adb->timer);
/* clean up entrylocks */
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
isc_mutexblock_destroy(adb->entrylocks, NBUCKETS);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
fail2: /* clean up namelocks */
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
isc_mutexblock_destroy(adb->namelocks, NBUCKETS);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
fail1: /* clean up only allocated memory */
if (adb->nmp != NULL)
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->emp != NULL)
isc_mempool_destroy(&adb->emp);
if (adb->ahmp != NULL)
isc_mempool_destroy(&adb->ahmp);
if (adb->aimp != NULL)
isc_mempool_destroy(&adb->aimp);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (adb->afmp != NULL)
start on fetch infrastructure
1999-10-25 21:02:54 +00:00
isc_mempool_destroy(&adb->afmp);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (adb->af6mp != NULL)
isc_mempool_destroy(&adb->af6mp);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
isc_mutex_destroy(&adb->mplock);
snapshot
1999-10-20 23:26:06 +00:00
fail0c:
snapshot
1999-10-05 23:50:43 +00:00
isc_mutex_destroy(&adb->lock);
snapshot
1999-10-20 23:26:06 +00:00
fail0b:
isc_random_invalidate(&adb->rand);
snapshot
1999-10-05 23:50:43 +00:00
fail0a:
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
isc_mem_put(mem, adb, sizeof (dns_adb_t));
return (result);
Start on address.c
1999-09-21 22:46:42 +00:00
}
void
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
dns_adb_detach(dns_adb_t **adbx)
Start on address.c
1999-09-21 22:46:42 +00:00
{
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
dns_adb_t *adb;
REQUIRE(adbx != NULL && DNS_ADB_VALID(*adbx));
adb = *adbx;
*adbx = NULL;
snapshot
1999-10-05 23:50:43 +00:00
LOCK(&adb->lock);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
dec_adb_erefcnt(adb, ISC_FALSE);
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
if (adb->erefcnt == 0)
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
INSIST(adb->shutting_down);
UNLOCK(&adb->lock);
}
void
dns_adb_whenshutdown(dns_adb_t *adb, isc_task_t *task, isc_event_t **eventp)
{
isc_task_t *clone;
isc_event_t *event;
/*
* Send '*eventp' to 'task' when 'adb' has shutdown.
*/
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(eventp != NULL);
event = *eventp;
*eventp = NULL;
LOCK(&adb->lock);
if (adb->shutting_down && adb->irefcnt == 0 &&
isc_mempool_getallocated(adb->ahmp) == 0) {
/*
* We're already shutdown. Send the event.
*/
event->sender = adb;
isc_task_send(task, &event);
} else {
clone = NULL;
isc_task_attach(task, &clone);
event->sender = clone;
ISC_LIST_APPEND(adb->whenshutdown, event, link);
}
UNLOCK(&adb->lock);
}
void
dns_adb_shutdown(dns_adb_t *adb) {
/*
* Shutdown 'adb'.
*/
LOCK(&adb->lock);
if (!adb->shutting_down) {
adb->shutting_down = ISC_TRUE;
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
shutdown_names(adb);
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
check_exit(adb);
}
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
UNLOCK(&adb->lock);
Start on address.c
1999-09-21 22:46:42 +00:00
}
isc_result_t
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
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,
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t **findp)
Start on address.c
1999-09-21 22:46:42 +00:00
{
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
snapshot
1999-10-08 23:12:21 +00:00
dns_adbname_t *adbname;
int bucket;
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
isc_boolean_t use_hints;
snapshot
1999-10-05 23:50:43 +00:00
isc_result_t result;
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
isc_boolean_t want_event;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
unsigned int wanted_addresses;
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
unsigned int query_pending;
snapshot
1999-10-05 23:50:43 +00:00
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
REQUIRE(DNS_ADB_VALID(adb));
if (task != NULL) {
REQUIRE(action != NULL);
}
snapshot
1999-10-08 23:12:21 +00:00
REQUIRE(name != NULL);
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
REQUIRE(zone != NULL);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
REQUIRE(findp != NULL && *findp == NULL);
snapshot
1999-10-05 23:50:43 +00:00
minor formatting nits, and require at least one address family be requested in calls to dns_adb_createfind().
1999-11-01 02:29:03 +00:00
REQUIRE((options & DNS_ADBFIND_ADDRESSMASK) != 0);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
result = ISC_R_UNEXPECTED;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
wanted_addresses = (options & DNS_ADBFIND_ADDRESSMASK);
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
query_pending = 0;
want_event = ISC_FALSE;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
snapshot
1999-10-20 23:26:06 +00:00
if (now == 0) {
result = isc_stdtime_get(&now);
if (result != ISC_R_SUCCESS)
return (result);
}
update a comment.
1999-09-25 02:44:40 +00:00
/*
review checkpoint
1999-11-25 01:23:32 +00:00
* XXXMLG Move this comment somewhere else!
*
snapshot
1999-10-08 23:12:21 +00:00
* Look up the name in our internal database.
update a comment.
1999-09-25 02:44:40 +00:00
*
* Possibilities: Note that these are not always exclusive.
*
snapshot
1999-10-08 23:12:21 +00:00
* No name found. In this case, allocate a new name header and
* an initial namehook or two. If any of these allocations
* fail, clean up and return ISC_R_NOMEMORY.
update a comment.
1999-09-25 02:44:40 +00:00
*
* Name found, valid addresses present. Allocate one addrinfo
* structure for each found and append it to the linked list
* of addresses for this header.
*
* Name found, queries pending. In this case, if a task was
* passed in, allocate a job id, attach it to the name's job
* list and remember to tell the caller that there will be
* more info coming later.
*/
review checkpoint
1999-11-25 01:23:32 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find = new_adbfind(adb);
if (find == NULL)
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
return (ISC_R_NOMEMORY);
snapshot
1999-10-08 23:12:21 +00:00
/*
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* Remember what types of addresses we are interested in.
*/
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->options = options;
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
find->flags |= wanted_addresses;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (FIND_WANTEVENT(find)) {
REQUIRE(task != NULL);
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
/*
* Try to see if we know anything about this name at all.
snapshot
1999-10-08 23:12:21 +00:00
*/
bucket = DNS_ADB_INVALIDBUCKET;
adbname = find_name_and_lock(adb, name, &bucket);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
if (adb->name_sd[bucket]) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
"dns_adb_createfind: returning ISC_R_SHUTTINGDOWN");
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
free_adbfind(adb, &find);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
result = ISC_R_SHUTTINGDOWN;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
goto out;
start on name expiration times
1999-10-26 00:16:36 +00:00
}
/*
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* Nothing found. Allocate a new adbname structure for this name.
start on name expiration times
1999-10-26 00:16:36 +00:00
*/
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
if (adbname == NULL) {
adbname = new_adbname(adb, name);
if (adbname == NULL) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
free_adbfind(adb, &find);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
result = ISC_R_NOMEMORY;
goto out;
}
link_name(adb, bucket, adbname);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
}
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
/*
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* Expire old entries, etc.
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
*/
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
check_expire_namehooks(adbname, now);
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
use_hints = dns_name_equal(zone, dns_rootname);
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
/*
* Try to populate the name from the database and/or
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* start fetches.
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
*/
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (!NAME_HAS_V4(adbname) && !NAME_FETCH_V4(adbname)
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
&& EXPIRE_OK(adbname->expire_v4, now)
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
&& WANT_INET(wanted_addresses)) {
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
result = dbfind_name(adbname, now, use_hints, dns_rdatatype_a);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
if (result == ISC_R_SUCCESS) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
"dns_adb_createfind: Found A for name %p in db",
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
adbname);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
goto v6;
}
clean up the path of looking up names.
1999-10-25 23:43:20 +00:00
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* Listen to negative cache hints, and don't start
* another query.
*/
if (NCACHE_RESULT(result))
goto v6;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
/*
* Try to start fetches for v4.
*/
result = fetch_name_v4(adbname, now);
if (result == ISC_R_SUCCESS) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
"dns_adb_createfind: Started A fetch for name %p",
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
adbname);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
goto v6;
}
fetch contexts
1999-10-26 01:12:20 +00:00
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
v6:
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (!NAME_HAS_V6(adbname) && !NAME_FETCH_V6(adbname)
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
&& EXPIRE_OK(adbname->expire_v6, now)
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
&& WANT_INET6(wanted_addresses)) {
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
result = dbfind_a6(adbname, now, use_hints);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
if (result == ISC_R_SUCCESS) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
"dns_adb_createfind: Found A6 for name %p",
minor formatting nits, and require at least one address family be requested in calls to dns_adb_createfind().
1999-11-01 02:29:03 +00:00
adbname);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
goto copy;
}
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* Listen to negative cache hints, and don't start
* another query.
*/
if (NCACHE_RESULT(result))
goto copy;
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
/*
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
* Try to start fetches for a6.
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
*/
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
result = fetch_name_a6(adbname, now, use_hints);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
if (result == ISC_R_SUCCESS) {
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL,
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
"dns_adb_createfind: Started A6 fetch for name %p",
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
adbname);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
goto copy;
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
}
snapshot
1999-10-08 23:12:21 +00:00
/*
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* Run through the name and copy out the bits we are
* interested in.
snapshot
1999-10-08 23:12:21 +00:00
*/
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
copy:
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
copy_namehook_lists(adb, find, zone, adbname, now);
clean up from Bob's quick code walk-through
1999-10-21 01:37:57 +00:00
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (NAME_FETCH_V4(adbname))
query_pending |= DNS_ADBFIND_INET;
if (NAME_FETCH_V6(adbname))
query_pending |= DNS_ADBFIND_INET6;
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
/*
* Attach to the name's query list if there are queries
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
* already running, and we have been asked to.
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
*/
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
want_event = ISC_TRUE;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (!FIND_WANTEVENT(find))
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
want_event = ISC_FALSE;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (FIND_WANTEMPTYEVENT(find) && FIND_HAS_ADDRS(find))
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
want_event = ISC_FALSE;
if ((wanted_addresses & query_pending) == 0)
want_event = ISC_FALSE;
if (want_event) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->adbname = adbname;
find->name_bucket = bucket;
ISC_LIST_APPEND(adbname->finds, find, plink);
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
find->query_pending = (query_pending & wanted_addresses);
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
find->flags &= ~DNS_ADBFIND_ADDRESSMASK;
find->flags |= (find->query_pending & DNS_ADBFIND_ADDRESSMASK);
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
DP(DEF_LEVEL, "createfind: attaching find %p to adbname %p",
more debugging output.
1999-11-01 02:57:16 +00:00
find, adbname);
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
} else {
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
/*
* Remove the flag so the caller knows there will never
* be an event, and set internal flags to fake that
* the event was sent and freed, so dns_adb_destroyfind() will
* do the right thing.
*/
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->options &= ~DNS_ADBFIND_WANTEVENT;
find->flags |= (FIND_EVENT_SENT | FIND_EVENT_FREED);
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
find->flags &= ~DNS_ADBFIND_ADDRESSMASK;
snapshot
1999-10-08 23:12:21 +00:00
}
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->partial_result |= (adbname->partial_result & wanted_addresses);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
result = ISC_R_SUCCESS;
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
out:
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
if (find != NULL) {
*findp = find;
snapshot
1999-10-08 23:12:21 +00:00
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
if (want_event) {
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
isc_task_t *taskp;
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
INSIST((find->flags & DNS_ADBFIND_ADDRESSMASK) != 0);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
taskp = NULL;
isc_task_attach(task, &taskp);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->event.sender = taskp;
find->event.action = action;
find->event.arg = arg;
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
}
}
comment out dumping calls
1999-10-31 19:29:20 +00:00
/* dns_adb_dumpfind(find, stderr); */
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
snapshot
1999-10-08 23:12:21 +00:00
if (bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->namelocks[bucket]);
return (result);
add dns_adb_refresh()
1999-09-25 01:56:10 +00:00
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
isc_result_t
dns_adb_deletename(dns_adb_t *adb, dns_name_t *host)
{
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
int name_bucket;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
dns_adbname_t *name;
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
isc_boolean_t decr_adbrefcnt;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(host != NULL);
name = NULL;
/*
* Find the name.
*/
name_bucket = DNS_ADB_INVALIDBUCKET;
name = find_name_and_lock(adb, host, &name_bucket);
if (name == NULL) {
UNLOCK(&adb->namelocks[name_bucket]);
return (ISC_R_NOTFOUND);
}
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
kill_name(&name, DNS_EVENT_ADBNAMEDELETED);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
decr_adbrefcnt = ISC_FALSE;
if (adb->name_sd[name_bucket] && (adb->name_refcnt[name_bucket] == 0))
decr_adbrefcnt = ISC_TRUE;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
if (name_bucket != DNS_ADB_INVALIDBUCKET)
UNLOCK(&adb->namelocks[name_bucket]);
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
if (decr_adbrefcnt)
dec_adb_irefcnt(adb, ISC_TRUE);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
return (DNS_R_SUCCESS);
}
cleanup snapshot
1999-10-29 23:53:12 +00:00
/* XXXMLG needs v6 support */
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
isc_result_t
review checkpoint
1999-11-25 01:23:32 +00:00
_dns_adb_insert(dns_adb_t *adb, dns_name_t *host, isc_sockaddr_t *addr,
start on name expiration times
1999-10-26 00:16:36 +00:00
dns_ttl_t ttl, isc_stdtime_t now)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
{
dns_adbname_t *name;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
isc_boolean_t free_name;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
dns_adbentry_t *entry;
isc_boolean_t free_entry;
dns_adbnamehook_t *namehook;
isc_boolean_t free_namehook;
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
int name_bucket, addr_bucket; /* unlock if != DNS_ADB_INVALIDBUCKET */
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
isc_result_t result;
start on name expiration times
1999-10-26 00:16:36 +00:00
isc_stdtime_t expire_time;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(host != NULL);
REQUIRE(addr != NULL);
start on name expiration times
1999-10-26 00:16:36 +00:00
if (now == 0) {
result = isc_stdtime_get(&now);
if (result != ISC_R_SUCCESS)
return (result);
}
expire_time = now + ttl;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
name = NULL;
free_name = ISC_FALSE;
entry = NULL;
free_entry = ISC_FALSE;
namehook = NULL;
free_namehook = ISC_FALSE;
result = ISC_R_UNEXPECTED;
/*
* First, see if the host is already in the database. If it is,
* don't make a new host entry. If not, copy the name and name's
* contents into our structure and allocate what we'll need
* to attach things together.
*/
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
name_bucket = DNS_ADB_INVALIDBUCKET;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
name = find_name_and_lock(adb, host, &name_bucket);
if (name == NULL) {
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
name = new_adbname(adb, host);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
if (name == NULL) {
result = ISC_R_NOMEMORY;
goto out;
}
free_name = ISC_TRUE;
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
name->expire_v4 = ISC_MIN(expire_time, name->expire_v4);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
}
/*
* Now, while keeping the name locked, search for the address.
* Three possibilities: One, the address doesn't exist.
* Two, the address exists, but we aren't linked to it.
* Three, the address exists and we are linked to it.
* (1) causes a new entry and namehook to be created.
* (2) causes only a new namehook.
* (3) is an error.
*/
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
addr_bucket = DNS_ADB_INVALIDBUCKET;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
entry = find_entry_and_lock(adb, addr, &addr_bucket);
/*
* Case (1): new entry and namehook.
*/
if (entry == NULL) {
entry = new_adbentry(adb);
if (entry == NULL) {
result = ISC_R_NOMEMORY;
goto out;
}
free_entry = ISC_TRUE;
}
/*
* Case (3): entry exists, we're linked.
*/
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
namehook = ISC_LIST_HEAD(name->v4);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
while (namehook != NULL) {
if (namehook->entry == entry) {
result = ISC_R_EXISTS;
goto out;
}
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
namehook = ISC_LIST_NEXT(namehook, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
}
/*
* Case (2): New namehook, link to entry from above.
*/
namehook = new_adbnamehook(adb, entry);
if (namehook == NULL) {
result = ISC_R_NOMEMORY;
goto out;
}
free_namehook = ISC_TRUE;
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_APPEND(name->v4, namehook, plink);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
entry->lock_bucket = addr_bucket;
snapshot
1999-10-08 23:12:21 +00:00
inc_entry_refcnt(adb, entry, ISC_FALSE);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
entry->sockaddr = *addr;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
/*
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
* If needed, string up the name and entry.
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
*/
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
if (!ISC_LINK_LINKED(name, plink))
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
link_name(adb, name_bucket, name);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
if (!ISC_LINK_LINKED(entry, plink))
ISC_LIST_PREPEND(adb->entries[addr_bucket], entry, plink);
start on name expiration times
1999-10-26 00:16:36 +00:00
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
name->expire_v4 = ISC_MIN(name->expire_v4, expire_time);
start on name expiration times
1999-10-26 00:16:36 +00:00
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
UNLOCK(&adb->namelocks[name_bucket]);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
name_bucket = DNS_ADB_INVALIDBUCKET;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
UNLOCK(&adb->entrylocks[addr_bucket]);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
addr_bucket = DNS_ADB_INVALIDBUCKET;
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
return (ISC_R_SUCCESS);
out:
if (free_name)
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
free_adbname(adb, &name);
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
if (free_entry)
isc_mempool_put(adb->emp, entry);
if (free_namehook)
isc_mempool_put(adb->nhmp, namehook);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
if (name_bucket != DNS_ADB_INVALIDBUCKET)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
UNLOCK(&adb->namelocks[name_bucket]);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
if (addr_bucket != DNS_ADB_INVALIDBUCKET)
Start flushing out the address.c stuff
1999-09-23 00:43:10 +00:00
UNLOCK(&adb->entrylocks[addr_bucket]);
return (result);
}
Start on address.c
1999-09-21 22:46:42 +00:00
void
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adb_destroyfind(dns_adbfind_t **findp)
Start on address.c
1999-09-21 22:46:42 +00:00
{
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
dns_adbentry_t *entry;
dns_adbaddrinfo_t *ai;
int bucket;
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
dns_adb_t *adb;
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
REQUIRE(findp != NULL && DNS_ADBFIND_VALID(*findp));
find = *findp;
*findp = NULL;
Start on address.c
1999-09-21 22:46:42 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
LOCK(&find->lock);
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL, "dns_adb_done on find %p", find);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
adb = find->adb;
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
REQUIRE(DNS_ADB_VALID(adb));
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
REQUIRE(FIND_EVENTFREED(find));
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
bucket = find->name_bucket;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
INSIST(bucket == DNS_ADB_INVALIDBUCKET);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
UNLOCK(&find->lock);
snapshot address.[ch]
1999-09-22 00:26:20 +00:00
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* The find doesn't exist on any list, and nothing is locked.
* Return the find to the memory pool, and decrement the adb's
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
* reference count.
*/
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ai = ISC_LIST_HEAD(find->list);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
while (ai != NULL) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ISC_LIST_UNLINK(find->list, ai, publink);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
entry = ai->entry;
ai->entry = NULL;
ai->sockaddr = NULL;
INSIST(DNS_ADBENTRY_VALID(entry));
dec_entry_refcnt(adb, entry, ISC_TRUE);
free_adbaddrinfo(adb, &ai);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ai = ISC_LIST_HEAD(find->list);
snapshot: dns_adb_done() partial implementation, handles mostly work, but no fetches are started yet.
1999-10-14 00:50:00 +00:00
}
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* WARNING: The find is freed with the adb locked. This is done
* to avoid a race condition where we free the find, some other
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
* thread tests to see if it should be destroyed, detects it should
* be, destroys it, and then we try to lock it for our check, but the
* lock is destroyed.
*/
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
LOCK(&adb->lock);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
free_adbfind(adb, &find);
cleanup: kill_name(): names are killed by a single function. link_name(), unlink_name(): names (and bucket reference counts) are managed by these. cancel fetches at names when killing the name. if fetches are pending when killing, set a "dead" flag in the name instead and let it die when the last fetch comes in.
1999-10-26 23:44:36 +00:00
check_exit(adb);
event-driven shutdown/destroy
1999-10-25 23:07:14 +00:00
UNLOCK(&adb->lock);
Start on address.c
1999-09-21 22:46:42 +00:00
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
void
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adb_cancelfind(dns_adbfind_t *find)
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
{
isc_event_t *ev;
isc_task_t *task;
dns_adb_t *adb;
int bucket;
Unlock the right bucket in the race condition avoidance case
1999-12-10 23:22:13 +00:00
int unlock_bucket;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
LOCK(&find->lock);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL, "dns_adb_cancelfind on find %p", find);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
adb = find->adb;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
REQUIRE(DNS_ADB_VALID(adb));
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
REQUIRE(!FIND_EVENTFREED(find));
REQUIRE(FIND_WANTEVENT(find));
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
bucket = find->name_bucket;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
if (bucket == DNS_ADB_INVALIDBUCKET)
goto cleanup;
/*
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
* We need to get the adbname's lock to unlink the find.
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
*/
Unlock the right bucket in the race condition avoidance case
1999-12-10 23:22:13 +00:00
unlock_bucket = bucket;
violate_locking_hierarchy(&find->lock, &adb->namelocks[unlock_bucket]);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
bucket = find->name_bucket;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
if (bucket != DNS_ADB_INVALIDBUCKET) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ISC_LIST_UNLINK(find->adbname->finds, find, plink);
find->adbname = NULL;
find->name_bucket = DNS_ADB_INVALIDBUCKET;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
}
Unlock the right bucket in the race condition avoidance case
1999-12-10 23:22:13 +00:00
UNLOCK(&adb->namelocks[unlock_bucket]);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
bucket = DNS_ADB_INVALIDBUCKET;
cleanup:
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (!FIND_EVENTSENT(find)) {
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ev = &find->event;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
task = ev->sender;
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ev->sender = find;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
ev->type = DNS_EVENT_ADBCANCELED;
ev->destroy = event_free;
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ev->destroy_arg = find;
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(DEF_LEVEL, "Sending event %p to task %p for find %p",
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
ev, task, find);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
isc_task_sendanddetach(&task, &ev);
}
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
UNLOCK(&find->lock);
implement dns_adb_cancelfind(), rename _done() to _destroyfind(), and _lookup to _createfind()
1999-10-29 18:00:31 +00:00
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
void
dns_adb_dump(dns_adb_t *adb, FILE *f)
{
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(f != NULL);
/*
* Lock the adb itself, lock all the name buckets, then lock all
* the entry buckets. This should put the adb into a state where
* nothing can change, so we can iterate through everything and
* print at our leasure.
*/
LOCK(&adb->lock);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
dump_adb(adb, f);
UNLOCK(&adb->lock);
}
static void
dump_adb(dns_adb_t *adb, FILE *f)
{
int i;
isc_sockaddr_t *sa;
dns_adbname_t *name;
dns_adbentry_t *entry;
char tmp[512];
const char *tmpp;
update the right ttl in a/aaaa db lookups. Print ttl in seconds from now, rather than absolute time.
1999-11-04 08:29:06 +00:00
isc_stdtime_t now;
isc_result_t result;
result = isc_stdtime_get(&now);
INSIST(result == ISC_R_SUCCESS);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
fprintf(f, "ADB %p DUMP:\n", adb);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
fprintf(f, "erefcnt %u, irefcnt %u, finds out %u\n",
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
adb->erefcnt, adb->irefcnt,
isc_mempool_getallocated(adb->nhmp));
snapshot ; external and internal reference counts are separated out, and everything but fetches work.
1999-10-19 01:37:22 +00:00
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++)
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
LOCK(&adb->namelocks[i]);
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++)
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
LOCK(&adb->entrylocks[i]);
/*
* Dump the names
*/
fprintf(f, "Names:\n");
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++) {
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
name = ISC_LIST_HEAD(adb->names[i]);
if (name == NULL)
continue;
fprintf(f, "Name bucket %d:\n", i);
while (name != NULL) {
fprintf(f, "name %p\n", name);
if (!DNS_ADBNAME_VALID(name))
fprintf(f, "\tMAGIC %08x\n", name->magic);
update the right ttl in a/aaaa db lookups. Print ttl in seconds from now, rather than absolute time.
1999-11-04 08:29:06 +00:00
fprintf(f, "\texpiry [");
if (name->expire_v4 == INT_MAX)
fprintf(f, "inf ");
else
fprintf(f, "%d ", name->expire_v4 - now);
if (name->expire_v6 == INT_MAX)
fprintf(f, "inf] ");
else
fprintf(f, "%d] ", name->expire_v6 - now);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
print_dns_name(f, &name->name);
snapshot
1999-10-05 23:50:43 +00:00
fprintf(f, "\n");
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
print_namehook_list(f, name);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
print_fetch_list(f, name);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
print_find_list(f, name);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
fprintf(f, "\n");
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
name = ISC_LIST_NEXT(name, plink);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
}
}
/*
* Dump the entries
*/
fprintf(f, "Entries:\n");
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++) {
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
entry = ISC_LIST_HEAD(adb->entries[i]);
if (entry == NULL)
continue;
fprintf(f, "Entry bucket %d:\n", i);
while (entry != NULL) {
if (!DNS_ADBENTRY_VALID(entry))
fprintf(f, "\tMAGIC %08x\n", entry->magic);
if (entry->lock_bucket != i)
fprintf(f, "\tWRONG BUCKET! lock_bucket %d\n",
entry->lock_bucket);
sa = &entry->sockaddr;
snapshot
1999-10-12 02:06:08 +00:00
switch (sa->type.sa.sa_family) {
case AF_INET:
tmpp = inet_ntop(AF_INET,
&sa->type.sin.sin_addr,
tmp, sizeof tmp);
break;
case AF_INET6:
tmpp = inet_ntop(AF_INET6,
&sa->type.sin6.sin6_addr,
tmp, sizeof tmp);
break;
default:
tmpp = "UnkFamily";
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
if (tmpp == NULL)
tmpp = "CANNOT TRANSLATE ADDRESS!";
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
fprintf(f, "\t%p: refcnt %u flags %08x goodness %d"
snapshot
1999-10-12 02:06:08 +00:00
" srtt %u addr %s\n",
fix shutdown routines. The adb will go away at the right time, now.
1999-10-22 05:19:42 +00:00
entry, entry->refcnt, entry->flags,
entry->goodness, entry->srtt, tmpp);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
entry = ISC_LIST_NEXT(entry, plink);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
}
}
/*
* Unlock everything
*/
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++)
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
UNLOCK(&adb->entrylocks[i]);
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
for (i = 0 ; i < NBUCKETS ; i++)
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
UNLOCK(&adb->namelocks[i]);
}
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
void
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adb_dumpfind(dns_adbfind_t *find, FILE *f)
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
{
char tmp[512];
const char *tmpp;
dns_adbaddrinfo_t *ai;
isc_sockaddr_t *sa;
/*
* Not used currently, in the API Just In Case we
* want to dump out the name and/or entries too.
*/
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
LOCK(&find->lock);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
fprintf(f, "Find %p\n", find);
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
fprintf(f, "\tqpending %08x partial %08x options %08x flags %08x\n",
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->query_pending, find->partial_result,
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
find->options, find->flags);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
fprintf(f, "\tname_bucket %d, name %p, event sender %p\n",
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find->name_bucket, find->adbname, find->event.sender);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
ai = ISC_LIST_HEAD(find->list);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
if (ai != NULL)
fprintf(f, "\tAddresses:\n");
while (ai != NULL) {
sa = ai->sockaddr;
switch (sa->type.sa.sa_family) {
case AF_INET:
tmpp = inet_ntop(AF_INET, &sa->type.sin.sin_addr,
tmp, sizeof tmp);
break;
case AF_INET6:
tmpp = inet_ntop(AF_INET6, &sa->type.sin6.sin6_addr,
tmp, sizeof tmp);
break;
default:
tmpp = "UnkFamily";
}
if (tmpp == NULL)
tmpp = "CANNOT TRANSLATE ADDRESS!";
fprintf(f, "\t\tentry %p, flags %08x goodness %d"
" srtt %u addr %s\n",
ai->entry, ai->flags, ai->goodness, ai->srtt, tmpp);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ai = ISC_LIST_NEXT(ai, publink);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
}
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
UNLOCK(&find->lock);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
}
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
static void
print_dns_name(FILE *f, dns_name_t *name)
{
char buf[257];
isc_buffer_t b;
INSIST(f != NULL);
memset(buf, 0, sizeof (buf));
isc_buffer_init(&b, buf, sizeof (buf) - 1, ISC_BUFFERTYPE_TEXT);
dns_name_totext(name, ISC_FALSE, &b);
fprintf(f, buf); /* safe, since names < 256 chars, and we memset */
}
static void
print_namehook_list(FILE *f, dns_adbname_t *n)
{
dns_adbnamehook_t *nh;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
nh = ISC_LIST_HEAD(n->v4);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
while (nh != NULL) {
print v6 hooks too; use logging system; general cleanup
1999-10-29 22:28:57 +00:00
fprintf(f, "\t\tHook(V4) %p -> entry %p\n", nh, nh->entry);
nh = ISC_LIST_NEXT(nh, plink);
}
nh = ISC_LIST_HEAD(n->v6);
while (nh != NULL) {
fprintf(f, "\t\tHook(V6) %p -> entry %p\n", nh, nh->entry);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
nh = ISC_LIST_NEXT(nh, plink);
Many changes. o added adb_test.c to test the functions already written. o added code to delete names and all associated addresses. o added a database dumper which will currently print the adb in a human (or at least developer) readable format. o found and fixed many twisted little locking issues.
1999-10-02 01:59:09 +00:00
}
}
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
static inline void
print_fetch(FILE *f, dns_adbfetch_t *ft, char *type)
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
{
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
fprintf(f, "\t\tFetch(%s): %p -> { nh %p, entry %p, fetch %p }\n",
type, ft, ft->namehook, ft->entry, ft->fetch);
}
static inline void
print_fetch6(FILE *f, dns_adbfetch6_t *ft)
{
fprintf(f, "\t\tFetch(A6): %p -> { nh %p, entry %p, fetch %p }\n",
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
ft, ft->namehook, ft->entry, ft->fetch);
}
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
static void
print_fetch_list(FILE *f, dns_adbname_t *n)
{
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
dns_adbfetch6_t *fetch6;
if (NAME_FETCH_A(n))
print_fetch(f, n->fetch_a, "A");
if (NAME_FETCH_AAAA(n))
print_fetch(f, n->fetch_aaaa, "AAAA");
fetch6 = ISC_LIST_HEAD(n->fetches_a6);
while (fetch6 != NULL) {
print_fetch6(f, fetch6);
fetch6 = ISC_LIST_NEXT(fetch6, plink);
}
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
}
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
static void
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
print_find_list(FILE *f, dns_adbname_t *name)
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
{
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
dns_adbfind_t *find;
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find = ISC_LIST_HEAD(name->finds);
while (find != NULL) {
more debugging output.
1999-11-01 02:57:16 +00:00
dns_adb_dumpfind(find, f);
replace all instances of 'handle' with 'find' since that's what they are now.
1999-10-29 18:30:48 +00:00
find = ISC_LIST_NEXT(find, plink);
snapshot; everything works other than fetches and database lookups.
1999-10-16 00:38:21 +00:00
}
}
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
static isc_result_t
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
dbfind_name(dns_adbname_t *adbname, isc_stdtime_t now,
isc_boolean_t use_hints, dns_rdatatype_t rdtype)
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
{
isc_result_t result;
database lookups
1999-10-21 01:18:06 +00:00
dns_rdataset_t rdataset;
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dns_adb_t *adb;
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
INSIST(DNS_ADBNAME_VALID(adbname));
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
INSIST(rdtype == dns_rdatatype_a || rdtype == dns_rdatatype_aaaa);
Add code to check for a lame zone, and to expire lame entries as needed.
1999-10-19 20:55:04 +00:00
database lookups
1999-10-21 01:18:06 +00:00
dns_rdataset_init(&rdataset);
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
result = dns_view_find(adb->view, &adbname->name, rdtype,
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
now, DNS_DBFIND_GLUEOK, use_hints,
&rdataset, NULL);
switch (result) {
case DNS_R_GLUE:
case DNS_R_HINT:
case DNS_R_SUCCESS:
/*
* Found in the database. Even if we can't copy out
* any information, return success, or else a fetch
* will be made, which will only make things worse.
*/
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
result = import_rdataset(adbname, &rdataset, now);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
break;
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
case DNS_R_NCACHENXDOMAIN:
case DNS_R_NCACHENXRRSET:
/*
* We found a negative cache entry. Pull the TTL from it
* so we won't ask again for a while.
*/
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
rdataset.ttl = ISC_MIN(rdataset.ttl, ADB_CACHE_MINIMUM);
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
if (rdtype == dns_rdatatype_a) {
adbname->expire_v4 = rdataset.ttl + now;
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb name %p: Caching negative entry for A (ttl %u)",
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
adbname, rdataset.ttl);
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
} else {
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb name %p: Caching negative entry for AAAA (ttl %u)",
be more cautious when updating expire times, and unify name/address buckets
1999-11-05 02:05:06 +00:00
adbname, rdataset.ttl);
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
adbname->expire_v6 = rdataset.ttl + now;
}
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
}
if (dns_rdataset_isassociated(&rdataset))
dns_rdataset_disassociate(&rdataset);
return (result);
}
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
static isc_result_t
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
dbfind_a6(dns_adbname_t *adbname, isc_stdtime_t now, isc_boolean_t use_hints)
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
{
isc_result_t result;
dns_rdataset_t rdataset;
dns_adb_t *adb;
dns_a6context_t a6ctx;
INSIST(DNS_ADBNAME_VALID(adbname));
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
INSIST(!NAME_FETCH_V6(adbname));
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
result = ISC_R_UNEXPECTED;
dns_rdataset_init(&rdataset);
result = dns_view_find(adb->view, &adbname->name, dns_rdatatype_a6,
now, DNS_DBFIND_GLUEOK, use_hints,
&rdataset, NULL);
switch (result) {
case DNS_R_GLUE:
case DNS_R_HINT:
case DNS_R_SUCCESS:
/*
* Start a6 chain follower. There is no need to poke people
* who might be waiting, since this is call requires there
* are none.
*/
dns_a6_init(&a6ctx, a6find, NULL, import_a6,
a6missing, adbname);
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
(void)dns_a6_foreach(&a6ctx, &rdataset, now);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
result = ISC_R_SUCCESS;
break;
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
case DNS_R_NCACHENXDOMAIN:
case DNS_R_NCACHENXRRSET:
/*
* We found a negative cache entry. Pull the TTL from it
* so we won't ask again for a while.
*/
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb name %p: Caching negative entry for A6 (ttl %u)",
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
adbname, rdataset.ttl);
adbname->expire_v6 = ISC_MIN(rdataset.ttl + now,
adbname->expire_v6);
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
}
if (dns_rdataset_isassociated(&rdataset))
dns_rdataset_disassociate(&rdataset);
return (result);
}
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
static void
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
fetch_callback(isc_task_t *task, isc_event_t *ev)
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
{
dns_fetchevent_t *dev;
dns_adbname_t *name;
dns_adb_t *adb;
dns_adbfetch_t *fetch;
int bucket;
isc_eventtype_t ev_status;
adb does fetches for A records now. Has a memory leak still.
1999-10-27 22:24:40 +00:00
isc_stdtime_t now;
isc_result_t result;
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
unsigned int address_type;
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
(void)task;
INSIST(ev->type == DNS_EVENT_FETCHDONE);
dev = (dns_fetchevent_t *)ev;
name = ev->arg;
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
bucket = name->lock_bucket;
LOCK(&adb->namelocks[bucket]);
clean up selection of which fetch is which in combined callback for A/AAAA
1999-11-04 09:04:29 +00:00
INSIST(NAME_FETCH_A(name) || NAME_FETCH_AAAA(name));
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
address_type = 0;
clean up selection of which fetch is which in combined callback for A/AAAA
1999-11-04 09:04:29 +00:00
if (NAME_FETCH_A(name) && (name->fetch_a->fetch == dev->fetch)) {
address_type = DNS_ADBFIND_INET;
fetch = name->fetch_a;
name->fetch_a = NULL;
} else if (NAME_FETCH_AAAA(name)
&& (name->fetch_aaaa->fetch == dev->fetch)) {
address_type = DNS_ADBFIND_INET6;
fetch = name->fetch_aaaa;
name->fetch_aaaa = NULL;
}
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
INSIST(address_type != 0);
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
dns_resolver_destroyfetch(adb->view->resolver, &fetch->fetch);
dev->fetch = NULL;
cleanup snapshot
1999-10-29 23:53:12 +00:00
ev_status = DNS_EVENT_ADBNOMOREADDRESSES;
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
/*
* Cleanup things we don't care about.
*/
if (dev->node != NULL)
dns_db_detachnode(dev->db, &dev->node);
if (dev->db != NULL)
dns_db_detach(&dev->db);
/*
* If this name is marked as dead, clean up, throwing away
* potentially good data.
*/
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (NAME_DEAD(name)) {
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
isc_boolean_t decr_adbrefcnt;
free_adbfetch(adb, &fetch);
isc_event_free(&ev);
kill_name(&name, DNS_EVENT_ADBCANCELED);
decr_adbrefcnt = ISC_FALSE;
if (adb->name_sd[bucket] && (adb->name_refcnt[bucket] == 0))
decr_adbrefcnt = ISC_TRUE;
UNLOCK(&adb->namelocks[bucket]);
if (decr_adbrefcnt)
dec_adb_irefcnt(adb, ISC_TRUE);
return;
}
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* If we got a negative cache response, remember it.
*/
if (NCACHE_RESULT(dev->result)) {
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
dev->rdataset->ttl = ISC_MIN(dev->rdataset->ttl,
ADB_CACHE_MINIMUM);
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
if (address_type == DNS_ADBFIND_INET) {
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb fetch name %p: "
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
"Caching negative entry for A (ttl %u)",
name, dev->rdataset->ttl);
name->expire_v4 = ISC_MIN(name->expire_v4,
dev->rdataset->ttl + now);
} else {
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb fetch name %p: "
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
"Caching negative entry for AAAA (ttl %u)",
name, dev->rdataset->ttl);
name->expire_v6 = ISC_MIN(name->expire_v6,
dev->rdataset->ttl + now);
}
goto out;
}
review checkpoint
1999-11-25 01:23:32 +00:00
/*
* XXXRTH CNAME/DNAME? We don't need to do this for targets
* of NS records, but what about other names?
*
* Need to do this for A6 too!
*/
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
/*
* Did we get back junk? If so, and there are no more fetches
* sitting out there, tell all the finds about it.
*/
remove checks for null view, since we won't let that happen. Add a bit of code to avoid pounding on servers that we can't find the addresses of. Right now the adb just stops checking for 5 minutes.
1999-11-04 09:42:46 +00:00
if (dev->result != ISC_R_SUCCESS) {
/* XXXMLG Don't pound on bad servers. */
if (address_type == DNS_ADBFIND_INET)
name->expire_v4 = ISC_MIN(name->expire_v4, now + 300);
else
name->expire_v6 = ISC_MIN(name->expire_v6, now + 300);
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
DP(1, "got junk in fetch for name %p (%s)",
name, isc_result_totext(dev->result));
remove checks for null view, since we won't let that happen. Add a bit of code to avoid pounding on servers that we can't find the addresses of. Right now the adb just stops checking for 5 minutes.
1999-11-04 09:42:46 +00:00
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
goto out;
remove checks for null view, since we won't let that happen. Add a bit of code to avoid pounding on servers that we can't find the addresses of. Right now the adb just stops checking for 5 minutes.
1999-11-04 09:42:46 +00:00
}
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
/*
* We got something potentially useful.
*/
result = isc_stdtime_get(&now);
if (result == ISC_R_SUCCESS)
simplify importing rdatasets. One function handles A and AAAA types.
1999-10-29 19:42:06 +00:00
result = import_rdataset(name, &fetch->rdataset, now);
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
if (result == ISC_R_SUCCESS)
ev_status = DNS_EVENT_ADBMOREADDRESSES;
out:
free_adbfetch(adb, &fetch);
isc_event_free(&ev);
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
clean_finds_at_name(name, ev_status, address_type);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
UNLOCK(&adb->namelocks[bucket]);
return;
}
a6 checkpoint
1999-10-30 01:22:16 +00:00
static void
fetch_callback_a6(isc_task_t *task, isc_event_t *ev)
{
dns_fetchevent_t *dev;
dns_adbname_t *name;
dns_adb_t *adb;
dns_adbfetch6_t *fetch;
int bucket;
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
isc_stdtime_t now;
isc_result_t result;
a6 checkpoint
1999-10-30 01:22:16 +00:00
(void)task;
INSIST(ev->type == DNS_EVENT_FETCHDONE);
dev = (dns_fetchevent_t *)ev;
name = ev->arg;
INSIST(DNS_ADBNAME_VALID(name));
adb = name->adb;
INSIST(DNS_ADB_VALID(adb));
bucket = name->lock_bucket;
LOCK(&adb->namelocks[bucket]);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
INSIST(!NAME_NEEDSPOKE(name));
add a few more logging lines; no functional change.
1999-10-30 02:40:59 +00:00
a6 checkpoint
1999-10-30 01:22:16 +00:00
for (fetch = ISC_LIST_HEAD(name->fetches_a6);
fetch != NULL;
fetch = ISC_LIST_NEXT(fetch, plink))
if (fetch->fetch == dev->fetch)
break;
INSIST(fetch != NULL);
ISC_LIST_UNLINK(name->fetches_a6, fetch, plink);
cleanup and fix a bug where finds will wait forever.
1999-11-01 20:16:35 +00:00
DP(ENTER_LEVEL, "ENTER: fetch_callback_a6() name %p", name);
a6 checkpoint
1999-10-30 01:22:16 +00:00
dns_resolver_destroyfetch(adb->view->resolver, &fetch->fetch);
dev->fetch = NULL;
/*
* Cleanup things we don't care about.
*/
if (dev->node != NULL)
dns_db_detachnode(dev->db, &dev->node);
if (dev->db != NULL)
dns_db_detach(&dev->db);
/*
* If this name is marked as dead, clean up, throwing away
* potentially good data.
*/
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (NAME_DEAD(name)) {
a6 checkpoint
1999-10-30 01:22:16 +00:00
isc_boolean_t decr_adbrefcnt;
free_adbfetch6(adb, &fetch);
isc_event_free(&ev);
kill_name(&name, DNS_EVENT_ADBCANCELED);
decr_adbrefcnt = ISC_FALSE;
if (adb->name_sd[bucket] && (adb->name_refcnt[bucket] == 0))
decr_adbrefcnt = ISC_TRUE;
UNLOCK(&adb->namelocks[bucket]);
if (decr_adbrefcnt)
dec_adb_irefcnt(adb, ISC_TRUE);
return;
}
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
result = isc_stdtime_get(&now);
if (result != ISC_R_SUCCESS)
goto out;
a6 checkpoint
1999-10-30 01:22:16 +00:00
/*
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
* If the A6 query didn't succeed, and this is the first query
* in the A6 chain, try AAAA records instead. For later failures,
* don't do this.
a6 checkpoint
1999-10-30 01:22:16 +00:00
*/
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
if (dev->result != ISC_R_SUCCESS) {
isc_boolean_t use_hints;
DP(DEF_LEVEL, "name %p: A6 failed, result %u",
name, dev->result);
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* If we got a negative cache response, remember it.
*/
if (NCACHE_RESULT(dev->result)) {
change macro name from ADB_NCACHE_MINIMUM to ADB_CACHE_MINIMUM since it's used as a general purpose minimum ttl, and actually set the TTL to the minimum when re get a negative cache entry.
1999-12-11 02:30:24 +00:00
dev->rdataset->ttl = ISC_MIN(dev->rdataset->ttl,
ADB_CACHE_MINIMUM);
Ignore ipv6 mapped ipv4 addresses. Set a default TTL for type 3 negative cache elements. This is local to the ADB, and cannot leak to clients, so no specs are violated. Change a logging level to be less verbose.
1999-12-01 02:05:16 +00:00
DP(NCACHE_LEVEL, "adb fetch name %p: "
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
"Caching negative entry for A6 (ttl %u)",
name, dev->rdataset->ttl);
name->expire_v6 = ISC_MIN(name->expire_v6,
dev->rdataset->ttl + now);
}
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
if (FETCH_USEHINTS(fetch))
use_hints = ISC_TRUE;
else
use_hints = ISC_FALSE;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
if (FETCH_FIRSTA6(fetch) && !NAME_HAS_V6(name)) {
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
DP(DEF_LEVEL,
"name %p: A6 query failed, starting AAAA", name);
/*
* Since this is the very first fetch, and it
* failed, we know there are no more running.
*/
result = dbfind_name(name, now, use_hints,
dns_rdatatype_aaaa);
if (result == ISC_R_SUCCESS) {
DP(DEF_LEVEL,
"name %p: callback_a6: Found AAAA for",
name);
name->flags |= NAME_NEEDS_POKE;
goto out;
}
Fix a lot of negative caching issues. I believe the code will use ncache responses from fetches and database lookups correctly now, but there needs to be a little more cleanup here and there. Bugs exist.
1999-11-24 19:23:27 +00:00
/*
* Listen to negative cache hints, and don't start
* another query.
*/
if (NCACHE_RESULT(result))
goto out;
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
/*
* Try to start fetches for AAAA.
*/
result = fetch_name_aaaa(name, now);
if (result == ISC_R_SUCCESS) {
DP(DEF_LEVEL,
"name %p: callback_a6: Started AAAA fetch",
name);
goto out;
}
}
a6 checkpoint
1999-10-30 01:22:16 +00:00
goto out;
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
}
a6 checkpoint
1999-10-30 01:22:16 +00:00
/*
* We got something potentially useful. Run the A6 chain
* follower on this A6 rdataset.
*/
fetch->a6ctx.chains = name->chains;
revise shutdown process; a6 chain expiration
1999-11-22 19:57:58 +00:00
(void)dns_a6_foreach(&fetch->a6ctx, dev->rdataset, now);
a6 checkpoint
1999-10-30 01:22:16 +00:00
out:
free_adbfetch6(adb, &fetch);
isc_event_free(&ev);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
if (NAME_NEEDSPOKE(name))
a6 checkpoint
1999-10-30 01:22:16 +00:00
clean_finds_at_name(name, DNS_EVENT_ADBMOREADDRESSES,
DNS_ADBFIND_INET6);
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
else if (!NAME_FETCH_V6(name))
a6 checkpoint
1999-10-30 01:22:16 +00:00
clean_finds_at_name(name, DNS_EVENT_ADBNOMOREADDRESSES,
DNS_ADBFIND_INET6);
dead/needs_poke are flags for adbnames, merge in Bob's changes
1999-10-30 01:58:02 +00:00
name->flags &= ~NAME_NEEDS_POKE;
a6 checkpoint
1999-10-30 01:22:16 +00:00
UNLOCK(&adb->namelocks[bucket]);
return;
}
fetch contexts
1999-10-26 01:12:20 +00:00
static isc_result_t
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
fetch_name_v4(dns_adbname_t *adbname, isc_stdtime_t now)
fetch contexts
1999-10-26 01:12:20 +00:00
{
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
isc_result_t result;
dns_adbfetch_t *fetch;
dns_rdataset_t nameservers;
dns_name_t fname;
isc_buffer_t buffer;
unsigned char ndata[256];
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
dns_adb_t *adb;
INSIST(DNS_ADBNAME_VALID(adbname));
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
INSIST(!NAME_FETCH_V4(adbname));
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
isc_buffer_init(&buffer, ndata, sizeof(ndata), ISC_BUFFERTYPE_BINARY);
fetch = NULL;
dns_name_init(&fname, NULL);
dns_name_setbuffer(&fname, &buffer);
dns_rdataset_init(&nameservers);
result = dns_view_findzonecut(adb->view, &adbname->name, &fname, now,
0, ISC_TRUE, &nameservers, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
fetch = new_adbfetch(adb);
if (fetch == NULL) {
result = ISC_R_NOMEMORY;
goto cleanup;
}
result = dns_resolver_createfetch(adb->view->resolver, &adbname->name,
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
dns_rdatatype_a, &fname,
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
&nameservers, NULL, 0,
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
adb->task, fetch_callback,
more v4/v6 splitting out
1999-10-29 01:26:45 +00:00
adbname, &fetch->rdataset, NULL,
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
&fetch->fetch);
if (result != ISC_R_SUCCESS)
goto cleanup;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
adbname->fetch_a = fetch;
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
fetch = NULL; /* keep us from cleaning this up below */
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
cleanup:
if (fetch != NULL)
free_adbfetch(adb, &fetch);
if (dns_rdataset_isassociated(&nameservers))
dns_rdataset_disassociate(&nameservers);
return (result);
}
static isc_result_t
fetch_name_aaaa(dns_adbname_t *adbname, isc_stdtime_t now)
{
isc_result_t result;
dns_adbfetch_t *fetch;
dns_rdataset_t nameservers;
dns_name_t fname;
isc_buffer_t buffer;
unsigned char ndata[256];
dns_adb_t *adb;
INSIST(DNS_ADBNAME_VALID(adbname));
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
INSIST(!NAME_FETCH_AAAA(adbname));
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
isc_buffer_init(&buffer, ndata, sizeof(ndata), ISC_BUFFERTYPE_BINARY);
fetch = NULL;
dns_name_init(&fname, NULL);
dns_name_setbuffer(&fname, &buffer);
dns_rdataset_init(&nameservers);
result = dns_view_findzonecut(adb->view, &adbname->name, &fname, now,
0, ISC_TRUE, &nameservers, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
fetch = new_adbfetch(adb);
if (fetch == NULL) {
result = ISC_R_NOMEMORY;
goto cleanup;
}
result = dns_resolver_createfetch(adb->view->resolver, &adbname->name,
a6 checkpoint 2
1999-10-30 01:35:51 +00:00
dns_rdatatype_aaaa, &fname,
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
&nameservers, NULL, 0,
snapshot; start noting negative cache ttls
1999-11-04 06:46:05 +00:00
adb->task, fetch_callback,
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
adbname, &fetch->rdataset, NULL,
&fetch->fetch);
if (result != ISC_R_SUCCESS)
goto cleanup;
fetch change: A -> pointer, AAAA -> pointer, A6 -> list
1999-10-29 21:48:51 +00:00
adbname->fetch_aaaa = fetch;
ipv6 AAAA queries work now.
1999-10-29 19:20:36 +00:00
fetch = NULL; /* keep us from cleaning this up below */
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
cleanup:
if (fetch != NULL)
free_adbfetch(adb, &fetch);
remove duplicate checks
1999-10-28 00:37:31 +00:00
if (dns_rdataset_isassociated(&nameservers))
dns_rdataset_disassociate(&nameservers);
snapshot; nearly all fetch infrastructure is in place.
1999-10-27 19:36:58 +00:00
return (result);
fetch contexts
1999-10-26 01:12:20 +00:00
}
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
static isc_result_t
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
fetch_name_a6(dns_adbname_t *adbname, isc_stdtime_t now,
isc_boolean_t use_hints)
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
{
isc_result_t result;
dns_adbfetch6_t *fetch;
dns_rdataset_t nameservers;
dns_name_t fname;
isc_buffer_t buffer;
unsigned char ndata[256];
dns_adb_t *adb;
INSIST(DNS_ADBNAME_VALID(adbname));
adb = adbname->adb;
INSIST(DNS_ADB_VALID(adb));
kill name->query_pending, since that bitmask is really represented more accurately by other means. Reverse the sense of fetch checking from NO_FETCH_A() and NO_FETCH_AAAA(), etc to NAME_FETCH_A(), NAME_FETCH_AAAA(), and add address family checks like NO_FETCH_V4() and _V6(). Fix a database dump bug where the A fetches were printed twice rather than printing the AAAA fetches. Add printing of A6 fetches.
1999-11-02 18:36:54 +00:00
INSIST(!NAME_FETCH_V6(adbname));
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
isc_buffer_init(&buffer, ndata, sizeof(ndata), ISC_BUFFERTYPE_BINARY);
fetch = NULL;
dns_name_init(&fname, NULL);
dns_name_setbuffer(&fname, &buffer);
dns_rdataset_init(&nameservers);
result = dns_view_findzonecut(adb->view, &adbname->name, &fname, now,
0, ISC_TRUE, &nameservers, NULL);
if (result != ISC_R_SUCCESS)
goto cleanup;
fetch = new_adbfetch6(adb, adbname, NULL);
if (fetch == NULL) {
result = ISC_R_NOMEMORY;
goto cleanup;
}
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
if (use_hints)
fetch->flags |= FETCH_USE_HINTS;
clean up macros to avoid HAVE_* names. First a6 is a fetch, not name, attribute.
1999-11-04 08:48:47 +00:00
fetch->flags |= FETCH_FIRST_A6;
snapshot; a6 seems to work?
1999-10-30 02:26:03 +00:00
result = dns_resolver_createfetch(adb->view->resolver, &adbname->name,
dns_rdatatype_a6, &fname,
&nameservers, NULL, 0,
adb->task, fetch_callback_a6,
adbname, &fetch->rdataset, NULL,
&fetch->fetch);
if (result != ISC_R_SUCCESS)
goto cleanup;
ISC_LIST_APPEND(adbname->fetches_a6, fetch, plink);
fetch = NULL; /* keep us from cleaning this up below */
cleanup:
if (fetch != NULL)
free_adbfetch6(adb, &fetch);
if (dns_rdataset_isassociated(&nameservers))
dns_rdataset_disassociate(&nameservers);
return (result);
}
fix a few bugs, and start an AAAA db lookup/query if no A6 is found
1999-11-02 00:29:45 +00:00
/* XXXMLG
* Needs to take a find argument and an address info, no zone or adb, since
* these can be extracted from the find itself.
*/
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
isc_result_t
make lameness work, now. Grr.
1999-10-19 21:28:09 +00:00
dns_adb_marklame(dns_adb_t *adb, dns_adbaddrinfo_t *addr, dns_name_t *zone,
isc_stdtime_t expire_time)
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
{
dns_adbzoneinfo_t *zi;
make lameness work, now. Grr.
1999-10-19 21:28:09 +00:00
int bucket;
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(DNS_ADBADDRINFO_VALID(addr));
REQUIRE(zone != NULL);
zi = new_adbzoneinfo(adb, zone);
if (zi == NULL)
return (ISC_R_NOMEMORY);
make lameness work, now. Grr.
1999-10-19 21:28:09 +00:00
zi->lame_timer = expire_time;
bucket = addr->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
private links are plink, public links are publink
1999-10-29 01:53:20 +00:00
ISC_LIST_PREPEND(addr->entry->zoneinfo, zi, plink);
make lameness work, now. Grr.
1999-10-19 21:28:09 +00:00
UNLOCK(&adb->entrylocks[bucket]);
Add the API to allow marking an address as lame for a zone
1999-10-19 21:10:29 +00:00
return (ISC_R_SUCCESS);
}
Add a way to adjust goodness.
1999-10-19 22:06:08 +00:00
void
dns_adb_adjustgoodness(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
int goodness_adjustment)
{
int bucket;
int old_goodness, new_goodness;
Allow the srtt value to be adjusted, and update the goodness and srtt when they are modified
1999-10-19 22:21:27 +00:00
REQUIRE(DNS_ADB_VALID(adb));
Add a way to adjust goodness.
1999-10-19 22:06:08 +00:00
REQUIRE(DNS_ADBADDRINFO_VALID(addr));
if (goodness_adjustment == 0)
return;
bucket = addr->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
old_goodness = addr->entry->goodness;
if (goodness_adjustment > 0) {
if (old_goodness > INT_MAX - goodness_adjustment)
new_goodness = INT_MAX;
else
new_goodness = old_goodness + goodness_adjustment;
} else {
if (old_goodness < INT_MIN - goodness_adjustment)
new_goodness = INT_MAX;
else
new_goodness = old_goodness + goodness_adjustment;
}
addr->entry->goodness = new_goodness;
Allow the srtt value to be adjusted, and update the goodness and srtt when they are modified
1999-10-19 22:21:27 +00:00
addr->goodness = new_goodness;
Add a way to adjust goodness.
1999-10-19 22:06:08 +00:00
UNLOCK(&adb->entrylocks[bucket]);
}
Allow the srtt value to be adjusted, and update the goodness and srtt when they are modified
1999-10-19 22:21:27 +00:00
void
dns_adb_adjustsrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
unsigned int rtt, unsigned int factor)
{
int bucket;
unsigned int new_srtt;
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(DNS_ADBADDRINFO_VALID(addr));
Minor API change. The 'factor' now ranges from 0..10. See adb.h for details.
1999-11-19 00:30:13 +00:00
REQUIRE(factor <= 10);
Allow the srtt value to be adjusted, and update the goodness and srtt when they are modified
1999-10-19 22:21:27 +00:00
bucket = addr->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
Minor API change. The 'factor' now ranges from 0..10. See adb.h for details.
1999-11-19 00:30:13 +00:00
new_srtt = (addr->entry->srtt / 10 * factor)
+ (rtt / 10 * (10 - factor));
Allow the srtt value to be adjusted, and update the goodness and srtt when they are modified
1999-10-19 22:21:27 +00:00
addr->entry->srtt = new_srtt;
addr->srtt = new_srtt;
UNLOCK(&adb->entrylocks[bucket]);
}
add dns_adb_changeflags()
1999-11-16 06:53:29 +00:00
void
dns_adb_changeflags(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
unsigned int bits, unsigned int mask)
{
int bucket;
REQUIRE(DNS_ADB_VALID(adb));
REQUIRE(DNS_ADBADDRINFO_VALID(addr));
bucket = addr->entry->lock_bucket;
LOCK(&adb->entrylocks[bucket]);
bits was being ORed with the mask instead of ANDed. Update the entry's flags too.
1999-11-16 21:04:18 +00:00
addr->entry->flags = (addr->entry->flags & ~mask) | (bits & mask);
/*
* Note that we do not update the other bits in addr->flags with
* the most recent values from addr->entry->flags.
*
* XXXRTH I think this is what we want, because otherwise flags
* that the caller didn't ask to change could be updated.
*/
addr->flags = (addr->flags & ~mask) | (bits & mask);
add dns_adb_changeflags()
1999-11-16 06:53:29 +00:00
UNLOCK(&adb->entrylocks[bucket]);
}
Reference in New Issue Copy Permalink