]>
git.ipfire.org Git - people/ms/dnsmasq.git/blob - src/forward.c
1 /* dnsmasq is Copyright (c) 2000 - 2005 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.
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
15 static struct frec
*frec_list
= NULL
;
17 static struct frec
*lookup_frec(unsigned short id
);
18 static struct frec
*lookup_frec_by_sender(unsigned short id
,
19 union mysockaddr
*addr
,
21 static unsigned short get_id(void);
24 /* Send a UDP packet with it's source address set as "source"
25 unless nowild is true, when we just send it with the kernel default */
26 static void send_from(int fd
, int nowild
, char *packet
, size_t len
,
27 union mysockaddr
*to
, struct all_addr
*source
,
33 struct cmsghdr align
; /* this ensures alignment */
34 #if defined(HAVE_LINUX_NETWORK)
35 char control
[CMSG_SPACE(sizeof(struct in_pktinfo
))];
36 #elif defined(IP_SENDSRCADDR)
37 char control
[CMSG_SPACE(sizeof(struct in_addr
))];
40 char control6
[CMSG_SPACE(sizeof(struct in6_pktinfo
))];
44 iov
[0].iov_base
= packet
;
47 msg
.msg_control
= NULL
;
48 msg
.msg_controllen
= 0;
51 msg
.msg_namelen
= sa_len(to
);
57 struct cmsghdr
*cmptr
;
58 msg
.msg_control
= &control_u
;
59 msg
.msg_controllen
= sizeof(control_u
);
60 cmptr
= CMSG_FIRSTHDR(&msg
);
62 if (to
->sa
.sa_family
== AF_INET
)
64 #if defined(HAVE_LINUX_NETWORK)
65 struct in_pktinfo
*pkt
= (struct in_pktinfo
*)CMSG_DATA(cmptr
);
67 pkt
->ipi_spec_dst
= source
->addr
.addr4
;
68 msg
.msg_controllen
= cmptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_pktinfo
));
69 cmptr
->cmsg_level
= SOL_IP
;
70 cmptr
->cmsg_type
= IP_PKTINFO
;
71 #elif defined(IP_SENDSRCADDR)
72 struct in_addr
*a
= (struct in_addr
*)CMSG_DATA(cmptr
);
73 *a
= source
->addr
.addr4
;
74 msg
.msg_controllen
= cmptr
->cmsg_len
= CMSG_LEN(sizeof(struct in_addr
));
75 cmptr
->cmsg_level
= IPPROTO_IP
;
76 cmptr
->cmsg_type
= IP_SENDSRCADDR
;
82 struct in6_pktinfo
*pkt
= (struct in6_pktinfo
*)CMSG_DATA(cmptr
);
83 pkt
->ipi6_ifindex
= iface
; /* Need iface for IPv6 to handle link-local addrs */
84 pkt
->ipi6_addr
= source
->addr
.addr6
;
85 msg
.msg_controllen
= cmptr
->cmsg_len
= CMSG_LEN(sizeof(struct in6_pktinfo
));
86 cmptr
->cmsg_type
= IPV6_PKTINFO
;
87 cmptr
->cmsg_level
= IPV6_LEVEL
;
90 iface
= 0; /* eliminate warning */
95 if (sendmsg(fd
, &msg
, 0) == -1)
97 /* certain Linux kernels seem to object to setting the source address in the IPv6 stack
98 by returning EINVAL from sendmsg. In that case, try again without setting the
99 source address, since it will nearly alway be correct anyway. IPv6 stinks. */
100 if (errno
== EINVAL
&& msg
.msg_controllen
)
102 msg
.msg_controllen
= 0;
110 static unsigned short search_servers(struct daemon
*daemon
, time_t now
, struct all_addr
**addrpp
,
111 unsigned short qtype
, char *qdomain
, int *type
, char **domain
)
114 /* If the query ends in the domain in one of our servers, set
115 domain to point to that name. We find the largest match to allow both
116 domain.org and sub.domain.org to exist. */
118 unsigned int namelen
= strlen(qdomain
);
119 unsigned int matchlen
= 0;
121 unsigned short flags
= 0;
123 for (serv
= daemon
->servers
; serv
; serv
=serv
->next
)
124 /* domain matches take priority over NODOTS matches */
125 if ((serv
->flags
& SERV_FOR_NODOTS
) && *type
!= SERV_HAS_DOMAIN
&& !strchr(qdomain
, '.') && namelen
!= 0)
127 unsigned short sflag
= serv
->addr
.sa
.sa_family
== AF_INET
? F_IPV4
: F_IPV6
;
128 *type
= SERV_FOR_NODOTS
;
129 if (serv
->flags
& SERV_NO_ADDR
)
131 else if (serv
->flags
& SERV_LITERAL_ADDRESS
)
136 if (serv
->addr
.sa
.sa_family
== AF_INET
)
137 *addrpp
= (struct all_addr
*)&serv
->addr
.in
.sin_addr
;
140 *addrpp
= (struct all_addr
*)&serv
->addr
.in6
.sin6_addr
;
147 else if (serv
->flags
& SERV_HAS_DOMAIN
)
149 unsigned int domainlen
= strlen(serv
->domain
);
150 char *matchstart
= qdomain
+ namelen
- domainlen
;
151 if (namelen
>= domainlen
&&
152 hostname_isequal(matchstart
, serv
->domain
) &&
153 domainlen
>= matchlen
&&
154 (domainlen
== 0 || namelen
== domainlen
|| *(serv
->domain
) == '.' || *(matchstart
-1) == '.' ))
156 unsigned short sflag
= serv
->addr
.sa
.sa_family
== AF_INET
? F_IPV4
: F_IPV6
;
157 *type
= SERV_HAS_DOMAIN
;
158 *domain
= serv
->domain
;
159 matchlen
= domainlen
;
160 if (serv
->flags
& SERV_NO_ADDR
)
162 else if (serv
->flags
& SERV_LITERAL_ADDRESS
)
164 if ((sflag
| F_QUERY
) & qtype
)
167 if (serv
->addr
.sa
.sa_family
== AF_INET
)
168 *addrpp
= (struct all_addr
*)&serv
->addr
.in
.sin_addr
;
171 *addrpp
= (struct all_addr
*)&serv
->addr
.in6
.sin6_addr
;
180 if (flags
& ~(F_NOERR
| F_NXDOMAIN
)) /* flags set here means a literal found */
183 log_query(F_CONFIG
| F_FORWARD
| F_NEG
, qdomain
, NULL
, 0, NULL
, 0);
185 log_query(F_CONFIG
| F_FORWARD
| flags
, qdomain
, *addrpp
, 0, NULL
, 0);
187 else if (qtype
&& (daemon
->options
& OPT_NODOTS_LOCAL
) && !strchr(qdomain
, '.') && namelen
!= 0)
190 if (flags
== F_NXDOMAIN
&& check_for_local_domain(qdomain
, now
, daemon
))
193 if (flags
== F_NXDOMAIN
|| flags
== F_NOERR
)
194 log_query(F_CONFIG
| F_FORWARD
| F_NEG
| qtype
| (flags
& F_NXDOMAIN
), qdomain
, NULL
, 0, NULL
, 0);
199 /* returns new last_server */
200 static void forward_query(struct daemon
*daemon
, int udpfd
, union mysockaddr
*udpaddr
,
201 struct all_addr
*dst_addr
, unsigned int dst_iface
,
202 HEADER
*header
, size_t plen
, time_t now
, struct frec
*forward
)
206 struct all_addr
*addrp
= NULL
;
207 unsigned int crc
= questions_crc(header
, plen
, daemon
->namebuff
);
208 unsigned short flags
= 0;
209 unsigned short gotname
= extract_request(header
, plen
, daemon
->namebuff
, NULL
);
210 struct server
*start
= NULL
;
212 /* may be no servers available. */
213 if (!daemon
->servers
)
215 else if (forward
|| (forward
= lookup_frec_by_sender(ntohs(header
->id
), udpaddr
, crc
)))
217 /* retry on existing query, send to all available servers */
218 domain
= forward
->sentto
->domain
;
219 if (!(daemon
->options
& OPT_ORDER
))
221 forward
->forwardall
= 1;
222 daemon
->last_server
= NULL
;
224 type
= forward
->sentto
->flags
& SERV_TYPE
;
225 if (!(start
= forward
->sentto
->next
))
226 start
= daemon
->servers
; /* at end of list, recycle */
227 header
->id
= htons(forward
->new_id
);
232 flags
= search_servers(daemon
, now
, &addrp
, gotname
, daemon
->namebuff
, &type
, &domain
);
234 if (!flags
&& !(forward
= get_new_frec(daemon
, now
, NULL
)))
235 /* table full - server failure. */
240 forward
->source
= *udpaddr
;
241 forward
->dest
= *dst_addr
;
242 forward
->iface
= dst_iface
;
243 forward
->new_id
= get_id();
245 forward
->orig_id
= ntohs(header
->id
);
247 forward
->forwardall
= 0;
248 header
->id
= htons(forward
->new_id
);
250 /* In strict_order mode, or when using domain specific servers
251 always try servers in the order specified in resolv.conf,
252 otherwise, use the one last known to work. */
254 if (type
!= 0 || (daemon
->options
& OPT_ORDER
))
255 start
= daemon
->servers
;
256 else if (!(start
= daemon
->last_server
))
258 start
= daemon
->servers
;
259 forward
->forwardall
= 1;
264 /* check for send errors here (no route to host)
265 if we fail to send to all nameservers, send back an error
266 packet straight away (helps modem users when offline) */
268 if (!flags
&& forward
)
270 struct server
*firstsentto
= start
;
275 /* only send to servers dealing with our domain.
276 domain may be NULL, in which case server->domain
277 must be NULL also. */
279 if (type
== (start
->flags
& SERV_TYPE
) &&
280 (type
!= SERV_HAS_DOMAIN
|| hostname_isequal(domain
, start
->domain
)) &&
281 !(start
->flags
& SERV_LITERAL_ADDRESS
))
283 if (sendto(start
->sfd
->fd
, (char *)header
, plen
, 0,
285 sa_len(&start
->addr
)) == -1)
292 /* Keep info in case we want to re-send this packet */
293 daemon
->srv_save
= start
;
294 daemon
->packet_len
= plen
;
297 strcpy(daemon
->namebuff
, "query");
298 if (start
->addr
.sa
.sa_family
== AF_INET
)
299 log_query(F_SERVER
| F_IPV4
| F_FORWARD
, daemon
->namebuff
,
300 (struct all_addr
*)&start
->addr
.in
.sin_addr
, 0,
304 log_query(F_SERVER
| F_IPV6
| F_FORWARD
, daemon
->namebuff
,
305 (struct all_addr
*)&start
->addr
.in6
.sin6_addr
, 0,
309 forward
->sentto
= start
;
310 if (!forward
->forwardall
)
312 forward
->forwardall
++;
316 if (!(start
= start
->next
))
317 start
= daemon
->servers
;
319 if (start
== firstsentto
)
326 /* could not send on, prepare to return */
327 header
->id
= htons(forward
->orig_id
);
328 forward
->new_id
= 0; /* cancel */
331 /* could not send on, return empty answer or address if known for whole domain */
334 plen
= setup_reply(header
, plen
, addrp
, flags
, daemon
->local_ttl
);
335 send_from(udpfd
, daemon
->options
& OPT_NOWILD
, (char *)header
, plen
, udpaddr
, dst_addr
, dst_iface
);
341 static size_t process_reply(struct daemon
*daemon
, HEADER
*header
, time_t now
,
342 unsigned int query_crc
, struct server
*server
, size_t n
)
344 unsigned char *pheader
, *sizep
;
348 /* If upstream is advertising a larger UDP packet size
349 than we allow, trim it so that we don't get overlarge
350 requests for the client. */
352 if ((pheader
= find_pseudoheader(header
, n
, &plen
, &sizep
)))
354 unsigned short udpsz
;
355 unsigned char *psave
= sizep
;
357 GETSHORT(udpsz
, sizep
);
358 if (udpsz
> daemon
->edns_pktsz
)
359 PUTSHORT(daemon
->edns_pktsz
, psave
);
362 if (header
->opcode
!= QUERY
|| (header
->rcode
!= NOERROR
&& header
->rcode
!= NXDOMAIN
))
365 /* Complain loudly if the upstream server is non-recursive. */
366 if (!header
->ra
&& header
->rcode
== NOERROR
&& ntohs(header
->ancount
) == 0 &&
367 server
&& !(server
->flags
& SERV_WARNED_RECURSIVE
))
369 prettyprint_addr(&server
->addr
, daemon
->namebuff
);
370 syslog(LOG_WARNING
, _("nameserver %s refused to do a recursive query"), daemon
->namebuff
);
371 if (!(daemon
->options
& OPT_LOG
))
372 server
->flags
|= SERV_WARNED_RECURSIVE
;
375 if (daemon
->bogus_addr
&& header
->rcode
!= NXDOMAIN
&&
376 check_for_bogus_wildcard(header
, n
, daemon
->namebuff
, daemon
->bogus_addr
, now
))
379 header
->rcode
= NXDOMAIN
;
384 if (header
->rcode
== NXDOMAIN
&&
385 extract_request(header
, n
, daemon
->namebuff
, NULL
) &&
386 check_for_local_domain(daemon
->namebuff
, now
, daemon
))
388 /* if we forwarded a query for a locally known name (because it was for
389 an unknown type) and the answer is NXDOMAIN, convert that to NODATA,
390 since we know that the domain exists, even if upstream doesn't */
393 header
->rcode
= NOERROR
;
396 /* If the crc of the question section doesn't match the crc we sent, then
397 someone might be attempting to insert bogus values into the cache by
398 sending replies containing questions and bogus answers. */
399 if (query_crc
== questions_crc(header
, n
, daemon
->namebuff
))
400 extract_addresses(header
, n
, daemon
->namebuff
, now
, daemon
);
403 /* do this after extract_addresses. Ensure NODATA reply and remove
408 header
->ancount
= htons(0);
409 header
->nscount
= htons(0);
410 header
->arcount
= htons(0);
413 /* the bogus-nxdomain stuff, doctor and NXDOMAIN->NODATA munging can all elide
414 sections of the packet. Find the new length here and put back pseudoheader
415 if it was removed. */
416 return resize_packet(header
, n
, pheader
, plen
);
419 /* sets new last_server */
420 void reply_query(struct serverfd
*sfd
, struct daemon
*daemon
, time_t now
)
422 /* packet from peer server, extract data for cache, and send to
423 original requester */
424 struct frec
*forward
;
426 union mysockaddr serveraddr
;
427 socklen_t addrlen
= sizeof(serveraddr
);
428 ssize_t n
= recvfrom(sfd
->fd
, daemon
->packet
, daemon
->edns_pktsz
, 0, &serveraddr
.sa
, &addrlen
);
431 /* packet buffer overwritten */
432 daemon
->srv_save
= NULL
;
434 /* Determine the address of the server replying so that we can mark that as good */
435 serveraddr
.sa
.sa_family
= sfd
->source_addr
.sa
.sa_family
;
437 if (serveraddr
.sa
.sa_family
== AF_INET6
)
438 serveraddr
.in6
.sin6_flowinfo
= 0;
441 header
= (HEADER
*)daemon
->packet
;
442 forward
= lookup_frec(ntohs(header
->id
));
444 if (n
>= (int)sizeof(HEADER
) && header
->qr
&& forward
)
446 struct server
*server
= forward
->sentto
;
448 if ((header
->rcode
== SERVFAIL
|| header
->rcode
== REFUSED
) && forward
->forwardall
== 0)
449 /* for broken servers, attempt to send to another one. */
451 unsigned char *pheader
;
454 /* recreate query from reply */
455 pheader
= find_pseudoheader(header
, (size_t)n
, &plen
, NULL
);
456 header
->ancount
= htons(0);
457 header
->nscount
= htons(0);
458 header
->arcount
= htons(0);
459 if ((nn
= resize_packet(header
, (size_t)n
, pheader
, plen
)))
463 forward_query(daemon
, -1, NULL
, NULL
, 0, header
, nn
, now
, forward
);
468 if ((forward
->sentto
->flags
& SERV_TYPE
) == 0)
470 if (header
->rcode
== SERVFAIL
|| header
->rcode
== REFUSED
)
474 struct server
*last_server
;
475 /* find good server by address if possible, otherwise assume the last one we sent to */
476 for (last_server
= daemon
->servers
; last_server
; last_server
= last_server
->next
)
477 if (!(last_server
->flags
& (SERV_LITERAL_ADDRESS
| SERV_HAS_DOMAIN
| SERV_FOR_NODOTS
| SERV_NO_ADDR
)) &&
478 sockaddr_isequal(&last_server
->addr
, &serveraddr
))
480 server
= last_server
;
484 daemon
->last_server
= server
;
487 /* If the answer is an error, keep the forward record in place in case
488 we get a good reply from another server. Kill it when we've
489 had replies from all to avoid filling the forwarding table when
490 everything is broken */
491 if (forward
->forwardall
== 0 || --forward
->forwardall
== 1 ||
492 (header
->rcode
!= REFUSED
&& header
->rcode
!= SERVFAIL
))
494 if ((nn
= process_reply(daemon
, header
, now
, forward
->crc
, server
, (size_t)n
)))
496 header
->id
= htons(forward
->orig_id
);
497 header
->ra
= 1; /* recursion if available */
498 send_from(forward
->fd
, daemon
->options
& OPT_NOWILD
, daemon
->packet
, nn
,
499 &forward
->source
, &forward
->dest
, forward
->iface
);
501 forward
->new_id
= 0; /* cancel */
506 void receive_query(struct listener
*listen
, struct daemon
*daemon
, time_t now
)
508 HEADER
*header
= (HEADER
*)daemon
->packet
;
509 union mysockaddr source_addr
;
511 struct all_addr dst_addr
;
512 struct in_addr netmask
, dst_addr_4
;
518 struct cmsghdr
*cmptr
;
520 struct cmsghdr align
; /* this ensures alignment */
522 char control6
[CMSG_SPACE(sizeof(struct in6_pktinfo
))];
524 #if defined(HAVE_LINUX_NETWORK)
525 char control
[CMSG_SPACE(sizeof(struct in_pktinfo
))];
526 #elif defined(IP_RECVDSTADDR)
527 char control
[CMSG_SPACE(sizeof(struct in_addr
)) +
528 CMSG_SPACE(sizeof(struct sockaddr_dl
))];
532 /* packet buffer overwritten */
533 daemon
->srv_save
= NULL
;
535 if (listen
->family
== AF_INET
&& (daemon
->options
& OPT_NOWILD
))
537 dst_addr_4
= listen
->iface
->addr
.in
.sin_addr
;
538 netmask
= listen
->iface
->netmask
;
542 dst_addr_4
.s_addr
= 0;
546 iov
[0].iov_base
= daemon
->packet
;
547 iov
[0].iov_len
= daemon
->edns_pktsz
;
549 msg
.msg_control
= control_u
.control
;
550 msg
.msg_controllen
= sizeof(control_u
);
552 msg
.msg_name
= &source_addr
;
553 msg
.msg_namelen
= sizeof(source_addr
);
557 if ((n
= recvmsg(listen
->fd
, &msg
, 0)) == -1)
560 if (n
< (int)sizeof(HEADER
) ||
561 (msg
.msg_flags
& MSG_TRUNC
) ||
565 source_addr
.sa
.sa_family
= listen
->family
;
567 if (listen
->family
== AF_INET6
)
568 source_addr
.in6
.sin6_flowinfo
= 0;
571 if (!(daemon
->options
& OPT_NOWILD
))
575 if (msg
.msg_controllen
< sizeof(struct cmsghdr
))
578 #if defined(HAVE_LINUX_NETWORK)
579 if (listen
->family
== AF_INET
)
580 for (cmptr
= CMSG_FIRSTHDR(&msg
); cmptr
; cmptr
= CMSG_NXTHDR(&msg
, cmptr
))
581 if (cmptr
->cmsg_level
== SOL_IP
&& cmptr
->cmsg_type
== IP_PKTINFO
)
583 dst_addr_4
= dst_addr
.addr
.addr4
= ((struct in_pktinfo
*)CMSG_DATA(cmptr
))->ipi_spec_dst
;
584 if_index
= ((struct in_pktinfo
*)CMSG_DATA(cmptr
))->ipi_ifindex
;
586 #elif defined(IP_RECVDSTADDR) && defined(IP_RECVIF)
587 if (listen
->family
== AF_INET
)
589 for (cmptr
= CMSG_FIRSTHDR(&msg
); cmptr
; cmptr
= CMSG_NXTHDR(&msg
, cmptr
))
590 if (cmptr
->cmsg_level
== IPPROTO_IP
&& cmptr
->cmsg_type
== IP_RECVDSTADDR
)
591 dst_addr_4
= dst_addr
.addr
.addr4
= *((struct in_addr
*)CMSG_DATA(cmptr
));
592 else if (cmptr
->cmsg_level
== IPPROTO_IP
&& cmptr
->cmsg_type
== IP_RECVIF
)
593 if_index
= ((struct sockaddr_dl
*)CMSG_DATA(cmptr
))->sdl_index
;
598 if (listen
->family
== AF_INET6
)
600 for (cmptr
= CMSG_FIRSTHDR(&msg
); cmptr
; cmptr
= CMSG_NXTHDR(&msg
, cmptr
))
601 if (cmptr
->cmsg_level
== IPV6_LEVEL
&& cmptr
->cmsg_type
== IPV6_PKTINFO
)
603 dst_addr
.addr
.addr6
= ((struct in6_pktinfo
*)CMSG_DATA(cmptr
))->ipi6_addr
;
604 if_index
=((struct in6_pktinfo
*)CMSG_DATA(cmptr
))->ipi6_ifindex
;
609 /* enforce available interface configuration */
614 if (daemon
->if_except
|| daemon
->if_names
|| (daemon
->options
& OPT_LOCALISE
))
617 ifr
.ifr_ifindex
= if_index
;
618 if (ioctl(listen
->fd
, SIOCGIFNAME
, &ifr
) == -1)
621 if (!if_indextoname(if_index
, ifr
.ifr_name
))
625 if (listen
->family
== AF_INET
&&
626 (daemon
->options
& OPT_LOCALISE
) &&
627 ioctl(listen
->fd
, SIOCGIFNETMASK
, &ifr
) == -1)
630 netmask
= ((struct sockaddr_in
*) &ifr
.ifr_addr
)->sin_addr
;
633 if (!iface_check(daemon
, listen
->family
, &dst_addr
, ifr
.ifr_name
))
637 if (extract_request(header
, (size_t)n
, daemon
->namebuff
, &type
))
639 if (listen
->family
== AF_INET
)
640 log_query(F_QUERY
| F_IPV4
| F_FORWARD
, daemon
->namebuff
,
641 (struct all_addr
*)&source_addr
.in
.sin_addr
, type
, NULL
, 0);
644 log_query(F_QUERY
| F_IPV6
| F_FORWARD
, daemon
->namebuff
,
645 (struct all_addr
*)&source_addr
.in6
.sin6_addr
, type
, NULL
, 0);
649 m
= answer_request (header
, ((char *) header
) + PACKETSZ
, (size_t)n
, daemon
,
650 dst_addr_4
, netmask
, now
);
652 send_from(listen
->fd
, daemon
->options
& OPT_NOWILD
, (char *)header
, m
, &source_addr
, &dst_addr
, if_index
);
654 forward_query(daemon
, listen
->fd
, &source_addr
, &dst_addr
, if_index
,
655 header
, (size_t)n
, now
, NULL
);
658 /* The daemon forks before calling this: it should deal with one connection,
659 blocking as neccessary, and then return. Note, need to be a bit careful
660 about resources for debug mode, when the fork is suppressed: that's
661 done by the caller. */
662 unsigned char *tcp_request(struct daemon
*daemon
, int confd
, time_t now
,
663 struct in_addr local_addr
, struct in_addr netmask
)
667 unsigned short qtype
, gotname
;
668 unsigned char c1
, c2
;
669 /* Max TCP packet + slop */
670 unsigned char *packet
= malloc(65536 + MAXDNAME
+ RRFIXEDSZ
);
672 struct server
*last_server
;
677 !read_write(confd
, &c1
, 1, 1) || !read_write(confd
, &c2
, 1, 1) ||
678 !(size
= c1
<< 8 | c2
) ||
679 !read_write(confd
, packet
, size
, 1))
682 if (size
< (int)sizeof(HEADER
))
685 header
= (HEADER
*)packet
;
687 if ((gotname
= extract_request(header
, (unsigned int)size
, daemon
->namebuff
, &qtype
)))
689 union mysockaddr peer_addr
;
690 socklen_t peer_len
= sizeof(union mysockaddr
);
692 if (getpeername(confd
, (struct sockaddr
*)&peer_addr
, &peer_len
) != -1)
694 if (peer_addr
.sa
.sa_family
== AF_INET
)
695 log_query(F_QUERY
| F_IPV4
| F_FORWARD
, daemon
->namebuff
,
696 (struct all_addr
*)&peer_addr
.in
.sin_addr
, qtype
, NULL
, 0);
699 log_query(F_QUERY
| F_IPV6
| F_FORWARD
, daemon
->namebuff
,
700 (struct all_addr
*)&peer_addr
.in6
.sin6_addr
, qtype
, NULL
, 0);
705 /* m > 0 if answered from cache */
706 m
= answer_request(header
, ((char *) header
) + 65536, (unsigned int)size
, daemon
,
707 local_addr
, netmask
, now
);
711 unsigned short flags
= 0;
712 struct all_addr
*addrp
= NULL
;
717 flags
= search_servers(daemon
, now
, &addrp
, gotname
, daemon
->namebuff
, &type
, &domain
);
719 if (type
!= 0 || (daemon
->options
& OPT_ORDER
) || !daemon
->last_server
)
720 last_server
= daemon
->servers
;
722 last_server
= daemon
->last_server
;
724 if (!flags
&& last_server
)
726 struct server
*firstsendto
= NULL
;
727 unsigned int crc
= questions_crc(header
, (unsigned int)size
, daemon
->namebuff
);
729 /* Loop round available servers until we succeed in connecting to one.
730 Note that this code subtley ensures that consecutive queries on this connection
731 which can go to the same server, do so. */
735 firstsendto
= last_server
;
738 if (!(last_server
= last_server
->next
))
739 last_server
= daemon
->servers
;
741 if (last_server
== firstsendto
)
745 /* server for wrong domain */
746 if (type
!= (last_server
->flags
& SERV_TYPE
) ||
747 (type
== SERV_HAS_DOMAIN
&& !hostname_isequal(domain
, last_server
->domain
)))
750 if ((last_server
->tcpfd
== -1) &&
751 (last_server
->tcpfd
= socket(last_server
->addr
.sa
.sa_family
, SOCK_STREAM
, 0)) != -1 &&
752 connect(last_server
->tcpfd
, &last_server
->addr
.sa
, sa_len(&last_server
->addr
)) == -1)
754 close(last_server
->tcpfd
);
755 last_server
->tcpfd
= -1;
758 if (last_server
->tcpfd
== -1)
764 if (!read_write(last_server
->tcpfd
, &c1
, 1, 0) ||
765 !read_write(last_server
->tcpfd
, &c2
, 1, 0) ||
766 !read_write(last_server
->tcpfd
, packet
, size
, 0) ||
767 !read_write(last_server
->tcpfd
, &c1
, 1, 1) ||
768 !read_write(last_server
->tcpfd
, &c2
, 1, 1))
770 close(last_server
->tcpfd
);
771 last_server
->tcpfd
= -1;
776 if (!read_write(last_server
->tcpfd
, packet
, m
, 1))
780 strcpy(daemon
->namebuff
, "query");
781 if (last_server
->addr
.sa
.sa_family
== AF_INET
)
782 log_query(F_SERVER
| F_IPV4
| F_FORWARD
, daemon
->namebuff
,
783 (struct all_addr
*)&last_server
->addr
.in
.sin_addr
, 0, NULL
, 0);
786 log_query(F_SERVER
| F_IPV6
| F_FORWARD
, daemon
->namebuff
,
787 (struct all_addr
*)&last_server
->addr
.in6
.sin6_addr
, 0, NULL
, 0);
790 /* There's no point in updating the cache, since this process will exit and
791 lose the information after one query. We make this call for the alias and
792 bogus-nxdomain side-effects. */
793 m
= process_reply(daemon
, header
, now
, crc
, last_server
, (unsigned int)m
);
799 /* In case of local answer or no connections made. */
801 m
= setup_reply(header
, (unsigned int)size
, addrp
, flags
, daemon
->local_ttl
);
806 if (!read_write(confd
, &c1
, 1, 0) ||
807 !read_write(confd
, &c2
, 1, 0) ||
808 !read_write(confd
, packet
, m
, 0))
813 static struct frec
*allocate_frec(time_t now
)
817 if ((f
= (struct frec
*)malloc(sizeof(struct frec
))))
828 /* if wait==NULL return a free or older than TIMEOUT record.
829 else return *wait zero if one available, or *wait is delay to
830 when the oldest in-use record will expire. */
831 struct frec
*get_new_frec(struct daemon
*daemon
, time_t now
, int *wait
)
833 struct frec
*f
, *oldest
;
839 for (f
= frec_list
, oldest
= NULL
, count
= 0; f
; f
= f
->next
, count
++)
845 else if (!oldest
|| difftime(f
->time
, oldest
->time
) <= 0)
848 /* can't find empty one, use oldest if there is one
849 and it's older than timeout */
850 if (oldest
&& ((int)difftime(now
, oldest
->time
)) >= TIMEOUT
)
852 /* keep stuff for twice timeout if we can by allocating a new
854 if (difftime(now
, oldest
->time
) < 2*TIMEOUT
&&
855 count
<= daemon
->ftabsize
&&
856 (f
= allocate_frec(now
)))
867 /* none available, calculate time 'till oldest record expires */
868 if (count
> daemon
->ftabsize
)
871 *wait
= oldest
->time
+ (time_t)TIMEOUT
- now
;
875 if (!(f
= allocate_frec(now
)) && wait
)
876 /* wait one second on malloc failure */
879 return f
; /* OK if malloc fails and this is NULL */
882 static struct frec
*lookup_frec(unsigned short id
)
886 for(f
= frec_list
; f
; f
= f
->next
)
893 static struct frec
*lookup_frec_by_sender(unsigned short id
,
894 union mysockaddr
*addr
,
899 for(f
= frec_list
; f
; f
= f
->next
)
903 sockaddr_isequal(&f
->source
, addr
))
909 /* A server record is going away, remove references to it */
910 void server_gone(struct daemon
*daemon
, struct server
*server
)
914 for (f
= frec_list
; f
; f
= f
->next
)
915 if (f
->new_id
!= 0 && f
->sentto
== server
)
918 if (daemon
->last_server
== server
)
919 daemon
->last_server
= NULL
;
921 if (daemon
->srv_save
== server
)
922 daemon
->srv_save
= NULL
;
925 /* return unique random ids between 1 and 65535 */
926 static unsigned short get_id(void)
928 unsigned short ret
= 0;
934 /* scrap ids already in use */
935 if ((ret
!= 0) && lookup_frec(ret
))