]>
git.ipfire.org Git - people/ms/dnsmasq.git/blob - src/cache.c
1 /* dnsmasq is Copyright (c) 2000-2012 Simon Kelley
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 dated June, 1991, or
6 (at your option) version 3 dated 29 June, 2007.
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
13 You should have received a copy of the GNU General Public License
14 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 static struct crec
*cache_head
= NULL
, *cache_tail
= NULL
, **hash_table
= NULL
;
21 static struct crec
*dhcp_spare
= NULL
;
23 static struct crec
*new_chain
= NULL
;
24 static int cache_inserted
= 0, cache_live_freed
= 0, insert_error
;
25 static union bigname
*big_free
= NULL
;
26 static int bignames_left
, hash_size
;
29 /* type->string mapping: this is also used by the name-hash function as a mixing table. */
32 const char * const name
;
66 static void cache_free(struct crec
*crecp
);
67 static void cache_unlink(struct crec
*crecp
);
68 static void cache_link(struct crec
*crecp
);
69 static void rehash(int size
);
70 static void cache_hash(struct crec
*crecp
);
77 bignames_left
= daemon
->cachesize
/10;
79 if (daemon
->cachesize
> 0)
81 crecp
= safe_malloc(daemon
->cachesize
*sizeof(struct crec
));
83 for (i
=0; i
< daemon
->cachesize
; i
++, crecp
++)
91 /* create initial hash table*/
92 rehash(daemon
->cachesize
);
95 /* In most cases, we create the hash table once here by calling this with (hash_table == NULL)
96 but if the hosts file(s) are big (some people have 50000 ad-block entries), the table
97 will be much too small, so the hosts reading code calls rehash every 1000 addresses, to
99 static void rehash(int size
)
101 struct crec
**new, **old
, *p
, *tmp
;
102 int i
, new_size
, old_size
;
104 /* hash_size is a power of two. */
105 for (new_size
= 64; new_size
< size
/10; new_size
= new_size
<< 1);
107 /* must succeed in getting first instance, failure later is non-fatal */
109 new = safe_malloc(new_size
* sizeof(struct crec
*));
110 else if (new_size
<= hash_size
|| !(new = whine_malloc(new_size
* sizeof(struct crec
*))))
113 for(i
= 0; i
< new_size
; i
++)
117 old_size
= hash_size
;
119 hash_size
= new_size
;
123 for (i
= 0; i
< old_size
; i
++)
124 for (p
= old
[i
]; p
; p
= tmp
)
133 static struct crec
**hash_bucket(char *name
)
135 unsigned int c
, val
= 017465; /* Barker code - minimum self-correlation in cyclic shift */
136 const unsigned char *mix_tab
= (const unsigned char*)typestr
;
138 while((c
= (unsigned char) *name
++))
140 /* don't use tolower and friends here - they may be messed up by LOCALE */
141 if (c
>= 'A' && c
<= 'Z')
143 val
= ((val
<< 7) | (val
>> (32 - 7))) + (mix_tab
[(val
+ c
) & 0x3F] ^ c
);
146 /* hash_size is a power of two */
147 return hash_table
+ ((val
^ (val
>> 16)) & (hash_size
- 1));
150 static void cache_hash(struct crec
*crecp
)
152 /* maintain an invariant that all entries with F_REVERSE set
153 are at the start of the hash-chain and all non-reverse
154 immortal entries are at the end of the hash-chain.
155 This allows reverse searches and garbage collection to be optimised */
157 struct crec
**up
= hash_bucket(cache_get_name(crecp
));
159 if (!(crecp
->flags
& F_REVERSE
))
161 while (*up
&& ((*up
)->flags
& F_REVERSE
))
162 up
= &((*up
)->hash_next
);
164 if (crecp
->flags
& F_IMMORTAL
)
165 while (*up
&& !((*up
)->flags
& F_IMMORTAL
))
166 up
= &((*up
)->hash_next
);
168 crecp
->hash_next
= *up
;
172 static void cache_free(struct crec
*crecp
)
174 crecp
->flags
&= ~F_FORWARD
;
175 crecp
->flags
&= ~F_REVERSE
;
176 crecp
->uid
= uid
++; /* invalidate CNAMES pointing to this. */
179 cache_tail
->next
= crecp
;
182 crecp
->prev
= cache_tail
;
186 /* retrieve big name for further use. */
187 if (crecp
->flags
& F_BIGNAME
)
189 crecp
->name
.bname
->next
= big_free
;
190 big_free
= crecp
->name
.bname
;
191 crecp
->flags
&= ~F_BIGNAME
;
195 /* insert a new cache entry at the head of the list (youngest entry) */
196 static void cache_link(struct crec
*crecp
)
198 if (cache_head
) /* check needed for init code */
199 cache_head
->prev
= crecp
;
200 crecp
->next
= cache_head
;
207 /* remove an arbitrary cache entry for promotion */
208 static void cache_unlink (struct crec
*crecp
)
211 crecp
->prev
->next
= crecp
->next
;
213 cache_head
= crecp
->next
;
216 crecp
->next
->prev
= crecp
->prev
;
218 cache_tail
= crecp
->prev
;
221 char *cache_get_name(struct crec
*crecp
)
223 if (crecp
->flags
& F_BIGNAME
)
224 return crecp
->name
.bname
->name
;
225 else if (crecp
->flags
& F_NAMEP
)
226 return crecp
->name
.namep
;
228 return crecp
->name
.sname
;
231 static int is_outdated_cname_pointer(struct crec
*crecp
)
233 if (!(crecp
->flags
& F_CNAME
))
236 if (crecp
->addr
.cname
.cache
&& crecp
->addr
.cname
.uid
== crecp
->addr
.cname
.cache
->uid
)
242 static int is_expired(time_t now
, struct crec
*crecp
)
244 if (crecp
->flags
& F_IMMORTAL
)
247 if (difftime(now
, crecp
->ttd
) < 0)
253 static int cache_scan_free(char *name
, struct all_addr
*addr
, time_t now
, unsigned short flags
)
255 /* Scan and remove old entries.
256 If (flags & F_FORWARD) then remove any forward entries for name and any expired
257 entries but only in the same hash bucket as name.
258 If (flags & F_REVERSE) then remove any reverse entries for addr and any expired
259 entries in the whole cache.
260 If (flags == 0) remove any expired entries in the whole cache.
262 In the flags & F_FORWARD case, the return code is valid, and returns zero if the
263 name exists in the cache as a HOSTS or DHCP entry (these are never deleted)
265 We take advantage of the fact that hash chains have stuff in the order <reverse>,<other>,<immortal>
266 so that when we hit an entry which isn't reverse and is immortal, we're done. */
268 struct crec
*crecp
, **up
;
270 if (flags
& F_FORWARD
)
272 for (up
= hash_bucket(name
), crecp
= *up
; crecp
; crecp
= crecp
->hash_next
)
273 if (is_expired(now
, crecp
) || is_outdated_cname_pointer(crecp
))
275 *up
= crecp
->hash_next
;
276 if (!(crecp
->flags
& (F_HOSTS
| F_DHCP
)))
282 else if ((crecp
->flags
& F_FORWARD
) &&
283 ((flags
& crecp
->flags
& (F_IPV4
| F_IPV6
)) || ((crecp
->flags
| flags
) & F_CNAME
)) &&
284 hostname_isequal(cache_get_name(crecp
), name
))
286 if (crecp
->flags
& (F_HOSTS
| F_DHCP
))
288 *up
= crecp
->hash_next
;
293 up
= &crecp
->hash_next
;
299 int addrlen
= (flags
& F_IPV6
) ? IN6ADDRSZ
: INADDRSZ
;
301 int addrlen
= INADDRSZ
;
303 for (i
= 0; i
< hash_size
; i
++)
304 for (crecp
= hash_table
[i
], up
= &hash_table
[i
];
305 crecp
&& ((crecp
->flags
& F_REVERSE
) || !(crecp
->flags
& F_IMMORTAL
));
306 crecp
= crecp
->hash_next
)
307 if (is_expired(now
, crecp
))
309 *up
= crecp
->hash_next
;
310 if (!(crecp
->flags
& (F_HOSTS
| F_DHCP
)))
316 else if (!(crecp
->flags
& (F_HOSTS
| F_DHCP
)) &&
317 (flags
& crecp
->flags
& F_REVERSE
) &&
318 (flags
& crecp
->flags
& (F_IPV4
| F_IPV6
)) &&
319 memcmp(&crecp
->addr
.addr
, addr
, addrlen
) == 0)
321 *up
= crecp
->hash_next
;
326 up
= &crecp
->hash_next
;
332 /* Note: The normal calling sequence is
337 but an abort can cause the cache_end_insert to be missed
338 in which can the next cache_start_insert cleans things up. */
340 void cache_start_insert(void)
342 /* Free any entries which didn't get committed during the last
347 struct crec
*tmp
= new_chain
->next
;
348 cache_free(new_chain
);
355 struct crec
*cache_insert(char *name
, struct all_addr
*addr
,
356 time_t now
, unsigned long ttl
, unsigned short flags
)
359 union bigname
*big_name
= NULL
;
360 int freed_all
= flags
& F_REVERSE
;
363 log_query(flags
| F_UPSTREAM
, name
, addr
, NULL
);
365 /* if previous insertion failed give up now. */
369 /* First remove any expired entries and entries for the name/address we
370 are currently inserting. Fail is we attempt to delete a name from
371 /etc/hosts or DHCP. */
372 if (!cache_scan_free(name
, addr
, now
, flags
))
378 /* Now get a cache entry from the end of the LRU list */
380 if (!(new = cache_tail
)) /* no entries left - cache is too small, bail */
386 /* End of LRU list is still in use: if we didn't scan all the hash
387 chains for expired entries do that now. If we already tried that
388 then it's time to start spilling things. */
390 if (new->flags
& (F_FORWARD
| F_REVERSE
))
392 /* If free_avail set, we believe that an entry has been freed.
393 Bugs have been known to make this not true, resulting in
394 a tight loop here. If that happens, abandon the
395 insert. Once in this state, all inserts will probably fail. */
404 free_avail
= 1; /* Must be free space now. */
405 cache_scan_free(cache_get_name(new), &new->addr
.addr
, now
, new->flags
);
410 cache_scan_free(NULL
, NULL
, now
, 0);
416 /* Check if we need to and can allocate extra memory for a long name.
417 If that fails, give up now. */
418 if (name
&& (strlen(name
) > SMALLDNAME
-1))
423 big_free
= big_free
->next
;
425 else if (!bignames_left
||
426 !(big_name
= (union bigname
*)whine_malloc(sizeof(union bigname
))))
436 /* Got the rest: finally grab entry. */
444 new->name
.bname
= big_name
;
445 new->flags
|= F_BIGNAME
;
449 strcpy(cache_get_name(new), name
);
451 *cache_get_name(new) = 0;
454 new->addr
.addr
= *addr
;
456 new->addr
.cname
.cache
= NULL
;
458 new->ttd
= now
+ (time_t)ttl
;
459 new->next
= new_chain
;
465 /* after end of insertion, commit the new entries */
466 void cache_end_insert(void)
473 struct crec
*tmp
= new_chain
->next
;
474 /* drop CNAMEs which didn't find a target. */
475 if (is_outdated_cname_pointer(new_chain
))
476 cache_free(new_chain
);
479 cache_hash(new_chain
);
480 cache_link(new_chain
);
488 struct crec
*cache_find_by_name(struct crec
*crecp
, char *name
, time_t now
, unsigned short prot
)
492 if (crecp
) /* iterating */
496 /* first search, look for relevant entries and push to top of list
497 also free anything which has expired */
498 struct crec
*next
, **up
, **insert
= NULL
, **chainp
= &ans
;
499 unsigned short ins_flags
= 0;
501 for (up
= hash_bucket(name
), crecp
= *up
; crecp
; crecp
= next
)
503 next
= crecp
->hash_next
;
505 if (!is_expired(now
, crecp
) && !is_outdated_cname_pointer(crecp
))
507 if ((crecp
->flags
& F_FORWARD
) &&
508 (crecp
->flags
& prot
) &&
509 hostname_isequal(cache_get_name(crecp
), name
))
511 if (crecp
->flags
& (F_HOSTS
| F_DHCP
))
514 chainp
= &crecp
->next
;
522 /* Move all but the first entry up the hash chain
523 this implements round-robin.
524 Make sure that re-ordering doesn't break the hash-chain
527 if (insert
&& (crecp
->flags
& (F_REVERSE
| F_IMMORTAL
)) == ins_flags
)
529 *up
= crecp
->hash_next
;
530 crecp
->hash_next
= *insert
;
532 insert
= &crecp
->hash_next
;
539 ins_flags
= crecp
->flags
& (F_REVERSE
| F_IMMORTAL
);
541 up
= &crecp
->hash_next
;
545 /* case : not expired, incorrect entry. */
546 up
= &crecp
->hash_next
;
550 /* expired entry, free it */
551 *up
= crecp
->hash_next
;
552 if (!(crecp
->flags
& (F_HOSTS
| F_DHCP
)))
560 *chainp
= cache_head
;
564 (ans
->flags
& F_FORWARD
) &&
565 (ans
->flags
& prot
) &&
566 hostname_isequal(cache_get_name(ans
), name
))
572 struct crec
*cache_find_by_addr(struct crec
*crecp
, struct all_addr
*addr
,
573 time_t now
, unsigned short prot
)
577 int addrlen
= (prot
== F_IPV6
) ? IN6ADDRSZ
: INADDRSZ
;
579 int addrlen
= INADDRSZ
;
582 if (crecp
) /* iterating */
586 /* first search, look for relevant entries and push to top of list
587 also free anything which has expired. All the reverse entries are at the
588 start of the hash chain, so we can give up when we find the first
591 struct crec
**up
, **chainp
= &ans
;
593 for (i
=0; i
<hash_size
; i
++)
594 for (crecp
= hash_table
[i
], up
= &hash_table
[i
];
595 crecp
&& (crecp
->flags
& F_REVERSE
);
596 crecp
= crecp
->hash_next
)
597 if (!is_expired(now
, crecp
))
599 if ((crecp
->flags
& prot
) &&
600 memcmp(&crecp
->addr
.addr
, addr
, addrlen
) == 0)
602 if (crecp
->flags
& (F_HOSTS
| F_DHCP
))
605 chainp
= &crecp
->next
;
613 up
= &crecp
->hash_next
;
617 *up
= crecp
->hash_next
;
618 if (!(crecp
->flags
& (F_HOSTS
| F_DHCP
)))
625 *chainp
= cache_head
;
629 (ans
->flags
& F_REVERSE
) &&
630 (ans
->flags
& prot
) &&
631 memcmp(&ans
->addr
.addr
, addr
, addrlen
) == 0)
637 static void add_hosts_entry(struct crec
*cache
, struct all_addr
*addr
, int addrlen
,
638 unsigned short flags
, int index
, struct crec
**rhash
, int hashsz
)
640 struct crec
*lookup
= cache_find_by_name(NULL
, cache
->name
.sname
, 0, flags
& (F_IPV4
| F_IPV6
));
641 int i
, nameexists
= 0;
645 /* Remove duplicates in hosts files. */
646 if (lookup
&& (lookup
->flags
& F_HOSTS
))
649 if (memcmp(&lookup
->addr
.addr
, addr
, addrlen
) == 0)
656 /* Ensure there is only one address -> name mapping (first one trumps)
657 We do this by steam here, The entries are kept in hash chains, linked
658 by ->next (which is unused at this point) held in hash buckets in
659 the array rhash, hashed on address. Note that rhash and the values
660 in ->next are only valid whilst reading hosts files: the buckets are
661 then freed, and the ->next pointer used for other things.
663 Only insert each unique address once into this hashing structure.
665 This complexity avoids O(n^2) divergent CPU use whilst reading
666 large (10000 entry) hosts files. */
669 for (j
= 0, i
= 0; i
< addrlen
; i
++)
670 j
= (j
*2 +((unsigned char *)addr
)[i
]) % hashsz
;
672 for (lookup
= rhash
[j
]; lookup
; lookup
= lookup
->next
)
673 if ((lookup
->flags
& flags
& (F_IPV4
| F_IPV6
)) &&
674 memcmp(&lookup
->addr
.addr
, addr
, addrlen
) == 0)
680 /* maintain address hash chain, insert new unique address */
683 cache
->next
= rhash
[j
];
687 cache
->flags
= flags
;
689 memcpy(&cache
->addr
.addr
, addr
, addrlen
);
692 /* don't need to do alias stuff for second and subsequent addresses. */
694 for (a
= daemon
->cnames
; a
; a
= a
->next
)
695 if (hostname_isequal(cache
->name
.sname
, a
->target
) &&
696 (lookup
= whine_malloc(sizeof(struct crec
))))
698 lookup
->flags
= F_FORWARD
| F_IMMORTAL
| F_NAMEP
| F_HOSTS
| F_CNAME
;
699 lookup
->name
.namep
= a
->alias
;
700 lookup
->addr
.cname
.cache
= cache
;
701 lookup
->addr
.cname
.uid
= index
;
706 static int eatspace(FILE *f
)
712 if ((c
= getc(f
)) == '#')
713 while (c
!= '\n' && c
!= EOF
)
730 static int gettok(FILE *f
, char *token
)
736 if ((c
= getc(f
)) == EOF
)
737 return (count
== 0) ? EOF
: 1;
739 if (isspace(c
) || c
== '#')
745 if (count
< (MAXDNAME
- 1))
753 static int read_hostsfile(char *filename
, int index
, int cache_size
, struct crec
**rhash
, int hashsz
)
755 FILE *f
= fopen(filename
, "r");
756 char *token
= daemon
->namebuff
, *domain_suffix
= NULL
;
757 int addr_count
= 0, name_count
= cache_size
, lineno
= 0;
758 unsigned short flags
= 0;
759 struct all_addr addr
;
760 int atnl
, addrlen
= 0;
764 my_syslog(LOG_ERR
, _("failed to load names from %s: %s"), filename
, strerror(errno
));
770 while ((atnl
= gettok(f
, token
)) != EOF
)
775 if (inet_pton(AF_INET
, token
, &addr
) > 0)
777 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV4
;
779 domain_suffix
= get_domain(addr
.addr
.addr4
);
781 else if (inet_pton(AF_INET6
, token
, &addr
) > 0)
783 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV6
;
785 domain_suffix
= daemon
->domain_suffix
;
788 if ((addr
.addr
.addr4
.s_addr
= inet_addr(token
)) != (in_addr_t
) -1)
790 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV4
;
792 domain_suffix
= get_domain(addr
.addr
.addr4
);
797 my_syslog(LOG_ERR
, _("bad address at %s line %d"), filename
, lineno
);
799 atnl
= gettok(f
, token
);
805 /* rehash every 1000 names. */
806 if ((name_count
- cache_size
) > 1000)
809 cache_size
= name_count
;
818 if ((atnl
= gettok(f
, token
)) == EOF
)
821 fqdn
= !!strchr(token
, '.');
823 if ((canon
= canonicalise(token
, &nomem
)))
825 /* If set, add a version of the name with a default domain appended */
826 if (option_bool(OPT_EXPAND
) && domain_suffix
&& !fqdn
&&
827 (cache
= whine_malloc(sizeof(struct crec
) +
828 strlen(canon
)+2+strlen(domain_suffix
)-SMALLDNAME
)))
830 strcpy(cache
->name
.sname
, canon
);
831 strcat(cache
->name
.sname
, ".");
832 strcat(cache
->name
.sname
, domain_suffix
);
833 add_hosts_entry(cache
, &addr
, addrlen
, flags
, index
, rhash
, hashsz
);
836 if ((cache
= whine_malloc(sizeof(struct crec
) + strlen(canon
)+1-SMALLDNAME
)))
838 strcpy(cache
->name
.sname
, canon
);
839 add_hosts_entry(cache
, &addr
, addrlen
, flags
, index
, rhash
, hashsz
);
846 my_syslog(LOG_ERR
, _("bad name at %s line %d"), filename
, lineno
);
853 my_syslog(LOG_INFO
, _("read %s - %d addresses"), filename
, addr_count
);
858 void cache_reload(void)
860 struct crec
*cache
, **up
, *tmp
;
861 int revhashsz
, i
, total_size
= daemon
->cachesize
;
862 struct hostsfile
*ah
;
864 cache_inserted
= cache_live_freed
= 0;
866 for (i
=0; i
<hash_size
; i
++)
867 for (cache
= hash_table
[i
], up
= &hash_table
[i
]; cache
; cache
= tmp
)
869 tmp
= cache
->hash_next
;
870 if (cache
->flags
& F_HOSTS
)
872 *up
= cache
->hash_next
;
875 else if (!(cache
->flags
& F_DHCP
))
877 *up
= cache
->hash_next
;
878 if (cache
->flags
& F_BIGNAME
)
880 cache
->name
.bname
->next
= big_free
;
881 big_free
= cache
->name
.bname
;
886 up
= &cache
->hash_next
;
889 if (option_bool(OPT_NO_HOSTS
) && !daemon
->addn_hosts
)
891 if (daemon
->cachesize
> 0)
892 my_syslog(LOG_INFO
, _("cleared cache"));
896 /* borrow the packet buffer for a temporary by-address hash */
897 memset(daemon
->packet
, 0, daemon
->packet_buff_sz
);
898 revhashsz
= daemon
->packet_buff_sz
/ sizeof(struct crec
*);
899 /* we overwrote the buffer... */
900 daemon
->srv_save
= NULL
;
902 if (!option_bool(OPT_NO_HOSTS
))
903 total_size
= read_hostsfile(HOSTSFILE
, 0, total_size
, (struct crec
**)daemon
->packet
, revhashsz
);
905 daemon
->addn_hosts
= expand_filelist(daemon
->addn_hosts
);
906 for (ah
= daemon
->addn_hosts
; ah
; ah
= ah
->next
)
907 if (!(ah
->flags
& AH_INACTIVE
))
908 total_size
= read_hostsfile(ah
->fname
, ah
->index
, total_size
, (struct crec
**)daemon
->packet
, revhashsz
);
911 char *get_domain(struct in_addr addr
)
913 struct cond_domain
*c
;
915 for (c
= daemon
->cond_domain
; c
; c
= c
->next
)
916 if (ntohl(addr
.s_addr
) >= ntohl(c
->start
.s_addr
) &&
917 ntohl(addr
.s_addr
) <= ntohl(c
->end
.s_addr
))
920 return daemon
->domain_suffix
;
924 struct in_addr
a_record_from_hosts(char *name
, time_t now
)
926 struct crec
*crecp
= NULL
;
929 while ((crecp
= cache_find_by_name(crecp
, name
, now
, F_IPV4
)))
930 if (crecp
->flags
& F_HOSTS
)
931 return *(struct in_addr
*)&crecp
->addr
;
933 my_syslog(MS_DHCP
| LOG_WARNING
, _("No IPv4 address found for %s"), name
);
939 void cache_unhash_dhcp(void)
941 struct crec
*cache
, **up
;
944 for (i
=0; i
<hash_size
; i
++)
945 for (cache
= hash_table
[i
], up
= &hash_table
[i
]; cache
; cache
= cache
->hash_next
)
946 if (cache
->flags
& F_DHCP
)
948 *up
= cache
->hash_next
;
949 cache
->next
= dhcp_spare
;
953 up
= &cache
->hash_next
;
956 void cache_add_dhcp_entry(char *host_name
,
957 struct in_addr
*host_address
, time_t ttd
)
959 struct crec
*crec
= NULL
, *aliasc
;
960 unsigned short flags
= F_NAMEP
| F_DHCP
| F_FORWARD
| F_IPV4
| F_REVERSE
;
964 while ((crec
= cache_find_by_name(crec
, host_name
, 0, F_IPV4
| F_CNAME
)))
966 /* check all addresses associated with name */
967 if (crec
->flags
& F_HOSTS
)
969 /* if in hosts, don't need DHCP record */
972 if (crec
->flags
& F_CNAME
)
973 my_syslog(MS_DHCP
| LOG_WARNING
,
974 _("%s is a CNAME, not giving it to the DHCP lease of %s"),
975 host_name
, inet_ntoa(*host_address
));
976 else if (crec
->addr
.addr
.addr
.addr4
.s_addr
!= host_address
->s_addr
)
978 strcpy(daemon
->namebuff
, inet_ntoa(crec
->addr
.addr
.addr
.addr4
));
979 my_syslog(MS_DHCP
| LOG_WARNING
,
980 _("not giving name %s to the DHCP lease of %s because "
981 "the name exists in %s with address %s"),
982 host_name
, inet_ntoa(*host_address
),
983 record_source(crec
->uid
), daemon
->namebuff
);
986 else if (!(crec
->flags
& F_DHCP
))
988 cache_scan_free(host_name
, NULL
, 0, crec
->flags
& (F_IPV4
| F_CNAME
| F_FORWARD
));
989 /* scan_free deletes all addresses associated with name */
997 if ((crec
= cache_find_by_addr(NULL
, (struct all_addr
*)host_address
, 0, F_IPV4
)))
999 if (crec
->flags
& F_NEG
)
1000 cache_scan_free(NULL
, (struct all_addr
*)host_address
, 0, F_IPV4
| F_REVERSE
);
1002 /* avoid multiple reverse mappings */
1003 flags
&= ~F_REVERSE
;
1006 if ((crec
= dhcp_spare
))
1007 dhcp_spare
= dhcp_spare
->next
;
1008 else /* need new one */
1009 crec
= whine_malloc(sizeof(struct crec
));
1011 if (crec
) /* malloc may fail */
1013 crec
->flags
= flags
;
1015 crec
->flags
|= F_IMMORTAL
;
1018 crec
->addr
.addr
.addr
.addr4
= *host_address
;
1019 crec
->name
.namep
= host_name
;
1023 for (a
= daemon
->cnames
; a
; a
= a
->next
)
1024 if (hostname_isequal(host_name
, a
->target
))
1026 if ((aliasc
= dhcp_spare
))
1027 dhcp_spare
= dhcp_spare
->next
;
1028 else /* need new one */
1029 aliasc
= whine_malloc(sizeof(struct crec
));
1033 aliasc
->flags
= F_FORWARD
| F_NAMEP
| F_DHCP
| F_CNAME
;
1035 aliasc
->flags
|= F_IMMORTAL
;
1038 aliasc
->name
.namep
= a
->alias
;
1039 aliasc
->addr
.cname
.cache
= crec
;
1040 aliasc
->addr
.cname
.uid
= crec
->uid
;
1049 void dump_cache(time_t now
)
1051 struct server
*serv
, *serv1
;
1053 my_syslog(LOG_INFO
, _("time %lu"), (unsigned long)now
);
1054 my_syslog(LOG_INFO
, _("cache size %d, %d/%d cache insertions re-used unexpired cache entries."),
1055 daemon
->cachesize
, cache_live_freed
, cache_inserted
);
1056 my_syslog(LOG_INFO
, _("queries forwarded %u, queries answered locally %u"),
1057 daemon
->queries_forwarded
, daemon
->local_answer
);
1059 /* sum counts from different records for same server */
1060 for (serv
= daemon
->servers
; serv
; serv
= serv
->next
)
1061 serv
->flags
&= ~SERV_COUNTED
;
1063 for (serv
= daemon
->servers
; serv
; serv
= serv
->next
)
1065 (SERV_NO_ADDR
| SERV_LITERAL_ADDRESS
| SERV_COUNTED
| SERV_USE_RESOLV
| SERV_NO_REBIND
)))
1068 unsigned int queries
= 0, failed_queries
= 0;
1069 for (serv1
= serv
; serv1
; serv1
= serv1
->next
)
1070 if (!(serv1
->flags
&
1071 (SERV_NO_ADDR
| SERV_LITERAL_ADDRESS
| SERV_COUNTED
| SERV_USE_RESOLV
| SERV_NO_REBIND
)) &&
1072 sockaddr_isequal(&serv
->addr
, &serv1
->addr
))
1074 serv1
->flags
|= SERV_COUNTED
;
1075 queries
+= serv1
->queries
;
1076 failed_queries
+= serv1
->failed_queries
;
1078 port
= prettyprint_addr(&serv
->addr
, daemon
->addrbuff
);
1079 my_syslog(LOG_INFO
, _("server %s#%d: queries sent %u, retried or failed %u"), daemon
->addrbuff
, port
, queries
, failed_queries
);
1082 if (option_bool(OPT_DEBUG
) || option_bool(OPT_LOG
))
1084 struct crec
*cache
;
1086 my_syslog(LOG_INFO
, "Host Address Flags Expires");
1088 for (i
=0; i
<hash_size
; i
++)
1089 for (cache
= hash_table
[i
]; cache
; cache
= cache
->hash_next
)
1091 char *a
, *p
= daemon
->namebuff
;
1092 p
+= sprintf(p
, "%-40.40s ", cache_get_name(cache
));
1093 if ((cache
->flags
& F_NEG
) && (cache
->flags
& F_FORWARD
))
1095 else if (cache
->flags
& F_CNAME
)
1098 if (!is_outdated_cname_pointer(cache
))
1099 a
= cache_get_name(cache
->addr
.cname
.cache
);
1104 a
= daemon
->addrbuff
;
1105 if (cache
->flags
& F_IPV4
)
1106 inet_ntop(AF_INET
, &cache
->addr
.addr
, a
, ADDRSTRLEN
);
1107 else if (cache
->flags
& F_IPV6
)
1108 inet_ntop(AF_INET6
, &cache
->addr
.addr
, a
, ADDRSTRLEN
);
1112 a
= inet_ntoa(cache
->addr
.addr
.addr
.addr4
);
1114 p
+= sprintf(p
, "%-30.30s %s%s%s%s%s%s%s%s%s%s ", a
,
1115 cache
->flags
& F_IPV4
? "4" : "",
1116 cache
->flags
& F_IPV6
? "6" : "",
1117 cache
->flags
& F_CNAME
? "C" : "",
1118 cache
->flags
& F_FORWARD
? "F" : " ",
1119 cache
->flags
& F_REVERSE
? "R" : " ",
1120 cache
->flags
& F_IMMORTAL
? "I" : " ",
1121 cache
->flags
& F_DHCP
? "D" : " ",
1122 cache
->flags
& F_NEG
? "N" : " ",
1123 cache
->flags
& F_NXDOMAIN
? "X" : " ",
1124 cache
->flags
& F_HOSTS
? "H" : " ");
1125 #ifdef HAVE_BROKEN_RTC
1126 p
+= sprintf(p
, "%lu", cache
->flags
& F_IMMORTAL
? 0: (unsigned long)(cache
->ttd
- now
));
1128 p
+= sprintf(p
, "%s", cache
->flags
& F_IMMORTAL
? "\n" : ctime(&(cache
->ttd
)));
1129 /* ctime includes trailing \n - eat it */
1132 my_syslog(LOG_INFO
, daemon
->namebuff
);
1137 char *record_source(int index
)
1139 struct hostsfile
*ah
;
1144 for (ah
= daemon
->addn_hosts
; ah
; ah
= ah
->next
)
1145 if (ah
->index
== index
)
1151 void querystr(char *str
, unsigned short type
)
1155 sprintf(str
, "query[type=%d]", type
);
1156 for (i
= 0; i
< (sizeof(typestr
)/sizeof(typestr
[0])); i
++)
1157 if (typestr
[i
].type
== type
)
1158 sprintf(str
,"query[%s]", typestr
[i
].name
);
1161 void log_query(unsigned int flags
, char *name
, struct all_addr
*addr
, char *arg
)
1163 char *source
, *dest
= daemon
->addrbuff
;
1166 if (!option_bool(OPT_LOG
))
1172 inet_ntop(flags
& F_IPV4
? AF_INET
: AF_INET6
,
1173 addr
, daemon
->addrbuff
, ADDRSTRLEN
);
1175 strncpy(daemon
->addrbuff
, inet_ntoa(addr
->addr
.addr4
), ADDRSTRLEN
);
1179 if (flags
& F_REVERSE
)
1182 name
= daemon
->addrbuff
;
1187 if (flags
& F_NXDOMAIN
)
1190 dest
= "NXDOMAIN-IPv4";
1191 else if (flags
& F_IPV6
)
1192 dest
= "NXDOMAIN-IPv6";
1199 dest
= "NODATA-IPv4";
1200 else if (flags
& F_IPV6
)
1201 dest
= "NODATA-IPv6";
1206 else if (flags
& F_CNAME
)
1208 else if (flags
& F_RRNAME
)
1211 if (flags
& F_CONFIG
)
1213 else if (flags
& F_DHCP
)
1215 else if (flags
& F_HOSTS
)
1217 else if (flags
& F_UPSTREAM
)
1219 else if (flags
& F_SERVER
)
1221 source
= "forwarded";
1224 else if (flags
& F_QUERY
)
1232 if (strlen(name
) == 0)
1235 my_syslog(LOG_INFO
, "%s %s %s %s", source
, name
, verb
, dest
);