]>
git.ipfire.org Git - people/ms/dnsmasq.git/blob - src/cache.c
1 /* dnsmasq is Copyright (c) 2000-2011 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
, int addr_dup
)
640 struct crec
*lookup
= cache_find_by_name(NULL
, cache
->name
.sname
, 0, flags
& (F_IPV4
| F_IPV6
));
641 int i
, nameexists
= 0;
644 /* Remove duplicates in hosts files. */
645 if (lookup
&& (lookup
->flags
& F_HOSTS
))
648 if (memcmp(&lookup
->addr
.addr
, addr
, addrlen
) == 0)
655 /* Ensure there is only one address -> name mapping (first one trumps)
656 We do this by steam here, first we see if the address is the same as
657 the last one we saw, which eliminates most in the case of an ad-block
658 file with thousands of entries for the same address.
659 Then we search and bail at the first matching address that came from
660 a HOSTS file. Since the first host entry gets reverse, we know
661 then that it must exist without searching exhaustively for it. */
666 for (i
=0; i
<hash_size
; i
++)
668 for (lookup
= hash_table
[i
]; lookup
; lookup
= lookup
->hash_next
)
669 if ((lookup
->flags
& F_HOSTS
) &&
670 (lookup
->flags
& flags
& (F_IPV4
| F_IPV6
)) &&
671 memcmp(&lookup
->addr
.addr
, addr
, addrlen
) == 0)
680 cache
->flags
= flags
;
682 memcpy(&cache
->addr
.addr
, addr
, addrlen
);
685 /* don't need to do alias stuff for second and subsequent addresses. */
687 for (a
= daemon
->cnames
; a
; a
= a
->next
)
688 if (hostname_isequal(cache
->name
.sname
, a
->target
) &&
689 (lookup
= whine_malloc(sizeof(struct crec
))))
691 lookup
->flags
= F_FORWARD
| F_IMMORTAL
| F_NAMEP
| F_HOSTS
| F_CNAME
;
692 lookup
->name
.namep
= a
->alias
;
693 lookup
->addr
.cname
.cache
= cache
;
694 lookup
->addr
.cname
.uid
= index
;
699 static int eatspace(FILE *f
)
705 if ((c
= getc(f
)) == '#')
706 while (c
!= '\n' && c
!= EOF
)
723 static int gettok(FILE *f
, char *token
)
729 if ((c
= getc(f
)) == EOF
)
730 return (count
== 0) ? EOF
: 1;
732 if (isspace(c
) || c
== '#')
738 if (count
< (MAXDNAME
- 1))
746 static int read_hostsfile(char *filename
, int index
, int cache_size
)
748 FILE *f
= fopen(filename
, "r");
749 char *token
= daemon
->namebuff
, *domain_suffix
= NULL
;
750 int addr_count
= 0, name_count
= cache_size
, lineno
= 0;
751 unsigned short flags
= 0, saved_flags
= 0;
752 struct all_addr addr
, saved_addr
;
753 int atnl
, addrlen
= 0, addr_dup
;
757 my_syslog(LOG_ERR
, _("failed to load names from %s: %s"), filename
, strerror(errno
));
763 while ((atnl
= gettok(f
, token
)) != EOF
)
769 if (inet_pton(AF_INET
, token
, &addr
) > 0)
771 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV4
;
773 domain_suffix
= get_domain(addr
.addr
.addr4
);
775 else if (inet_pton(AF_INET6
, token
, &addr
) > 0)
777 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV6
;
779 domain_suffix
= daemon
->domain_suffix
;
782 if ((addr
.addr
.addr4
.s_addr
= inet_addr(token
)) != (in_addr_t
) -1)
784 flags
= F_HOSTS
| F_IMMORTAL
| F_FORWARD
| F_REVERSE
| F_IPV4
;
786 domain_suffix
= get_domain(addr
.addr
.addr4
);
791 my_syslog(LOG_ERR
, _("bad address at %s line %d"), filename
, lineno
);
793 atnl
= gettok(f
, token
);
797 if (saved_flags
== flags
&& memcmp(&addr
, &saved_addr
, addrlen
) == 0)
807 /* rehash every 1000 names. */
808 if ((name_count
- cache_size
) > 1000)
811 cache_size
= name_count
;
820 if ((atnl
= gettok(f
, token
)) == EOF
)
823 fqdn
= !!strchr(token
, '.');
825 if ((canon
= canonicalise(token
, &nomem
)))
827 /* If set, add a version of the name with a default domain appended */
828 if (option_bool(OPT_EXPAND
) && domain_suffix
&& !fqdn
&&
829 (cache
= whine_malloc(sizeof(struct crec
) +
830 strlen(canon
)+2+strlen(domain_suffix
)-SMALLDNAME
)))
832 strcpy(cache
->name
.sname
, canon
);
833 strcat(cache
->name
.sname
, ".");
834 strcat(cache
->name
.sname
, domain_suffix
);
835 add_hosts_entry(cache
, &addr
, addrlen
, flags
, index
, addr_dup
);
839 if ((cache
= whine_malloc(sizeof(struct crec
) + strlen(canon
)+1-SMALLDNAME
)))
841 strcpy(cache
->name
.sname
, canon
);
842 add_hosts_entry(cache
, &addr
, addrlen
, flags
, index
, addr_dup
);
849 my_syslog(LOG_ERR
, _("bad name at %s line %d"), filename
, lineno
);
856 my_syslog(LOG_INFO
, _("read %s - %d addresses"), filename
, addr_count
);
861 void cache_reload(void)
863 struct crec
*cache
, **up
, *tmp
;
864 int i
, total_size
= daemon
->cachesize
;
865 struct hostsfile
*ah
;
867 cache_inserted
= cache_live_freed
= 0;
869 for (i
=0; i
<hash_size
; i
++)
870 for (cache
= hash_table
[i
], up
= &hash_table
[i
]; cache
; cache
= tmp
)
872 tmp
= cache
->hash_next
;
873 if (cache
->flags
& F_HOSTS
)
875 *up
= cache
->hash_next
;
878 else if (!(cache
->flags
& F_DHCP
))
880 *up
= cache
->hash_next
;
881 if (cache
->flags
& F_BIGNAME
)
883 cache
->name
.bname
->next
= big_free
;
884 big_free
= cache
->name
.bname
;
889 up
= &cache
->hash_next
;
892 if (option_bool(OPT_NO_HOSTS
) && !daemon
->addn_hosts
)
894 if (daemon
->cachesize
> 0)
895 my_syslog(LOG_INFO
, _("cleared cache"));
899 if (!option_bool(OPT_NO_HOSTS
))
900 total_size
= read_hostsfile(HOSTSFILE
, 0, total_size
);
902 daemon
->addn_hosts
= expand_filelist(daemon
->addn_hosts
);
903 for (ah
= daemon
->addn_hosts
; ah
; ah
= ah
->next
)
904 if (!(ah
->flags
& AH_INACTIVE
))
905 total_size
= read_hostsfile(ah
->fname
, ah
->index
, total_size
);
908 char *get_domain(struct in_addr addr
)
910 struct cond_domain
*c
;
912 for (c
= daemon
->cond_domain
; c
; c
= c
->next
)
913 if (ntohl(addr
.s_addr
) >= ntohl(c
->start
.s_addr
) &&
914 ntohl(addr
.s_addr
) <= ntohl(c
->end
.s_addr
))
917 return daemon
->domain_suffix
;
921 struct in_addr
a_record_from_hosts(char *name
, time_t now
)
923 struct crec
*crecp
= NULL
;
926 while ((crecp
= cache_find_by_name(crecp
, name
, now
, F_IPV4
)))
927 if (crecp
->flags
& F_HOSTS
)
928 return *(struct in_addr
*)&crecp
->addr
;
930 my_syslog(MS_DHCP
| LOG_WARNING
, _("No IPv4 address found for %s"), name
);
936 void cache_unhash_dhcp(void)
938 struct crec
*cache
, **up
;
941 for (i
=0; i
<hash_size
; i
++)
942 for (cache
= hash_table
[i
], up
= &hash_table
[i
]; cache
; cache
= cache
->hash_next
)
943 if (cache
->flags
& F_DHCP
)
945 *up
= cache
->hash_next
;
946 cache
->next
= dhcp_spare
;
950 up
= &cache
->hash_next
;
953 void cache_add_dhcp_entry(char *host_name
,
954 struct in_addr
*host_address
, time_t ttd
)
956 struct crec
*crec
= NULL
, *aliasc
;
957 unsigned short flags
= F_NAMEP
| F_DHCP
| F_FORWARD
| F_IPV4
| F_REVERSE
;
961 while ((crec
= cache_find_by_name(crec
, host_name
, 0, F_IPV4
| F_CNAME
)))
963 /* check all addresses associated with name */
964 if (crec
->flags
& F_HOSTS
)
966 /* if in hosts, don't need DHCP record */
969 if (crec
->flags
& F_CNAME
)
970 my_syslog(MS_DHCP
| LOG_WARNING
,
971 _("%s is a CNAME, not giving it to the DHCP lease of %s"),
972 host_name
, inet_ntoa(*host_address
));
973 else if (crec
->addr
.addr
.addr
.addr4
.s_addr
!= host_address
->s_addr
)
975 strcpy(daemon
->namebuff
, inet_ntoa(crec
->addr
.addr
.addr
.addr4
));
976 my_syslog(MS_DHCP
| LOG_WARNING
,
977 _("not giving name %s to the DHCP lease of %s because "
978 "the name exists in %s with address %s"),
979 host_name
, inet_ntoa(*host_address
),
980 record_source(crec
->uid
), daemon
->namebuff
);
983 else if (!(crec
->flags
& F_DHCP
))
985 cache_scan_free(host_name
, NULL
, 0, crec
->flags
& (F_IPV4
| F_CNAME
| F_FORWARD
));
986 /* scan_free deletes all addresses associated with name */
994 if ((crec
= cache_find_by_addr(NULL
, (struct all_addr
*)host_address
, 0, F_IPV4
)))
996 if (crec
->flags
& F_NEG
)
997 cache_scan_free(NULL
, (struct all_addr
*)host_address
, 0, F_IPV4
| F_REVERSE
);
999 /* avoid multiple reverse mappings */
1000 flags
&= ~F_REVERSE
;
1003 if ((crec
= dhcp_spare
))
1004 dhcp_spare
= dhcp_spare
->next
;
1005 else /* need new one */
1006 crec
= whine_malloc(sizeof(struct crec
));
1008 if (crec
) /* malloc may fail */
1010 crec
->flags
= flags
;
1012 crec
->flags
|= F_IMMORTAL
;
1015 crec
->addr
.addr
.addr
.addr4
= *host_address
;
1016 crec
->name
.namep
= host_name
;
1020 for (a
= daemon
->cnames
; a
; a
= a
->next
)
1021 if (hostname_isequal(host_name
, a
->target
))
1023 if ((aliasc
= dhcp_spare
))
1024 dhcp_spare
= dhcp_spare
->next
;
1025 else /* need new one */
1026 aliasc
= whine_malloc(sizeof(struct crec
));
1030 aliasc
->flags
= F_FORWARD
| F_NAMEP
| F_DHCP
| F_CNAME
;
1032 aliasc
->flags
|= F_IMMORTAL
;
1035 aliasc
->name
.namep
= a
->alias
;
1036 aliasc
->addr
.cname
.cache
= crec
;
1037 aliasc
->addr
.cname
.uid
= crec
->uid
;
1046 void dump_cache(time_t now
)
1048 struct server
*serv
, *serv1
;
1050 my_syslog(LOG_INFO
, _("time %lu"), (unsigned long)now
);
1051 my_syslog(LOG_INFO
, _("cache size %d, %d/%d cache insertions re-used unexpired cache entries."),
1052 daemon
->cachesize
, cache_live_freed
, cache_inserted
);
1053 my_syslog(LOG_INFO
, _("queries forwarded %u, queries answered locally %u"),
1054 daemon
->queries_forwarded
, daemon
->local_answer
);
1056 /* sum counts from different records for same server */
1057 for (serv
= daemon
->servers
; serv
; serv
= serv
->next
)
1058 serv
->flags
&= ~SERV_COUNTED
;
1060 for (serv
= daemon
->servers
; serv
; serv
= serv
->next
)
1062 (SERV_NO_ADDR
| SERV_LITERAL_ADDRESS
| SERV_COUNTED
| SERV_USE_RESOLV
| SERV_NO_REBIND
)))
1065 unsigned int queries
= 0, failed_queries
= 0;
1066 for (serv1
= serv
; serv1
; serv1
= serv1
->next
)
1067 if (!(serv1
->flags
&
1068 (SERV_NO_ADDR
| SERV_LITERAL_ADDRESS
| SERV_COUNTED
| SERV_USE_RESOLV
| SERV_NO_REBIND
)) &&
1069 sockaddr_isequal(&serv
->addr
, &serv1
->addr
))
1071 serv1
->flags
|= SERV_COUNTED
;
1072 queries
+= serv1
->queries
;
1073 failed_queries
+= serv1
->failed_queries
;
1075 port
= prettyprint_addr(&serv
->addr
, daemon
->addrbuff
);
1076 my_syslog(LOG_INFO
, _("server %s#%d: queries sent %u, retried or failed %u"), daemon
->addrbuff
, port
, queries
, failed_queries
);
1079 if (option_bool(OPT_DEBUG
) || option_bool(OPT_LOG
))
1081 struct crec
*cache
;
1083 my_syslog(LOG_INFO
, "Host Address Flags Expires");
1085 for (i
=0; i
<hash_size
; i
++)
1086 for (cache
= hash_table
[i
]; cache
; cache
= cache
->hash_next
)
1088 char *a
, *p
= daemon
->namebuff
;
1089 p
+= sprintf(p
, "%-40.40s ", cache_get_name(cache
));
1090 if ((cache
->flags
& F_NEG
) && (cache
->flags
& F_FORWARD
))
1092 else if (cache
->flags
& F_CNAME
)
1095 if (!is_outdated_cname_pointer(cache
))
1096 a
= cache_get_name(cache
->addr
.cname
.cache
);
1101 a
= daemon
->addrbuff
;
1102 if (cache
->flags
& F_IPV4
)
1103 inet_ntop(AF_INET
, &cache
->addr
.addr
, a
, ADDRSTRLEN
);
1104 else if (cache
->flags
& F_IPV6
)
1105 inet_ntop(AF_INET6
, &cache
->addr
.addr
, a
, ADDRSTRLEN
);
1109 a
= inet_ntoa(cache
->addr
.addr
.addr
.addr4
);
1111 p
+= sprintf(p
, "%-30.30s %s%s%s%s%s%s%s%s%s%s ", a
,
1112 cache
->flags
& F_IPV4
? "4" : "",
1113 cache
->flags
& F_IPV6
? "6" : "",
1114 cache
->flags
& F_CNAME
? "C" : "",
1115 cache
->flags
& F_FORWARD
? "F" : " ",
1116 cache
->flags
& F_REVERSE
? "R" : " ",
1117 cache
->flags
& F_IMMORTAL
? "I" : " ",
1118 cache
->flags
& F_DHCP
? "D" : " ",
1119 cache
->flags
& F_NEG
? "N" : " ",
1120 cache
->flags
& F_NXDOMAIN
? "X" : " ",
1121 cache
->flags
& F_HOSTS
? "H" : " ");
1122 #ifdef HAVE_BROKEN_RTC
1123 p
+= sprintf(p
, "%lu", cache
->flags
& F_IMMORTAL
? 0: (unsigned long)(cache
->ttd
- now
));
1125 p
+= sprintf(p
, "%s", cache
->flags
& F_IMMORTAL
? "\n" : ctime(&(cache
->ttd
)));
1126 /* ctime includes trailing \n - eat it */
1129 my_syslog(LOG_INFO
, daemon
->namebuff
);
1134 char *record_source(int index
)
1136 struct hostsfile
*ah
;
1141 for (ah
= daemon
->addn_hosts
; ah
; ah
= ah
->next
)
1142 if (ah
->index
== index
)
1148 void querystr(char *str
, unsigned short type
)
1152 sprintf(str
, "query[type=%d]", type
);
1153 for (i
= 0; i
< (sizeof(typestr
)/sizeof(typestr
[0])); i
++)
1154 if (typestr
[i
].type
== type
)
1155 sprintf(str
,"query[%s]", typestr
[i
].name
);
1158 void log_query(unsigned int flags
, char *name
, struct all_addr
*addr
, char *arg
)
1160 char *source
, *dest
= daemon
->addrbuff
;
1163 if (!option_bool(OPT_LOG
))
1169 inet_ntop(flags
& F_IPV4
? AF_INET
: AF_INET6
,
1170 addr
, daemon
->addrbuff
, ADDRSTRLEN
);
1172 strncpy(daemon
->addrbuff
, inet_ntoa(addr
->addr
.addr4
), ADDRSTRLEN
);
1176 if (flags
& F_REVERSE
)
1179 name
= daemon
->addrbuff
;
1184 if (flags
& F_NXDOMAIN
)
1187 dest
= "NXDOMAIN-IPv4";
1188 else if (flags
& F_IPV6
)
1189 dest
= "NXDOMAIN-IPv6";
1196 dest
= "NODATA-IPv4";
1197 else if (flags
& F_IPV6
)
1198 dest
= "NODATA-IPv6";
1203 else if (flags
& F_CNAME
)
1205 else if (flags
& F_RRNAME
)
1208 if (flags
& F_CONFIG
)
1210 else if (flags
& F_DHCP
)
1212 else if (flags
& F_HOSTS
)
1214 else if (flags
& F_UPSTREAM
)
1216 else if (flags
& F_SERVER
)
1218 source
= "forwarded";
1221 else if (flags
& F_QUERY
)
1229 if (strlen(name
) == 0)
1232 my_syslog(LOG_INFO
, "%s %s %s %s", source
, name
, verb
, dest
);