From cfa3ab7f89293811d60e2d5d16a30f3c22924b22 Mon Sep 17 00:00:00 2001 From: Mark Andrews Date: Fri, 31 Aug 2001 02:01:56 +0000 Subject: [PATCH] Timers now use isc_time_t rather than isc_stdtime_t. zone->expiretime now has a consistant epoch [RT #1686] --- lib/dns/zone.c | 218 ++++++++++++++++++++++++------------------------- 1 file changed, 109 insertions(+), 109 deletions(-) diff --git a/lib/dns/zone.c b/lib/dns/zone.c index 1f1fc3ce50..1ec4ff27da 100644 --- a/lib/dns/zone.c +++ b/lib/dns/zone.c @@ -15,7 +15,7 @@ * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -/* $Id: zone.c,v 1.335 2001/08/30 06:48:43 marka Exp $ */ +/* $Id: zone.c,v 1.336 2001/08/31 02:01:56 marka Exp $ */ #include @@ -148,9 +148,9 @@ struct dns_zone { unsigned int options; unsigned int db_argc; char **db_argv; - isc_stdtime_t expiretime; - isc_stdtime_t refreshtime; - isc_stdtime_t dumptime; + isc_time_t expiretime; + isc_time_t refreshtime; + isc_time_t dumptime; isc_time_t loadtime; isc_uint32_t serial; isc_uint32_t refresh; @@ -361,7 +361,7 @@ struct dns_io { isc_event_t *event; }; -static void zone_settimer(dns_zone_t *, isc_stdtime_t); +static void zone_settimer(dns_zone_t *, isc_time_t *); static void cancel_refresh(dns_zone_t *); static void zone_debuglog(dns_zone_t *zone, const char *, int debuglevel, const char *msg, ...) ISC_FORMAT_PRINTF(4, 5); @@ -481,9 +481,9 @@ dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) { zone->options = 0; zone->db_argc = 0; zone->db_argv = NULL; - zone->expiretime = 0; - zone->refreshtime = 0; - zone->dumptime = 0; + isc_time_settoepoch(&zone->expiretime); + isc_time_settoepoch(&zone->refreshtime); + isc_time_settoepoch(&zone->dumptime); isc_time_settoepoch(&zone->loadtime); zone->serial = 0; zone->refresh = DNS_ZONE_DEFAULTREFRESH; @@ -885,14 +885,14 @@ zone_isdynamic(dns_zone_t *zone) { static isc_result_t zone_load(dns_zone_t *zone, unsigned int flags) { isc_result_t result; - isc_stdtime_t now; + isc_time_t now; isc_time_t loadtime, filetime; dns_db_t *db = NULL; REQUIRE(DNS_ZONE_VALID(zone)); LOCK_ZONE(zone); - isc_stdtime_get(&now); + isc_time_now(&now); INSIST(zone->type != dns_zone_none); @@ -1122,10 +1122,10 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime, unsigned int soacount = 0; unsigned int nscount = 0; isc_uint32_t serial, refresh, retry, expire, minimum; - isc_stdtime_t now; + isc_time_t now; isc_boolean_t needdump = ISC_FALSE; - isc_stdtime_get(&now); + isc_time_now(&now); /* * Initiate zone transfer? We may need a error code that @@ -1244,17 +1244,20 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime, if (zone->type == dns_zone_slave || zone->type == dns_zone_stub) { isc_time_t t; + isc_interval_t i; result = isc_file_getmodtime(zone->journal, &t); if (result != ISC_R_SUCCESS) result = isc_file_getmodtime(zone->masterfile, &t); - if (result == ISC_R_SUCCESS) - zone->expiretime = isc_time_seconds(&t) + - zone->expire; - else - zone->expiretime = now + zone->retry; + if (result == ISC_R_SUCCESS) { + isc_interval_set(&i, zone->expire, 0); + isc_time_add(&t, &i, &zone->expiretime); + } else { + isc_interval_set(&i, zone->retry, 0); + isc_time_add(&now, &i, &zone->expiretime); + } zone->refreshtime = now; } break; @@ -1291,7 +1294,7 @@ zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime, if (needdump) zone_needdump(zone, DNS_DUMP_DELAY); if (zone->task != NULL) - zone_settimer(zone, now); + zone_settimer(zone, &now); dns_zone_log(zone, ISC_LOG_INFO, "loaded serial %u", zone->serial); return (result); @@ -1871,14 +1874,14 @@ dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) { void dns_zone_maintenance(dns_zone_t *zone) { const char me[] = "dns_zone_maintenance"; - isc_stdtime_t now; + isc_time_t now; REQUIRE(DNS_ZONE_VALID(zone)); ENTER; LOCK_ZONE(zone); - isc_stdtime_get(&now); - zone_settimer(zone, now); + isc_time_now(&now); + zone_settimer(zone, &now); UNLOCK_ZONE(zone); } @@ -1892,7 +1895,7 @@ was_dumping(dns_zone_t *zone) { DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DUMPING); if (!dumping) { DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP); - zone->dumptime = 0; + isc_time_settoepoch(&zone->dumptime); } return (dumping); } @@ -1900,7 +1903,7 @@ was_dumping(dns_zone_t *zone) { static void zone_maintenance(dns_zone_t *zone) { const char me[] = "zone_maintenance"; - isc_stdtime_t now; + isc_time_t now; isc_result_t result; isc_boolean_t dumping; @@ -1917,7 +1920,7 @@ zone_maintenance(dns_zone_t *zone) { if (zone->view == NULL || zone->view->adb == NULL) return; - isc_stdtime_get(&now); + isc_time_now(&now); /* * Expire check. @@ -1926,7 +1929,7 @@ zone_maintenance(dns_zone_t *zone) { case dns_zone_slave: case dns_zone_stub: LOCK_ZONE(zone); - if (now >= zone->expiretime && + if (isc_time_compare(&now, &zone->expiretime) >= 0 && DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) { zone_expire(zone); zone->refreshtime = now; @@ -1944,7 +1947,7 @@ zone_maintenance(dns_zone_t *zone) { case dns_zone_slave: case dns_zone_stub: if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DIALREFRESH) && - now >= zone->refreshtime) + isc_time_compare(&now, &zone->refreshtime) >= 0) dns_zone_refresh(zone); break; default: @@ -1959,7 +1962,7 @@ zone_maintenance(dns_zone_t *zone) { case dns_zone_slave: LOCK_ZONE(zone); if (zone->masterfile != NULL && - now >= zone->dumptime && + isc_time_compare(&now, &zone->dumptime) >= 0 && DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) && DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP)) { dumping = was_dumping(zone); @@ -1990,7 +1993,7 @@ zone_maintenance(dns_zone_t *zone) { default: break; } - zone_settimer(zone, now); + zone_settimer(zone, &now); } void @@ -2030,7 +2033,7 @@ zone_expire(dns_zone_t *zone) { void dns_zone_refresh(dns_zone_t *zone) { - isc_stdtime_t now; + isc_interval_t i; isc_uint32_t oldflags; REQUIRE(DNS_ZONE_VALID(zone)); @@ -2038,8 +2041,6 @@ dns_zone_refresh(dns_zone_t *zone) { if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) return; - isc_stdtime_get(&now); - /* * Set DNS_ZONEFLG_REFRESH so that there is only one refresh operation * in progress at a time. @@ -2063,11 +2064,9 @@ dns_zone_refresh(dns_zone_t *zone) { * Setting this to the retry time will do that. XXXMLG * If we are successful it will be reset using zone->refresh. */ - zone->refreshtime = now + - isc_random_jitter(zone->retry, zone->retry / 4); - zone_debuglog(zone, "dns_zone_refresh", 20, - "refresh time (%u/%u), now %u", - zone->refreshtime, zone->refresh, now); + isc_interval_set(&i, isc_random_jitter(zone->retry, zone->retry / 4), + 0); + isc_time_nowplusinterval(&zone->refreshtime, &i); /* * When lacking user-specified timer values from the SOA, @@ -2122,7 +2121,9 @@ dns_zone_dump(dns_zone_t *zone) { static void zone_needdump(dns_zone_t *zone, unsigned int delay) { - isc_stdtime_t now; + isc_time_t dumptime; + isc_time_t now; + isc_interval_t i; /* * 'zone' locked by caller @@ -2138,16 +2139,18 @@ zone_needdump(dns_zone_t *zone, unsigned int delay) { DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) == 0) return; - isc_stdtime_get(&now); + isc_interval_set(&i, delay, 0); + isc_time_now(&now); + isc_time_add(&now, &i, &dumptime); /* add some noise */ delay = isc_random_jitter(delay, delay/4); DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDDUMP); - if (zone->dumptime == 0 || - zone->dumptime > now + delay) - zone->dumptime = now + delay; - zone_settimer(zone, now); + if (isc_time_isepoch(&zone->dumptime) || + isc_time_compare(&zone->dumptime, &dumptime) > 0) + zone->dumptime = dumptime; + zone_settimer(zone, &now); } static isc_result_t @@ -2234,7 +2237,7 @@ zone_dump(dns_zone_t *zone, isc_boolean_t compact) { DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) { DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDDUMP); DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_DUMPING); - zone->dumptime = 0; + isc_time_settoepoch(&zone->dumptime); again = ISC_TRUE; } UNLOCK_ZONE(zone); @@ -2615,15 +2618,15 @@ notify_send(dns_notify_t *notify) { void dns_zone_notify(dns_zone_t *zone) { - isc_stdtime_t now; + isc_time_t now; REQUIRE(DNS_ZONE_VALID(zone)); LOCK_ZONE(zone); DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDNOTIFY); - isc_stdtime_get(&now); - zone_settimer(zone, now); + isc_time_now(&now); + zone_settimer(zone, &now); UNLOCK_ZONE(zone); } @@ -2916,8 +2919,9 @@ stub_callback(isc_task_t *task, isc_event_t *event) { char master[ISC_SOCKADDR_FORMATSIZE]; isc_uint32_t nscnt, cnamecnt; isc_result_t result; - isc_stdtime_t now; + isc_time_t now; isc_boolean_t exiting = ISC_FALSE; + isc_interval_t i; stub = revent->ev_arg; INSIST(DNS_STUB_VALID(stub)); @@ -2928,7 +2932,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) { ENTER; - isc_stdtime_get(&now); + isc_time_now(&now); if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) { zone_debuglog(zone, me, 1, "exiting"); @@ -3048,13 +3052,12 @@ stub_callback(isc_task_t *task, isc_event_t *event) { LOCK_ZONE(zone); dns_request_destroy(&zone->request); DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH); - zone->refreshtime = now + - isc_random_jitter(zone->refresh, zone->refresh / 4); - zone->expiretime = now + zone->expire; - zone_debuglog(zone, me, 20, - "refresh time (%u/%u), now %u", - zone->refreshtime, zone->refresh, now); - zone_settimer(zone, now); + isc_interval_set(&i, isc_random_jitter(zone->refresh, + zone->refresh / 4), 0); + isc_time_add(&now, &i, &zone->refreshtime); + isc_interval_set(&i, zone->expire, 0); + isc_time_add(&now, &i, &zone->expiretime); + zone_settimer(zone, &now); UNLOCK_ZONE(zone); goto free_stub; @@ -3073,7 +3076,7 @@ stub_callback(isc_task_t *task, isc_event_t *event) { if (exiting || zone->curmaster >= zone->masterscnt) { DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH); - zone_settimer(zone, now); + zone_settimer(zone, &now); UNLOCK_ZONE(zone); goto free_stub; } @@ -3113,13 +3116,14 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { dns_zone_t *zone; dns_message_t *msg = NULL; isc_uint32_t soacnt, cnamecnt, soacount, nscount; - isc_stdtime_t now; + isc_time_t now; char master[ISC_SOCKADDR_FORMATSIZE]; dns_rdataset_t *rdataset; dns_rdata_t rdata = DNS_RDATA_INIT; dns_rdata_soa_t soa; isc_result_t result; isc_uint32_t serial; + isc_interval_t i; zone = revent->ev_arg; INSIST(DNS_ZONE_VALID(zone)); @@ -3134,7 +3138,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { isc_sockaddr_format(&zone->masteraddr, master, sizeof(master)); - isc_stdtime_get(&now); + isc_time_now(&now); if (revent->result != ISC_R_SUCCESS) { dns_zone_log(zone, ISC_LOG_INFO, @@ -3313,9 +3317,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { dns_message_destroy(&msg); } else if (isc_serial_eq(soa.serial, zone->serial)) { if (zone->masterfile != NULL) { - isc_time_t t; - (void)isc_time_now(&t); - result = isc_file_settime(zone->masterfile, &t); + result = isc_file_settime(zone->masterfile, &now); if (result != ISC_R_SUCCESS) dns_zone_log(zone, ISC_LOG_ERROR, "refresh: could not set file " @@ -3323,12 +3325,11 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { zone->masterfile, dns_result_totext(result)); } - zone->refreshtime = now + - isc_random_jitter(zone->refresh, zone->refresh / 4); - zone->expiretime = now + zone->expire; - zone_debuglog(zone, me, 20, "refresh time (%u/%u), now %u", - zone->refreshtime, zone->refresh, now); - + isc_interval_set(&i, isc_random_jitter(zone->refresh, + zone->refresh / 4), 0); + isc_time_add(&now, &i, &zone->refreshtime); + isc_interval_set(&i, zone->expire, 0); + isc_time_add(&now, &i, &zone->expiretime); goto next_master; } else { zone_debuglog(zone, me, 1, "ahead"); @@ -3352,7 +3353,7 @@ refresh_callback(isc_task_t *task, isc_event_t *event) { DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDREFRESH); zone->refreshtime = now; } - zone_settimer(zone, now); + zone_settimer(zone, &now); UNLOCK_ZONE(zone); goto detach; } @@ -3792,9 +3793,9 @@ zone_timer(isc_task_t *task, isc_event_t *event) { } static void -zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { +zone_settimer(dns_zone_t *zone, isc_time_t *now) { const char me[] = "zone_settimer"; - isc_stdtime_t next = 0; + isc_time_t next; isc_time_t expires; isc_interval_t interval; isc_result_t result; @@ -3803,21 +3804,24 @@ zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING)) return; + isc_time_settoepoch(&next); + switch (zone->type) { case dns_zone_master: if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY)) - next = now; + next = *now; if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP) && !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_DUMPING)) { - INSIST(zone->dumptime != 0); - if (zone->dumptime < next || next == 0) + INSIST(!isc_time_isepoch(&zone->dumptime)); + if (isc_time_compare(&zone->dumptime, &next) < 0 || + isc_time_isepoch(&next)) next = zone->dumptime; } break; case dns_zone_slave: if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY)) - next = now; + next = *now; /*FALLTHROUGH*/ case dns_zone_stub: @@ -3825,13 +3829,15 @@ zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOMASTERS) && !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NOREFRESH) && !DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADING)) { - INSIST(zone->refreshtime != 0); - if (zone->refreshtime < next || next == 0) + INSIST(!isc_time_isepoch(&zone->refreshtime)); + if (isc_time_compare(&zone->refreshtime, &next) < 0 || + isc_time_isepoch(&next)) next = zone->refreshtime; } if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) { - INSIST(zone->expiretime != 0); - if (zone->expiretime < next || next == 0) + INSIST(!isc_time_isepoch(&zone->expiretime)); + if (isc_time_compare(&zone->expiretime, &next) < 0 || + isc_time_isepoch(&next)) next = zone->expiretime; } break; @@ -3840,7 +3846,7 @@ zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { break; } - if (next == 0) { + if (isc_time_isepoch(&next)) { zone_debuglog(zone, me, 10, "settimer inactive"); result = isc_timer_reset(zone->timer, isc_timertype_inactive, NULL, NULL, ISC_TRUE); @@ -3849,16 +3855,15 @@ zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { "could not deactivate zone timer: %s", isc_result_totext(result)); } else { - if (next <= now) { - next = now; - (void)isc_time_now(&expires); + if (isc_time_compare(&next, now) <= 0) { + expires = *now; isc_interval_set(&interval, 0, 0); } else { + int s; isc_time_settoepoch(&expires); - isc_interval_set(&interval, next - now, 0); + s = isc_time_microdiff(&next, now) / 1000000; + isc_interval_set(&interval, s, 0); } - zone_debuglog(zone, me, 10, "settimer %d %d = %d seconds", - next, now, next - now); result = isc_timer_reset(zone->timer, isc_timertype_once, &expires, &interval, ISC_TRUE); if (result != ISC_R_SUCCESS) @@ -3871,7 +3876,7 @@ zone_settimer(dns_zone_t *zone, isc_stdtime_t now) { static void cancel_refresh(dns_zone_t *zone) { const char me[] = "cancel_refresh"; - isc_stdtime_t now; + isc_time_t now; /* * 'zone' locked by caller. @@ -3883,8 +3888,8 @@ cancel_refresh(dns_zone_t *zone) { ENTER; DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH); - isc_stdtime_get(&now); - zone_settimer(zone, now); + isc_time_now(&now); + zone_settimer(zone, &now); } static isc_result_t @@ -4043,7 +4048,7 @@ dns_zone_notifyreceive(dns_zone_t *zone, isc_sockaddr_t *from, dns_rdataset_t *rdataset = NULL; dns_rdata_t rdata = DNS_RDATA_INIT; isc_result_t result; - isc_stdtime_t now; + isc_time_t now; char fromtext[ISC_SOCKADDR_FORMATSIZE]; int match = 0; isc_netaddr_t netaddr; @@ -4173,7 +4178,7 @@ dns_zone_notifyreceive(dns_zone_t *zone, isc_sockaddr_t *from, fromtext); return (ISC_R_SUCCESS); } - isc_stdtime_get(&now); + isc_time_now(&now); zone->notifyfrom = *from; UNLOCK_ZONE(zone); dns_zone_refresh(zone); @@ -4714,8 +4719,8 @@ zone_replacedb(dns_zone_t *zone, dns_db_t *db, isc_boolean_t dump) { static void zone_xfrdone(dns_zone_t *zone, isc_result_t result) { - const char me[] = "zone_xfrdone"; - isc_stdtime_t now; + isc_time_t now; + isc_interval_t i; isc_boolean_t again = ISC_FALSE; unsigned int soacount; unsigned int nscount; @@ -4731,7 +4736,7 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) { INSIST((zone->flags & DNS_ZONEFLG_REFRESH) != 0); DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_REFRESH); - isc_stdtime_get(&now); + isc_time_now(&now); switch (result) { case ISC_R_SUCCESS: DNS_ZONE_SETFLAG(zone, DNS_ZONEFLG_NEEDNOTIFY); @@ -4749,16 +4754,13 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) { * won't hurt with an AXFR. */ if (zone->masterfile != NULL || zone->journal != NULL) { - isc_time_t t; - - (void)isc_time_now(&t); - result = ISC_R_FAILURE; if (zone->journal != NULL) - result = isc_file_settime(zone->journal, &t); + result = isc_file_settime(zone->journal, &now); if (result != ISC_R_SUCCESS && zone->masterfile != NULL) - result = isc_file_settime(zone->masterfile, &t); + result = isc_file_settime(zone->masterfile, + &now); if (result != ISC_R_SUCCESS) dns_zone_log(zone, ISC_LOG_ERROR, "transfer: could not set file " @@ -4805,16 +4807,14 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) { if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDREFRESH)) { DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NEEDREFRESH); zone->refreshtime = now; - zone->expiretime = now + zone->expire; + isc_interval_set(&i, zone->expire, 0); + isc_time_add(&now, &i, &zone->expiretime); } else { - zone->refreshtime = now + - isc_random_jitter(zone->refresh, - zone->refresh / 4); - zone_debuglog(zone, me, 20, - "refresh time (%u/%u), now %u", - zone->refreshtime, zone->refresh, now); - - zone->expiretime = now + zone->expire; + isc_interval_set(&i, isc_random_jitter(zone->refresh, + zone->refresh / 4), 0); + isc_time_add(&now, &i, &zone->refreshtime); + isc_interval_set(&i, zone->expire, 0); + isc_time_add(&now, &i, &zone->expiretime); } if (result == ISC_R_SUCCESS && xfrresult == ISC_R_SUCCESS) dns_zone_log(zone, ISC_LOG_INFO, @@ -4838,7 +4838,7 @@ zone_xfrdone(dns_zone_t *zone, isc_result_t result) { } break; } - zone_settimer(zone, now); + zone_settimer(zone, &now); /* * If creating the transfer object failed, zone->xfr is NULL.