← Back to branch summary

~ubuntu-branches/ubuntu/maverick/bind9/maverick

« back to all changes in this revision

Viewing changes to lib/dns/cache.c

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2005-04-19 10:21:58 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050419102158-kp20cp1bqf4ivpzy
Tags: 1:9.3.1-2ubuntu1
resync with debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/dns/cache.c
15
15
 * PERFORMANCE OF THIS SOFTWARE.
16
16
 */
17
17
 
18
 
/* $Id: cache.c,v 1.45.2.7 2004/03/09 06:10:59 marka Exp $ */
 
18
/* $Id: cache.c,v 1.45.2.4.8.7 2004/03/08 02:07:52 marka Exp $ */
19
19
 
20
20
#include <config.h>
21
21
 
31
31
#include <dns/events.h>
32
32
#include <dns/log.h>
33
33
#include <dns/masterdump.h>
 
34
#include <dns/rdata.h>
 
35
#include <dns/rdataset.h>
 
36
#include <dns/rdatasetiter.h>
34
37
#include <dns/result.h>
35
38
 
36
39
#define CACHE_MAGIC             ISC_MAGIC('$', '$', '$', '$')
167
170
        REQUIRE(*cachep == NULL);
168
171
        REQUIRE(mctx != NULL);
169
172
 
170
 
        cache = isc_mem_get(mctx, sizeof *cache);
 
173
        cache = isc_mem_get(mctx, sizeof(*cache));
171
174
        if (cache == NULL)
172
175
                return (ISC_R_NOMEMORY);
173
176
 
255
258
 cleanup_lock:
256
259
        DESTROYLOCK(&cache->lock);
257
260
 cleanup_mem:
258
 
        isc_mem_put(mctx, cache, sizeof *cache);
 
261
        isc_mem_put(mctx, cache, sizeof(*cache));
259
262
        isc_mem_detach(&mctx);
260
263
        return (result);
261
264
}
307
310
        DESTROYLOCK(&cache->filelock);
308
311
        cache->magic = 0;
309
312
        mctx = cache->mctx;
310
 
        isc_mem_put(cache->mctx, cache, sizeof *cache);
 
313
        isc_mem_put(cache->mctx, cache, sizeof(*cache));
311
314
        isc_mem_detach(&mctx);
312
315
}
313
316
 
349
352
                 * When the cache is shut down, dump it to a file if one is
350
353
                 * specified.
351
354
                 */
352
 
                dns_cache_dump(cache);
 
355
                isc_result_t result = dns_cache_dump(cache);
 
356
                if (result != ISC_R_SUCCESS)
 
357
                        isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 
358
                                      DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
 
359
                                      "error dumping cache: %s ",
 
360
                                      isc_result_totext(result));
353
361
 
354
362
                /*
355
363
                 * If the cleaner task exists, let it free the cache.
434
442
void
435
443
dns_cache_setcleaninginterval(dns_cache_t *cache, unsigned int t) {
436
444
        isc_interval_t interval;
 
445
        isc_result_t result;
437
446
 
438
447
        LOCK(&cache->lock);
439
448
 
447
456
        cache->cleaner.cleaning_interval = t;
448
457
 
449
458
        if (t == 0) {
450
 
                isc_timer_reset(cache->cleaner.cleaning_timer,
451
 
                                isc_timertype_inactive, NULL, NULL, ISC_TRUE);
 
459
                result = isc_timer_reset(cache->cleaner.cleaning_timer,
 
460
                                         isc_timertype_inactive,
 
461
                                         NULL, NULL, ISC_TRUE);
452
462
        } else {
453
463
                isc_interval_set(&interval, cache->cleaner.cleaning_interval,
454
464
                                 0);
455
 
                isc_timer_reset(cache->cleaner.cleaning_timer,
456
 
                                isc_timertype_ticker,
457
 
                                NULL, &interval, ISC_FALSE);
 
465
                result = isc_timer_reset(cache->cleaner.cleaning_timer,
 
466
                                         isc_timertype_ticker,
 
467
                                         NULL, &interval, ISC_FALSE);
458
468
        }
 
469
        if (result != ISC_R_SUCCESS)    
 
470
                isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 
471
                              DNS_LOGMODULE_CACHE, ISC_LOG_WARNING,
 
472
                              "could not set cache cleaning interval: %s",
 
473
                              isc_result_totext(result));
 
474
 
459
475
 unlock:
460
476
        UNLOCK(&cache->lock);
461
477
}
646
662
        INSIST(task == cleaner->task);
647
663
        INSIST(event->ev_type == ISC_TIMEREVENT_TICK);
648
664
 
 
665
        isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
 
666
                      ISC_LOG_DEBUG(1), "cache cleaning timer fired, "
 
667
                      "cleaner state = %d", cleaner->state);
 
668
 
649
669
        if (cleaner->state == cleaner_s_idle)
650
670
                begin_cleaning(cleaner);
651
671
 
667
687
        INSIST(event->ev_type == DNS_EVENT_CACHEOVERMEM);
668
688
        INSIST(cleaner->overmem_event == NULL);
669
689
 
 
690
        isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_CACHE,
 
691
                      ISC_LOG_DEBUG(1), "overmem_cleaning_action called, "
 
692
                      "overmem = %d, state = %d", cleaner->overmem,
 
693
                      cleaner->state);
 
694
 
670
695
        LOCK(&cleaner->lock);
671
696
 
672
697
        if (cleaner->overmem) {
940
965
                isc_timer_detach(&cache->cleaner.cleaning_timer);
941
966
 
942
967
        /* Make sure we don't reschedule anymore. */
943
 
        isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL);
 
968
        (void)isc_task_purge(task, NULL, DNS_EVENT_CACHECLEAN, NULL);
944
969
 
945
970
        UNLOCK(&cache->lock);
946
971
 
961
986
        cache->db = db;
962
987
        return (ISC_R_SUCCESS);
963
988
}
 
989
 
 
990
isc_result_t
 
991
dns_cache_flushname(dns_cache_t *cache, dns_name_t *name) {
 
992
        isc_result_t result;
 
993
        dns_rdatasetiter_t *iter = NULL;
 
994
        dns_dbnode_t *node = NULL;
 
995
        dns_db_t *db = NULL;
 
996
        
 
997
        LOCK(&cache->lock);
 
998
        if (cache->db != NULL)
 
999
                dns_db_attach(cache->db, &db);
 
1000
        UNLOCK(&cache->lock);
 
1001
        if (db == NULL)
 
1002
                return (ISC_R_SUCCESS);
 
1003
        result = dns_db_findnode(cache->db, name, ISC_FALSE, &node);
 
1004
        if (result == ISC_R_NOTFOUND) {
 
1005
                result = ISC_R_SUCCESS;
 
1006
                goto cleanup_db;
 
1007
        }
 
1008
        if (result != ISC_R_SUCCESS)
 
1009
                goto cleanup_db;
 
1010
 
 
1011
        result = dns_db_allrdatasets(cache->db, node, NULL,
 
1012
                                     (isc_stdtime_t)0, &iter);
 
1013
        if (result != ISC_R_SUCCESS)
 
1014
                goto cleanup_node;
 
1015
 
 
1016
        for (result = dns_rdatasetiter_first(iter);
 
1017
             result == ISC_R_SUCCESS;
 
1018
             result = dns_rdatasetiter_next(iter))
 
1019
        {
 
1020
                dns_rdataset_t rdataset;
 
1021
                dns_rdataset_init(&rdataset);
 
1022
 
 
1023
                dns_rdatasetiter_current(iter, &rdataset);
 
1024
 
 
1025
                for (result = dns_rdataset_first(&rdataset);
 
1026
                     result == ISC_R_SUCCESS;
 
1027
                     result = dns_rdataset_next(&rdataset))
 
1028
                {
 
1029
                        dns_rdata_t rdata = DNS_RDATA_INIT;
 
1030
                        dns_rdatatype_t covers;
 
1031
 
 
1032
                        dns_rdataset_current(&rdataset, &rdata);
 
1033
                        if (rdata.type == dns_rdatatype_rrsig)
 
1034
                                covers = dns_rdata_covers(&rdata);
 
1035
                        else
 
1036
                                covers = 0;
 
1037
                        result = dns_db_deleterdataset(cache->db, node, NULL,
 
1038
                                                       rdata.type, covers);
 
1039
                        if (result != ISC_R_SUCCESS &&
 
1040
                            result != DNS_R_UNCHANGED)
 
1041
                                break;
 
1042
                }
 
1043
                dns_rdataset_disassociate(&rdataset);
 
1044
                if (result != ISC_R_NOMORE)
 
1045
                        break;
 
1046
        }
 
1047
        if (result == ISC_R_NOMORE)
 
1048
                result = ISC_R_SUCCESS;
 
1049
 
 
1050
        dns_rdatasetiter_destroy(&iter);
 
1051
 
 
1052
 cleanup_node:
 
1053
        dns_db_detachnode(cache->db, &node);
 
1054
 
 
1055
 cleanup_db:
 
1056
        dns_db_detach(&db);
 
1057
        return (result);
 
1058
}